Built with help from Claude. I mainly used Three.js to create a randomized 3D polygon mesh using random divisions on a square grid. Slapped a basic slope based lighting on top for better view. Source code on GitHub: https://github.com/Hegho/Terrain-Creator

Updated grass system to use instanced glb file with billboard grass clumps instead of procedurally generated grass blades(couldnt get this to look right)

Hi everyone,

I’m working on a computer graphics course project and would really appreciate feedback from people with experience in computer graphics, CFD, SPH, adaptive meshing, adaptive mesh refinement, computational grid, irregular (organic) unstructured quadrilateral/hexagonal grid generation, or scientific visualization.

The project started from two separate interests:

1. A GPU particle-based (Lagrangian grid-free) fluid simulation in Unity, inspired by Sebastian Lague’s fluid simulation work (https://www.youtube.com/watch?v=rSKMYc1CQHE).
2. A custom organic irregular quadrilateral/hexagonal grid that I had previously built in Unity, inspired by Oskar Stålberg's Townscaper game. I'm a bit concerned about using this grid, since Oskar used it more for creativity/artistic reasons in his game, to get that organic European look for his town assets (https://x.com/OskSta/status/1147881669350891521).

More recently, I came across the paper (is it okay that it's 20+ years old?) “A Solution-Adaptive Grid Generation Scheme for Atmospheric Flow Simulations” (https://www.researchgate.net/publication/2379446_A_Solution-Adaptive_Grid_Generation_Scheme_for_Atmospheric_Flow_Simulations), which gave me the idea to combine these two directions. I am not trying to reproduce the full atmospheric solver from the paper. Instead, I’m trying to reinterpret the solution-adaptive grid-generation idea in a real-time graphics context.

My current implementation is roughly:

• A GPU particle-fluid simulation, where particles carry position, velocity, density, etc.
• A custom organic irregular quadrilateral grid.
• A regular uniform quad grid as a comparison baseline (or maybe something else?).
• A bridge that samples the fluid state and assigns an importance value to each adaptive grid cell.
• Cells are dynamically refined/coarsened based on particle count, density, velocity, or combined importance.
• The grid itself is CPU-side topology, while the fluid simulation and importance sampling are GPU-side in Unity.
• The organic grid boundary can also be used as the physical fluid collision boundary.

The part I am unsure about is the scientific meaning framing.

Since the fluid simulation is particle-based/Lagrangian, the adaptive grid is not actually solving the fluid equations directly. Instead, the grid adapts to the particle solution field. So the project is more of a hybrid particle-grid / scientific visualization / adaptive representation prototype than a traditional grid-based CFD solver.

My tentative research question is something like:

How effectively can a particle-based fluid simulation drive solution-adaptive refinement of an organic irregular quadrilateral grid in real time, and how does this compare to a regular uniform adaptive grid?

To make this project idea scientifically meaningfull I need to make the evaluation look like a research investigation, not only a demo. So basically, I need to ground this exploratory investigation idea into state-of-the-art evaluation methods for my approach. I struggle with this part as well.

I might be considering evaluating (do correct me if this seems incorrect or too much or too unnecessary):

• FPS / frame time
• adaptation time
• active cell count
• base cell count
• max refinement level
• particle count scalability
• percentage of particles covered by refined cells
• percentage of refined cells that are empty/wasted
• organic grid vs uniform grid performance and adaptive behavior
• possibly mesh-quality metrics such as aspect ratio, angle quality, or cell area variation

My doubts are:

1. Is this hybrid approach scientifically meaningful, even though the adaptive grid is not the main fluid solver?
2. Is comparing an organic irregular adaptive grid against a uniform adaptive grid a valid research-style comparison?
3. Would it be more correct to frame this as adaptive scientific visualization / adaptive spatial representation rather than CFD accuracy?
4. What evaluation metrics would make this feel like a serious graphics/scientific computing project rather than just a creative Unity demo?
5. Are there related methods or papers I should reference, especially around particle-grid coupling, adaptive mesh refinement, scientific visualization, or fluid-driven level of detail?

I would be grateful for any critique, suggestions, or warnings. I especially want to make sure I am not overclaiming what the project does. My goal is to present it honestly as a research-inspired real-time graphics prototype with a meaningful evaluation, not as a fully validated CFD solver. My interests lie more in the computational grid, spatial discretisation, computational geometry, implicit representation, shape representation, uncovering shapes, geometries, patterns, and structures in a space, and the spatial intelligence side of research, rather than physics itself.

Any help would be appreciated! Let me know if you need more info regarding this.

Thanks in advance!

Hello, World!

I have started learning graphics programming for a few days with the help of learnopengl.com and I feel like I learned quite a lot in these few days. Setting up an OpenGL 3.3 project with C++ in Visual Studio, Drawing a blank window with GLFW and then drawing an RGB triangle in it with OpenGL and GLSL. Learned about shaders, buffers and different OpenGL objects and their use.

I am really getting a lot interested in this field of computer science. but, I am also a bit nervous about it. As there is a lot mathematics involved in this which is my biggest weakpoint.

I would like to hear about how y'all got into graphics programming and what challenges did y'all face while learning it.

So, here are the things I added to my game engine in the past month or so.

• Skybox support (From equirectangular map to cubemap image)
• Mipmap generation support for any kind of textures (Including skybox too)
• PBR support
• Diffuse + Specular IBL
• More stabalizing of the engine's core
• Added VMA to the engine
• Some helper tonemapping functions in the shader utils like ACES, Reinhard and Uncharted 2's tonemapper

As of now, the performance isn't good (Don't take the performance in the screenshot seriously, it showed that deltaTime due to the screenshot). There are lots of things left to be added and to be improved. But yeah, that's it for the updates.

Here is the github repo is anybody wondering :- MeltedForge

Things i have tried:

the mag and min parameters of the texture are correctly set to gl.NEAREST and gl.NEAREST_MIPMAP_NEAREST

the overall canvas has the .imageRendering css property set to "pixelated"

the uv coordinates, for the face displayed, i believe are correct

Hi all,

Does anyone happen to know the specific technical concept he's describing here? (Source: https://www.nintendo.com/en-za/Iwata-Asks/Iwata-Asks-The-Legend-of-Zelda-The-Wind-Waker-HD/The-Legend-of-Zelda-The-Wind-Waker-HD/5-Over-designed/5-Over-designed-807330.html )

I have noticed that Wind Waker HD has much brighter brights and darker darks than its GameCube predecessor. I've also noticed that this is the case generally when it comes to 8th gen games compared to 6th gen ones.

But I was wondering, specifically what is the reason for this? It's not true that the GameCube couldn't display anything that bright or that dark, right? So why couldn't you have that high contrast look you see in newer games? Like why do say ps2 games look so flat and washed out compared to a lot of ps4 ones in terms of tonal contrast?

Hey everyone! I've been working on a custom, from-scratch voxel engine utilizing Unity's Compute Shaders and StructuredBuffers.

Unlike traditional particle pipelines or VFX Graph, everything here runs within a single flat StructuredBuffer<uint4> directly on the GPU. The fluid simulation under the hood is based on a custom Lattice Boltzmann Method (LBM).

Currently pushing around 180 FPS on a RTX 4070ti at 192³ grid volume. My next immediate goals are dynamic light propagation and material thermodynamics.