Hillsguy

GitHub - rmn20/MascotME: MascotCapsule v3 implementation in pure J2ME MascotCapsule v3 implementation in pure J2ME. Contribute to rmn20/MascotME development by creating an account on GitHub.

github.com/rmn20/MascotME

Don't look at Nokia N70 and Samsung Champ, they are too slow for this

Spent my whole January working on a new MascotCapsule v3 implementation in pure MIDP 2.0
Now you can run games previously exclusive to Sony Ericsson phones on any powerful enough J2ME cellphone or easily add MCv3 support to your J2ME emulator without worrying about OpenGL/ES support

The same render, but with filter glossy 1 and cast/receive shadow caustics

So, it turns out, to achieve good looking caustics in Blender with Cycles you need to disable "filter gloss" option and NOT use "cast/receive shadow caustics" options

YouTube video by storerestore Pocket Acid released!

!!!
youtu.be/6xw3qoWYFCo

#SunVox

While I think that this effect looks great in open locations, sometimes I find it a bit weird looking in interiors.

Also note the hexagonal grid structure.
My guess is that hexagonal grid aligns better with radial gradients, resulting in reduced amount of aliasing artifacts compared to regular polygonal grid.

This is how individual passes look when applied:

This effect is applied in two passes:
First pass uses regular alpha blending with constant alpha.
Second pass uses additive blending, light sources are also a bit smaller.

Silent Hill 4 uses interesting volumetric light / light glare approximation.
Instead of drawing sprites at each light source, full-screen subdivided plane with procedural vertex colors is rendered and blended with game frame.
#gamedev

Does anyone know how Climax Studios implemented shadow maps on PS2 and PSP in Silent Hill: Origins and Shattered Memories?

Got bizarre dream bazaar to work with portmaster
Not quite butter smooth, but it works

yeah

The Future Sound Of London - Room 208

(Textures by Makkon)

Regular vertex lighting in sRGB

Regular vertex lighting in linear RGB

Vertex lighting in linear RGB with sqrt(col) interpolation

Vertex lighting in linear RGB with sqrt(1/col) interpolation (I use invsqr distance attenuation)

Was wondering why vertex lighting looks ugly in linear RGB compared to sRGB
Turns out it's due to interpolation in linear color space. Interpolating sqrt(col) fixes the issue
I also tried sqrt(1/col) but it looks wrong on smooth normals
I wonder if this can be applied to lightmaps too

Car model is from Need for Speed: Undercover (J2ME)

Experimenting with normals for spherical environment mapping
#gamedev #indiedev

This is a great thread @hillsguy.bsky.social, I'll add a bit more context here for anyone interested.

Yes there's no fancy sim - it just uses a water interaction buffer as a target for the particle system rendering, so we could use the power of particle system we already have.

Wow, thanks for those insights and for your repost!
Effects like this deserve more attention, I was surprised that there's no related publications on Valve site

Not really. Gradient maps are similar to palettes, but they are not interchangeable, both have their own limitations. Maybe some modifications of this technique could be applied to gradient maps too.

Thanks!
I'm not familiar with WebGL, but considering that WebGL 2 is based on GLES 3, I think it should be mostly doable.

I also wanted to check out that famous bottle shader, but I don't think that I can pinpoint anything useful without looking at shaders.
All I see is that bottle is fully opaque and doesn't use any colors from the framebuffer. Looks like only cubemaps and per-pixel lighting are used for refractions.

The next one in the pipeline is water, but I've already covered it earlier.
Only after all of this the player viewmodel is rendered. CS2 has a separate pass for the viewmodel SSAO, which feels like overkill to me.

Two sets of buffers with different resolutions are used for smokes at different distances. Close ones are rendered in ¼ buffers, and distant ones in ½ buffers.
Fire is also rendered separately and merged with OIT later, but only 4 ½ res buffers are used.

Smoke is rendered separately in a bunch of low-res buffers and is combined with OIT buffers later.
A whopping SIX (!) buffers are used! (R 32F, RG 32F, RGBA 32F, RGBA 16F, RG 16F, R 8UI).
The first 4 buffers seem to be the same as the OIT buffers, but I'm not sure about the rest.

Two render passes and one final composing pass is used for transparent geometry (see moment-based OIT).

First pass uses 3 render buffers (R 32F, RG 32F, RGBA 32F).
Second pass uses previous data as input and renders color data in RGBA 16F buffer.
Final pass combines this data with framebuffer data.

CS2 also uses some flavor of order-independent transparency for particles, glass, smoke and fire. Most likely, moment-based OIT is used.