Java-Gaming.org Hi !
Featured games (91)
games approved by the League of Dukes
Games in Showcase (799)
Games in Android Showcase (237)
games submitted by our members
Games in WIP (865)
games currently in development
News: Read the Java Gaming Resources, or peek at the official Java tutorials
 
    Home     Help   Search   Login   Register   
Pages: 1 ... 121 122 [123] 124 125 ... 215
  ignore  |  Print  
  What I did today  (Read 3549101 times)
0 Members and 7 Guests are viewing this topic.
Offline EgonOlsen
« Reply #3660 - Posted 2016-02-07 11:27:26 »

Darn I don't have any device that can play it Sad
Which device do you have?

Offline SHC
« Reply #3661 - Posted 2016-02-07 11:38:37 »

I think I improved in cubing, got 1:14 as my best solve today - with only F2L. Other than that, I did a quick implementation of a CPU like program to present in CO (Computer Organisation) class.

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
CPU cpu = new CPU(new Accumulator(), new Memory(3));

cpu.defineOperation(/* GET */ 0, (ac, mem, address) -> ac.value = mem.get(address));
cpu.defineOperation(/* ADD */ 1, (ac, mem, address) -> ac.value += mem.get(address));
cpu.defineOperation(/* STO */ 2, (ac, mem, address) -> mem.set(address, ac.value));
cpu.defineOperation(/* PRI */ 3, (ac, mem, address) -> System.out.println(mem.get(address)));

Instruction[] program = new Instruction[] {
        new Instruction(0, 0),   // Get the value at address 0
        new Instruction(1, 1),   // Add the value at address 1
        new Instruction(2, 2),   // Store the result into address 2
        new Instruction(3, 2)    // Print the value at address 2
};

cpu.memory.set(0, (byte) 2);  // Set the value 2 at address 0
cpu.memory.set(1, (byte) 5);  // Set the value 5 at address 1

Arrays.stream(program).forEach(cpu::execute);

I know this is not any better considering what we today have, but is enough for me to get some impression in class before lecturers.

Offline J0
« Reply #3662 - Posted 2016-02-07 11:52:10 »

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
CPU cpu = new CPU(new Accumulator(), new Memory(3));

cpu.defineOperation(/* GET */ 0, (ac, mem, address) -> ac.value = mem.get(address));
cpu.defineOperation(/* ADD */ 1, (ac, mem, address) -> ac.value += mem.get(address));
cpu.defineOperation(/* STO */ 2, (ac, mem, address) -> mem.set(address, ac.value));
cpu.defineOperation(/* PRI */ 3, (ac, mem, address) -> System.out.println(mem.get(address)));

Instruction[] program = new Instruction[] {
        new Instruction(0, 0),   // Get the value at address 0
        new Instruction(1, 1),   // Add the value at address 1
        new Instruction(2, 2),   // Store the result into address 2
        new Instruction(3, 2)    // Print the value at address 2
};

cpu.memory.set(0, (byte) 2);  // Set the value 2 at address 0
cpu.memory.set(1, (byte) 5);  // Set the value 5 at address 1

Arrays.stream(program).forEach(cpu::execute);


Would it not make it more readable to add a few static final integers?
Like so:
1  
public static final int GET = 0, ADD = 1, STO = 2, PRI = 3;

Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline SHC
« Reply #3663 - Posted 2016-02-07 11:55:13 »

Yes, it would increase readability, but all I wanted is a quick prototype to show there. I'll add it right now, thanks.

Offline J0
« Reply #3664 - Posted 2016-02-07 14:55:48 »

Not WIP material right here, mainly because I'm so far from finishing this project, but I recently set up a devlog for Alba on Google Drive, it greatly helps me coding faster! Although I still have a lot to do for school... Anyway, feel free to check it out Smiley
https://docs.google.com/document/d/14te43lfHLqNGmSIkq-8NkU8tsvgEnaukwZfKv74yDGE/edit
(If you go through this and spot an English mistake, please do correct me!)

J0

Offline Slyth2727
« Reply #3665 - Posted 2016-02-07 19:11:58 »

I think I improved in cubing, got 1:14 as my best solve today - with only F2L. Other than that, I did a quick implementation of a CPU like program to present in CO (Computer Organisation) class.

Good job! If you're in the US and have the ability to travel to oregon, you should go to nationals this year! It's a great experience and nobody really cares about your times, plenty of people with barely sub 2 minute averages attend.
Offline Archive
« Reply #3666 - Posted 2016-02-07 22:02:28 »

A video showing weather particles, mining, and equipment wearing Smiley

<a href="http://www.youtube.com/v/m73BzqxtDDU?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/m73BzqxtDDU?version=3&amp;hl=en_US&amp;start=</a>

Offline DarkCart

JGO Kernel


Medals: 124
Projects: 9
Exp: 50 years


It's all in the mind, y'know.


« Reply #3667 - Posted 2016-02-08 00:48:40 »

I set up a small website for myself. With CSS by @Jervac

(It's hosted on the old Wybuuk server)

http://www.darkcart.co

The darkest of carts.
Offline orange451

JGO Kernel


Medals: 544
Projects: 8
Exp: 8 years


Your face? Your ass? What's the difference?


« Reply #3668 - Posted 2016-02-08 03:02:04 »

Which device do you have?

A desktop Smiley

First Recon. A java made online first person shooter!
Offline Opiop
« Reply #3669 - Posted 2016-02-08 04:55:33 »



I finally did it, 1999 CBR600f4. This thing is either going to kill me or take me to the moon!
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline Slyth2727
« Reply #3670 - Posted 2016-02-08 05:39:26 »

Wow! I know nothing about bikes, but it looks pretty awesome if that means anything.
The jacket is a nice addition Smiley
Offline Coldstream24

JGO Ninja


Medals: 82
Projects: 1
Exp: 4 years


You can fill that void inside with programming, but you'll never return a value.


« Reply #3671 - Posted 2016-02-08 08:37:50 »


Been pretty busy with implementing more features into my engine - it's inching closer to actually being able to build a game. There's the animation editor and the dialogue editor side-by-side. Building the visualiser for a dialogue tree was pretty difficult, but it works really well now.

Dialogue nodes can specify actions that occur (I've called them outcomes) when they're finished being printed - they can currently affect variables defined in their respective dialogue object, or send messages to entities in the map. Variables can be used as prerequisites to control whether certain nodes are visible in-game.

My website: http://www.onedropgames.com/
My soundcloud: http://www.soundcloud.com/coldstream24
Creator of the Morningside Engine, co-founder of Onedrop Games.
Offline ShadedVertex
« Reply #3672 - Posted 2016-02-08 09:44:42 »

Coldstream24 it's actually starting to look pretty sweet. Are you writing it in Java?
Offline Opiop
« Reply #3673 - Posted 2016-02-08 13:10:39 »

Wow! I know nothing about bikes, but it looks pretty awesome if that means anything.
The jacket is a nice addition Smiley
Thank you! She's surprisingly clean and nice looking for a bike that's almost as old as me, and a sportbike nonetheless! The jacket is actually just some leather jacket I bought a while ago, it isn't made for biking haha. I couldn't help myself, I had to go for a ride around the neighborhood even without most of my gear Smiley
Offline SHC
« Reply #3674 - Posted 2016-02-08 13:38:00 »

Good job! If you're in the US and have the ability to travel to oregon, you should go to nationals this year! It's a great experience and nobody really cares about your times, plenty of people with barely sub 2 minute averages attend.

I live in India, and here cubing is not a big deal, and also for me. I just started to do this for fun, but eventually became more interested in it. Thanks for the advice.

Offline Coldstream24

JGO Ninja


Medals: 82
Projects: 1
Exp: 4 years


You can fill that void inside with programming, but you'll never return a value.


« Reply #3675 - Posted 2016-02-08 20:17:22 »

Coldstream24 it's actually starting to look pretty sweet. Are you writing it in Java?
Yeah, 100% Java.

My website: http://www.onedropgames.com/
My soundcloud: http://www.soundcloud.com/coldstream24
Creator of the Morningside Engine, co-founder of Onedrop Games.
Offline princec

« JGO Spiffy Duke »


Medals: 1128
Projects: 3
Exp: 20 years


Eh? Who? What? ... Me?


« Reply #3676 - Posted 2016-02-08 23:43:25 »

Today I put left, right, and first line indents into my text formatting renderer, and before- and after-paragraph spacing controls as well. How very mundane!

I'm doing a lot of text heavy UI work in Battledroid at the moment. There are a lot of windows of information about all the different systems in the battledroids and all the other resources in the game.

Cas Smiley

Offline Ecumene

JGO Kernel


Medals: 200
Projects: 4
Exp: 8 years


I did not hit her! I did not!


« Reply #3677 - Posted 2016-02-09 06:02:51 »

Finished the galaxy and solar abstractions to my project.

The idea is to have abstractions laid on top of each-other, starting from the galaxy, then solar system, planet, continents, and finally a heightmap of the planet's terrain. The terrain heightmap is generated from local properties of the continent, and the local properties of the continents are generated from the properties of the planet (moons and such) then the planet is generated by the solar system and so on.

The final terrain heightmap is probably the coolest bit because it's the only real thing here with any true scale. The heightmap will contain information on possibility of local vegetation and effects of erosion and tides on the terrain. So far this is what I've got, the platform is done I've just gotta code the "viewers", and "simulations" on top. I'll be creating a forum post on it after.  

CWSF 2016 starts May, and my regional starts April.

<a href="http://www.youtube.com/v/pV90PgE1iOc?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/pV90PgE1iOc?version=3&amp;hl=en_US&amp;start=</a>
(Sorry about the crop job, gtk record my desktop is AWFUL)

Offline ShadedVertex
« Reply #3678 - Posted 2016-02-09 08:45:19 »

Here's a bunch of links I collected (they're all related to computer graphics):

https://gist.github.com/AbstractAlgorithm/d0194f477adf829822ff (Riven shared this link not long ago)

https://www.opengl.org/resources/

http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-837-computer-graphics-fall-2012/

http://learnopengl.com/

http://openglinsights.com/

http://people.inf.elte.hu/plisaai/pdf/David%20Wolff%20-%20OpenGL%204.0%20Shading%20Language%20Cookbook%20(2).pdf

https://www.youtube.com/playlist?list=PLRIWtICgwaX0u7Rf9zkZhLoLuZVfUksDP

https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_pref01.html

http://john-chapman-graphics.blogspot.sg/2013/01/ssao-tutorial.html

http://www.paulboxley.com/blog/2011/03/terrain-generation-mark-one

http://gamedev.stackexchange.com/questions/1068/opengl-optimization-tips

http://www.mesa3d.org/brianp/sig97/perfopt.htm

http://www.inf.pucrs.br/flash/tcg/aulas/opt/perfogl.pdf

http://ptgmedia.pearsoncmg.com/images/9780321399526/samplepages/0321399528.pdf

https://www.opengl.org/documentation/

https://www.youtube.com/watch?v=HauN98naZ9U

http://notch.tumblr.com/post/8386977075/its-a-scam

https://mediatech.aalto.fi/~samuli/publications/laine2010i3d_paper.pdf

https://www.youtube.com/watch?v=Gshc8GMTa1Y

https://www.youtube.com/watch?v=oB1eMC9Jdsw

https://www.youtube.com/watch?v=m3K4Txg_jH0

https://www.youtube.com/watch?v=E6wyeVmjxk0
Offline Roquen

JGO Kernel


Medals: 518



« Reply #3679 - Posted 2016-02-09 18:55:21 »

I think I've been drugged.  I'm reading that amazon has a game engine.  http://aws.amazon.com/lumberyard/
Offline theagentd
« Reply #3680 - Posted 2016-02-09 22:38:39 »

A few months ago I saw these slides: http://www.slideshare.net/DevCentralAMD/holy-smoke-faster-particle-rendering-using-direct-compute-by-gareth-thomas

Apparently they found that foregoing rasterization of particles and instead going with a tiled compute shader was actually faster than hardware blending. In essence they divided the screen into tiles, binned all particles to said tiles and then had a compute shader "rasterize" those particles, blending into a vec4 completely inside the shader (no read-modify-write to VRAM). They also implemented sorting of particles in the compute shader.

I took a slightly different approach. I've been experimenting with quite a few order-independent transparency algorithms in the past few months/year, and I've got stochastic transparency, adaptive OIT, fourier-mapped OIT (hopefully I'll get around to posting my bachelor thesis on this soon) and a reference CPU-side sorting simple renderer. So as a first test, I tried merging all 3 passes stochastic transparency into a single compute shader. Instead of writing to 8xRGBA16F render targets in the first pass, and then reading all those textures in the second pass and finally doing the weighted average resolving in a final fullscreen pass, I simply use 8 vec4s in the compute shader, immediately do the second pass again writing to local variables and finally doing the resolve and outputting the final RGBA of all particles blended together correctly, all in one (not so) massive shader. I currently lack the tile binning, and a lot of calculations are currently done on the CPU that need a lot of optimizations, but the GPU performance looks very optimistic. In some cases with a large number of particles covering the entire screen, the compute shader achieves almost twice the framerate of my old algorithm, and even more impressively at the same time reduces memory controller load from 80% to a meager 2%. The next step would be to port adaptive OIT to a compute shader. This would be even more interesting at it would eliminate the need for a linked list, as I can just compute the visibility curve as I process the particles. This would in theory allow AOIT to work on OpenGL 3.3 hardware if I just emulate a compute shader with a fullscreen fragment shader pass.

The biggest problem with this approach is that I would need to have every single piece of transparent geometry available in the compute shader, and I wouldn't be able to have different shaders for different particles. However, it would be possible to only use the tiled approach to construct the visibility curve for AOIT in using a tiled compute shader, output the curve to textures and finally proceed with the second pass as usual. That would allow me to have fairly complex shaders for the particles (as long as they don't modify alpha in a complex way) and still have the flexibility of my old system.

I don't really have any good pictures I'm proud of to show off of all this, but hopefully I'll get some nice screenshots in the end. >___<

Myomyomyo.
Offline chrislo27
« Reply #3681 - Posted 2016-02-10 03:31:35 »

After working in 2D for the past five years, I finally decided to dabble into 3D. I followed xoppa's libgdx cube thingy and rendered a cube! Ultimately I actually chose the orthographic camera to render it and I like it more than the perspective camera, probably because I'm so used to 2D flat projections.
Offline Archive
« Reply #3682 - Posted 2016-02-10 03:32:42 »

After working in 2D for the past five years, I finally decided to dabble into 3D. I followed xoppa's libgdx cube thingy and rendered a cube! Ultimately I actually chose the orthographic camera to render it and I like it more than the perspective camera, probably because I'm so used to 2D flat projections.
3D is so fun haha keep workin on it

Offline ra4king

JGO Kernel


Medals: 508
Projects: 3
Exp: 5 years


I'm the King!


« Reply #3683 - Posted 2016-02-10 07:27:30 »

A few months ago I saw these slides: http://www.slideshare.net/DevCentralAMD/holy-smoke-faster-particle-rendering-using-direct-compute-by-gareth-thomas

Apparently they found that foregoing rasterization of particles and instead going with a tiled compute shader was actually faster than hardware blending. In essence they divided the screen into tiles, binned all particles to said tiles and then had a compute shader "rasterize" those particles, blending into a vec4 completely inside the shader (no read-modify-write to VRAM). They also implemented sorting of particles in the compute shader.

I took a slightly different approach. I've been experimenting with quite a few order-independent transparency algorithms in the past few months/year, and I've got stochastic transparency, adaptive OIT, fourier-mapped OIT (hopefully I'll get around to posting my bachelor thesis on this soon) and a reference CPU-side sorting simple renderer. So as a first test, I tried merging all 3 passes stochastic transparency into a single compute shader. Instead of writing to 8xRGBA16F render targets in the first pass, and then reading all those textures in the second pass and finally doing the weighted average resolving in a final fullscreen pass, I simply use 8 vec4s in the compute shader, immediately do the second pass again writing to local variables and finally doing the resolve and outputting the final RGBA of all particles blended together correctly, all in one (not so) massive shader. I currently lack the tile binning, and a lot of calculations are currently done on the CPU that need a lot of optimizations, but the GPU performance looks very optimistic. In some cases with a large number of particles covering the entire screen, the compute shader achieves almost twice the framerate of my old algorithm, and even more impressively at the same time reduces memory controller load from 80% to a meager 2%. The next step would be to port adaptive OIT to a compute shader. This would be even more interesting at it would eliminate the need for a linked list, as I can just compute the visibility curve as I process the particles. This would in theory allow AOIT to work on OpenGL 3.3 hardware if I just emulate a compute shader with a fullscreen fragment shader pass.

The biggest problem with this approach is that I would need to have every single piece of transparent geometry available in the compute shader, and I wouldn't be able to have different shaders for different particles. However, it would be possible to only use the tiled approach to construct the visibility curve for AOIT in using a tiled compute shader, output the curve to textures and finally proceed with the second pass as usual. That would allow me to have fairly complex shaders for the particles (as long as they don't modify alpha in a complex way) and still have the flexibility of my old system.

I don't really have any good pictures I'm proud of to show off of all this, but hopefully I'll get some nice screenshots in the end. >___<
Several questions about your rendering:

  • What did you need 8 render targets for in the first pass?
  • How does your new render system work with the compute shader? Do you still output to the render targets and then each instance of the compute shader processes the 8 vec4s across the 8 RT?
  • How is memory controller load reduced from 80% to 2%? Isn't the same data being processed by the compute shaders instead of fragment shaders now?

I've been getting very interested in how OIT works!

Offline Roquen

JGO Kernel


Medals: 518



« Reply #3684 - Posted 2016-02-10 08:35:14 »

On OIT: There's a new paper by Morgan McGuire & Michael Mara: http://graphics.cs.williams.edu/papers/TransparencyI3D16/

The reference version isn't up yet though...probably after the conference.
Offline theagentd
« Reply #3685 - Posted 2016-02-10 10:14:38 »

Several questions about your rendering:

  • What did you need 8 render targets for in the first pass?
  • How does your new render system work with the compute shader? Do you still output to the render targets and then each instance of the compute shader processes the 8 vec4s across the 8 RT?
  • How is memory controller load reduced from 80% to 2%? Isn't the same data being processed by the compute shaders instead of fragment shaders now?

I've been getting very interested in how OIT works!

I'll go with the stochastic OIT I implemented to explain it. Stochastic OIT basically means that you have a number of samples per pixel, and each sample has a chance to pass based on the alpha of what covers it. On average, this produces the correct result. The old algorithm looked like this:

In the first pass I write to 8 RGBA16 render targets with GL_MIN blending. I'm basically emulating 32 separate depth buffers this way (using MSAA and a coverage mask requires OGL4+ and limits samples to 8 ), and the shader outputs either <depth> for a sample that randomly passes, and <1.0> when it doesn't. This part is purely bandwidth bound. In the second pass, I basically do weighted blended order-independent transparency (WBOIT) using the 8 textures from before as the weighting function. This means writing to 1xRGBA16F and 1xR16F render target and reading the right pixel from all 8 render targets, then doing a step comparison between the depth of the current particle and all stochastic samples. This is also heavily bandwidth bound as the texture data doesn't fit in the texture cache. Finally, there's a fullscreen pass to resolve the weighted sum computes, writing to the final output RGBA16F render target.

For a compute shader, none of the textures are needed. I can replace the 8xRBGA16 with a vec4[8] and write to those instead. Since they're just registers in the compute shader, they never go out to main memory. Similarly, reading those samples is again just a register read, so texture hardware or main memory is never involved. I can even do the final weighted sum resolve in the compute shader as well, and finally just do an image-store write to the output RGBA16F render target. Only for this final write is main memory actually used.

On OIT: There's a new paper by Morgan McGuire & Michael Mara: http://graphics.cs.williams.edu/papers/TransparencyI3D16/
Yeah, I haven't entirely figured out what they're doing that's actually new in that one. Still working on it.

Myomyomyo.
Offline Roquen

JGO Kernel


Medals: 518



« Reply #3686 - Posted 2016-02-10 11:55:08 »

I've only skimmed the paper.  I'm going to wait for the reference version...the conference is in a couple of weeks.
Offline matt_p
« Reply #3687 - Posted 2016-02-10 13:41:07 »

Everything I've done today and will do (and the last days too): refactoring!
Currently I'm quite happy that it made a huge difference this time: less and better structured code and also easier to understand  Smiley (I think that resembles like all the reasons to refactor in the first place)
But I hope I will come back to actual implementation soon(ish)
Offline theagentd
« Reply #3688 - Posted 2016-02-10 15:09:52 »

I've only skimmed the paper.  I'm going to wait for the reference version...the conference is in a couple of weeks.
If that works as they say it does, using less than 16 bytes per pixel with only a single pass and without any need for OGL4+ features, it's completely revolutionary. The result looks correct for the glass, but the lack of tests with smoke particles and similar stuff is a bit suspicious.

Myomyomyo.
Offline Apo
« Reply #3689 - Posted 2016-02-10 18:39:40 »

Started a new game. It is a mix of my two favorite games: chess and soccer. It works really good and now I try to create a nice ai.

Pages: 1 ... 121 122 [123] 124 125 ... 215
  ignore  |  Print  
 
 

 
Riven (201 views)
2019-09-04 15:33:17

hadezbladez (4922 views)
2018-11-16 13:46:03

hadezbladez (1815 views)
2018-11-16 13:41:33

hadezbladez (5196 views)
2018-11-16 13:35:35

hadezbladez (1025 views)
2018-11-16 13:32:03

EgonOlsen (4397 views)
2018-06-10 19:43:48

EgonOlsen (5230 views)
2018-06-10 19:43:44

EgonOlsen (2973 views)
2018-06-10 19:43:20

DesertCoockie (3876 views)
2018-05-13 18:23:11

nelsongames (4308 views)
2018-04-24 18:15:36
Java Gaming Resources
by philfrei
2019-05-14 16:15:13

Deployment and Packaging
by philfrei
2019-05-08 15:15:36

Deployment and Packaging
by philfrei
2019-05-08 15:13:34

Deployment and Packaging
by philfrei
2019-02-17 20:25:53

Deployment and Packaging
by mudlee
2018-08-22 18:09:50

Java Gaming Resources
by gouessej
2018-08-22 08:19:41

Deployment and Packaging
by gouessej
2018-08-22 08:04:08

Deployment and Packaging
by gouessej
2018-08-22 08:03:45
java-gaming.org is not responsible for the content posted by its members, including references to external websites, and other references that may or may not have a relation with our primarily gaming and game production oriented community. inquiries and complaints can be sent via email to the info‑account of the company managing the website of java‑gaming.org
Powered by MySQL Powered by PHP Powered by SMF 1.1.18 | SMF © 2013, Simple Machines | Managed by Enhanced Four Valid XHTML 1.0! Valid CSS!