Google Code Shutting Down

Hi Anael, any news regarding github migration?

I know, there is already free AAA engine right now, and maybe more on later, and there is plenty of promising new engine like godot engine, openfl, etc with their near complete feature for production and easiness to use. So do you have any plan or a state of this engine?
Maybe if you have a roadmap or so, you can share with us, so if there is someone who like to contribute they can do the milestone.

Thanks for explanation, it is good to know that you have a plan for this engine.

I did successfully compile on Linux, Mac OSX (using hackintosh ), Windows (MinGW GCC Compiler), Android and iOS.
It's working on Linux and Mac OSX, but crash on Windows and Android at glLinkProgram (some of your shader code in Standard Renderer), it did not crash if I comment "addFx" on shader1-8 code, but on Android version I only got a gray window (from glClear I think), I don't know it's because I didn't embed the assets, because I don't know how to do it , or the window didn't swap the buffer. It was become harder on iOS version, I managed to compile and installed on devices, but it crash immediately when I open the app.

By plan to implement OpenCL or Cuda, do you want to focus on desktop?
If yes, then it's good to keep GLFW than SDL2 I think.

I've tried deferred rendering and physically based shading, but I haven't process transparent object and light didn't have the shadow at the moment, it's hard to implement CSM for me. At some point maybe I try to implement global illumination using LPV, and it can use your OpenCL implementation for cell generation.

If you already push the code to github, I'll fork and make some pull request to merge the features.

Last edited by jurgel (2015-04-08 02:21:32)

I'd tried both of SDL2 and GLFW, but it's not a class so the function name conflict to each other.

Why do you have interest in software rendering? Currently many of them are used for fallback mode. It's different if you want non realtime rendering.

OpenCL can be used together with OpenGL also, they can share GPU memory through interoperability, I'd used it for post processing, although it can achieved by fragment shader, just for testing purpose.

Deferred rendering used to decoupling object(n) and light(m), so instead of we calculate n*m per frame, it can be n+m, hence we can use hundred of light in a scene, but still not all of them can have shadow, because shadow calculation is quite expensive. Deferred rendering also has advantageous like post processing such as blur, DOF, tone mapping, glow, flare, etc. But it has a problem for transparent object, so they need different process and if in standard rendering we could use many shader for each object, we can't do this in deferred rendering.

The process, first we draw all object color/albedo, normal, and depth (probably specular coef, IOR, roughness, etc we like) into separate texture using one frame buffer (usually named gbuffer), usually we can compact into different channel on one texture, like normal map using rgb channel, and roughness value into alpha channel.
Then we process this textures for every light into light buffer if we want some post process later or draw directly to screen.

Physically based shading is similar to standard shading such as lambertian model for diffuse shading and blinn-phong for specular shading, but physically based shading using more accurate rendering equation, it's approximately equal to what light actually does, so the result can be more natural. This can be achieved in fragment shader using additional material parameter like roughness and IOR, it's more expensive though. CMIIW

Did you mean voxel based rendering? It's cool if we could create voxel based game engine, but I don't know anything about it yet. If you have a specific plan for voxel based rendering, just let me know.
We can't combine the current code and we have to start from scratch if we want to implement it, because it's different on every aspect though.

After a bit of googling it looks promising for the future, as it can perform real time ray tracing, but I concern about sparse voxel octree creation per frame if we want dynamic scene, and there isn't many resource out there for further implementation, so this is required much research.

This is interesting and can make Maratis unique from others I think.

It's great if we can add voxel renderer in current engine, so user can choose FixedRenderer, StandardRenderer, VoxelRenderer, and maybe DeferredRenderer later.

I don't understand how your code works , I'll look some reference to implement voxel based renderer which is compatible to CPU rendering then.

Yes, it's in the wind like pure old school 2d, a voxel is just a 3d pixel, it means "volumetric pixel",
it often looks like cubes, but in fact it is more like a stack of bitmaps (the stack being the Z dimension),
and because it's packed and aligned, it can be traversed very fast, using ray-casting or ray tracing.

When parsed directly it can render as cubes (like minecraft) or smoothed cubes depending of the filtering,
but it can also be converted to triangles using "marching cubes" and create smooth surfaces.

voxels are also used to accelerate the parsing of a scene for raytracing, like a fixed size octree.

Great, looks like an optimized code.
I still think to implement SSE function for matrix or vector math function though.
It won't be portable, but it will cut down the number of instruction.

Hmm, I don't know if the compiler could do auto compile to SSE instructions. What compiler flags should I use? Or it's on by default?

It's a great then
Nice info. Thanks.

Some update on github : https://github.com/anael-seghezzi/Marat … -C-library
And a first web experiment compiled to asm.js with emscripten : http://maratis3d.org/js/m_voronoi/m_voronoi.html

The adjustment is quite small, I'm surprised how simple it is.
First thing to check is the window/events system, but when using glfw or sdl there is no problem (sdl is better supported though), then the main loop need to be parsed a bit differently. There might be some modifications to do for file parsing but I didn't test it.