[Developing] 3D Pokemon Let's Go [Early demo] development

[tokenizer]

I'm working on this since ~4 months on my own. Right now I just keep adding features to the engine so it becomes usable one day.

A little preview:



Here is a list of what there currently is:
- All pokemon models from pokepark wii and pokemon rumble - rigged, textured and animated
- A own 3d game engine written entirely from scratch, 10.000 lines of code and running in the browser
- Physically based lighting
- Volumetric lighting
- Deferred shading pipeline
- Skeletal animations
- A lot others!
- The engine is running pretty fast! I carefully added features and I'm using the very latest web technology (WebGL2, WebAssembly) to have maximum performance.

If you're interested in helping this project or got any questions, then feel free to add me on discord (xima#5727).

 

[tokenizer]

Update:
- Added terrain height detection
- Added third-person camera
- Added preview video

 

[tokenizer]

- Added skeletal animation blending
- Added terrain-camera collision detection
- Fixed md5 normal calculations
- Fixed various joint weight transform issues
- Added new skybox

 

[tokenizer]

- Added a basic walk system
- Added a new walk animation
- Added shadow mapping
- Updated main post

 

[Pepperton]

This is pretty darn impressive. What language did you write the engine in? Can you maybe explain to me the functionality of your shading pipeline? Also I guess the big question I have is why'd you go for writing your own engine?

The company I'm interning at this summer uses WebGL for their games, and it's usually quite a pain to get asset bundles prepared to be compressed so that they can be properly rendered in the framework. I'm curious about your experiences using it for this. Our games aren't made on a custom engine; we use Unity, so that might have something to do with it.

 

[tokenizer]

It's written in a JavaScript WebAssembly hybrid solution. The engine itself uses JavaScript, performance critical parts are written in C and then compiled into WebAssembly.

The shading pipeline is just the standard deferred shading way. Everything is written into a geometry buffer first, which then gets processed and blended with point and directional lights into a single offscreen FBO. This FBO then gets blitted into the main FBO at the very end (after bloom, FXAA, volumetric lighting etc. were applied).

Also all of this happens in a own FBO+Filtering system of the engine. OpenGL requires to write many lines to do all of this, in the engine implementing things like FXAA only takes ~10 lines of actual code:

    filter.enable();
    filter.readFrameBuffer(null, gl.COLOR_ATTACHMENT0);
    let { variables } = filter.useProgram("FXAA");
    gl.uniform2fv(variables.uResolution, filter.resolution);
    filter.apply();
    filter.writeToFrameBuffer(null, gl.COLOR_ATTACHMENT0);

I wrote it for learning purposes - I'm not sure how helpful it actually is, but at least it's for my pokemon game plans :)

My engine doesn't require any bundling, everything is loaded async on-the-fly. All async loading stuff like loading shaders, textures or object files have an optional load callback, so if you want to only start your game when everything is loaded and ready, then it's possible this way.

Thanks!

 

[Pokegirl8929]

how can i test it out?