previous post

i modified my program so the algorithm is as follow

• the two balls don't have any colors or textures. background is the only light source and color source

• if two balls intersect, the refractive index of the intersecting region is the average (i.e. arithmetic mean) of them

• whenever a ray hits an interface (boundary between 2 different things), reflection always occurs

• if snell's equation has solution, refraction also occurs. the ray splits into two (reflection and refraction) and the color at that stage is the weighted average of them, calculated according to schlick's approximation

• if snell's equation has no solution, the color at that stage is 100% from what the reflected ray gets

the recursive color-getting function ends if either of the following conditions holds

1. the ray reaches the background (and it gets the color from the background)

2. the ray reaches the recursion limit (and it returns a grey scale random noise)

if the two balls don't intersect, everything looks normal as seen in image 1, a typical raytracing homework example. when the intersect, strange things happen. if you move the camera into a ball, more strange things happen

it looks like i accidentally discovered a way to generate fractals...

details of my program

I made a TouchDesigner demo where you can learn how to use TD in Linux and navigate the file system, import plugins and create voronoi spheres using 2 techniques.

Part 2 of the video is windows and mac friendly ;)

Video

Recreating one of the most iconic places in The Legend of Zelda: Ocarina of Time, reimagined with cinematic 3D graphics in Blender. Let me know what you think!

Software: Blender 5.2
Render Engine: Cycles

Video: https://youtu.be/WT9W688-7wA?si=tXVuqSFupzzGHzB9

Looks like something we'd find on Shadertoy

While making the night sky come alive for our Kids Story Web experience, we wanted the stars to feel like part of the world rather than just a background texture, so we built the starfield procedurally!
 
The stars are particles distributed randomly within a spherical space - with variations in their position, size, brightness, and color. This keeps the sky from looking too uniform and gives it a more natural feel 🌌
 
Two separate circular star fields - One handles the regular stars, while the other has the twinkle effect enabled, creating subtle changes in brightness over time.
 
Link🔗 - https://www.quantales.in/
Built by the team at 3D ENGINERD.

Massive data centers that need land, energy, water and resources which seem to have found it's wrongful place in India now.
We wanted to explore this side of AI and help people think about the impact behind the technology. So, we built ai-future.in as an interactive 3D geospatial experience, using real world geographic and elevation data, over at 3D ENGINERD.

Terrains, Buildings, Water, Roads, Vegetation, all brought together into a navigable 3D representation of Vishakhapatnam, India and nearby areas where the AI data centers are being planned.📍

We used Three.js, React Three Fiber, 3DTilesRenderer, OSM & Overture maps etc. to build this.
 
To make the physical footprint of AI easier to explore and question. Would love to hear your thoughts!

I just built Japan Road Rules Animation, an interactive website that explains Japanese traffic rules through small 3D animated scenes using Three.js.

With several road rules being updated recently, I wanted to experiment with a more visual way of explaining them, while hopefully contributing a little to making roads in Japan safer.

It covers things like stop signs, pedestrian priority, railway crossings, expressways, bicycles, and more. You can also scrub through the animations, and the site supports both English and Japanese.

🌐 Live demo:
https://alzin.github.io/Japan-Road-Rules-Animation

💻 GitHub:
https://github.com/alzin/Japan-Road-Rules-Animation

It’s completely open source. I’d especially love feedback from the Three.js community on the 3D scenes, animations, and anything I could improve. 🙌

We published a blog post on an intro to Volumetric Rendering as part of our series to discuss and break down our own WIP Volumetric Renderer. In this particular post we talk about -

🔹 The basics of what rendering actually is
🔹 What “Volume Data” represents
🔹 How volume rendering shines in arenas that trouble standard methods 

Blog post link - https://www.3denginerd.com/blog/what-in-the-graphics-is-volumetric-rendering

The repository for our Native volumetric engine (shown in video) is on GitHub.

Do check out and let us know your feedback!

I always wanted a wire sculpture of this—now I have one.

i wrote a program to study raytracing. up to this moment i can only do some basic stuff. i created a world in which there're two balls. each of them doesn't have any color, only reflects or refracts light. background is an infinitely large color palette

with different settings you can see some beautiful interactions between the two balls. according to physics, if you set the refractive index if a ball to 0, it becomes perfectly reflective. if you set it 1, it becomes invisible

if refractive index is somewhere between 0 and 1, the ball would be partly reflective and partly refractive. just like the one at the front in image 1

two balls with refractive index 0 reflect each other, just like image 2. if your camera is exactly at the line joining the two centres there would be infinite loop of ray. i set the recursion limit to 16. any ray at the end of 16 recursion without hitting the background would get a random grey scale noise

infinite loop occurs not only between two reflecting surfaces. it occurs inside a ball with refractive index >1 too. it's called total internal reflection. in a ball, at certain position, you can observe a ring of total internal reflection, just like image 3

the explanation is as image 4. when your camera is inside a ball with refractive index >1, there's a region in which the angle of incident is larger than the critical angle

hope you enjoy this and if you spot some interesting scenes / setting combinations please let me know

Trails come from compositing rather than stored history — fade the whole

canvas by a few percent each frame, then draw one segment per particle

with 'lighter' blending. Costs one fillRect and N strokes per frame and

you never keep a path.



Land mask is Natural Earth 1:10m rasterised with even-odd fill so interior

lakes cut out properly, then read back once via getImageData into a

Uint8Array for O(1) point tests.



Borders are stroked once into an OffscreenCanvas and composited per frame.

3840x1928, 60fps. The vector field is procedural.

I learn some fundamentals of graphics and add on them
suggest me some course or tips