Raymaching example

Author: einarf

examples/README.md

@@ -108,3 +108,14 @@ python manage.py runeffect examples.warpspeed
 ```
 
 ![screenshot](https://raw.githubusercontent.com/Contraz/demosys-py/master/examples/images/warpspeed.png)
+
+Raymaching
+----------
+
+Raymaching example by Arttu "helgrima" Tamminen.
+
+```bash
+python manage.py runeffect examples.raymaching
+```
+
+![screenshot](https://raw.githubusercontent.com/Contraz/demosys-py/master/examples/images/raymaching.png)

examples/images/raymaching.png

@@ -0,0 +1,56 @@
+import math
+
+import moderngl
+from demosys import geometry
+from demosys.effects import effect
+from pyrr import Vector3
+
+
+class SimpleRaymarchEffect(effect.Effect):
+    """Generated raymarching effect"""
+    def __init__(self):
+        self.shader = self.get_shader("raymarching_simple.glsl", local=True)
+
+        # create plane to fit whole screen
+        self.plane = geometry.plane_xz(size=(self.window_width, self.window_height), resolution=(10, 10))
+
+    @effect.bind_target
+    def draw(self, time, frametime, target):
+        self.ctx.enable(moderngl.DEPTH_TEST)
+
+        # Rotate plane 90 degrees, and move plane back so it will fit correctly on to screen
+        backoff = math.tan(math.radians(self.sys_camera.projection.fov / 2)) * (self.window_width / 2)
+        m_mv = self.create_transformation(rotation=(math.radians(90), 0.0, 0.0), translation=(0.0, 0.0, -backoff))
+
+        # Uniforms
+        fov = 0.60
+        alpha = 1.0
+        modifier = -0.6
+        cPosition = Vector3([(math.sin(time / 6.0) * 16.0),
+                             (math.sin(time / 12.0) * 16.0),
+                             (math.cos(time / 3.0) * 16.0)])
+        cLookAt = Vector3([0.0, 0.0, 0.0])
+        lPosition = Vector3([0.0, 17.0, 0.0])
+        lItensity = 2.6
+        color = Vector3([0.66, 0.96, 0.26])
+
+        # Draw the plane
+
+        # For vertex shader
+        self.shader.uniform("m_proj", self.sys_camera.projection.tobytes())
+        self.shader.uniform("m_mv", m_mv.astype('f4').tobytes())
+
+        # For fragment shader
+        self.shader.uniform("fov", fov)
+        self.shader.uniform("alpha", alpha)
+        self.shader.uniform("modifier", modifier)
+
+        self.shader.uniform("cPosition", cPosition.astype('f4').tobytes())
+        self.shader.uniform("cLookAt", cLookAt.astype('f4').tobytes())
+        self.shader.uniform("lPosition", lPosition.astype('f4').tobytes())
+        self.shader.uniform("lIntensity", lItensity)
+        self.shader.uniform("color", color.astype('f4').tobytes())
+
+        self.shader.uniform("resolution", (self.window_width, self.window_height))
+
+        self.plane.draw(self.shader)

examples/raymarching/effect.py

@@ -0,0 +1,115 @@
+#version 410
+
+#if defined VERTEX_SHADER
+
+in vec3 in_position;
+in vec3 in_normal;
+
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+
+out vec3 normal;
+out vec2 uv;
+
+void main() {
+	gl_Position = m_proj * m_mv * vec4(in_position, 1.0);
+}
+
+#elif defined FRAGMENT_SHADER
+
+uniform vec2 resolution;
+uniform float fov;
+uniform float alpha;
+uniform float modifier;
+uniform vec3 cPosition;
+uniform vec3 cLookAt;
+uniform vec3 lPosition;
+uniform float lIntensity;
+uniform vec3 color;
+
+out vec4 fragColor;
+
+const int maxSteps = 64;
+const float maxDistance = 60.0;
+const float distanceThreshold = 0.0005;
+
+struct Hit {
+    vec3 normal;
+    vec3 path;
+    float steps;
+    float dist;
+};
+
+float sdMandleBox(vec3 pos, float size)
+{
+    const int Iterations = 10;
+    const float Scale = 2.0;
+    const float FoldingLimit = 100.0;
+    const float MinRad2 = 0.15;
+    vec4 scale = vec4(size) / MinRad2;
+    float AbsScalem1 = abs(Scale - 1.0);
+    float AbsScaleRaisedTo1mIters = pow(abs(Scale), float(1 - Iterations));
+    vec4 p = vec4(pos, 1.0), p0 = p;  // p.w is the distance estimate
+    
+  for (int i=0; i<Iterations; i++)
+    {
+        p.xyz = clamp(p.xyz, -1.3, 1.3) * 2.0 + (modifier) - p.xyz;
+        float r2 = dot(p.xyz, p.xyz);
+        p *= clamp(max(MinRad2 / r2, MinRad2), 0.19, 1.0);
+        p = p * scale + p0;
+        if (r2>FoldingLimit) break;
+    }
+    return ((length(p.xyz) - AbsScalem1) / p.w - AbsScaleRaisedTo1mIters);
+}
+
+Hit raymarch(vec3 rayOrigin, vec3 rayDirection) {
+    const vec2 eps = vec2(0.001, 0.001);
+    float size = 1.8;
+    Hit h;
+    for(int i = 0; i < maxSteps; i++) {
+        h.path = rayOrigin + rayDirection * h.dist;
+        float d = sdMandleBox(h.path, size);
+        h.steps += 1.0;
+        if(d < distanceThreshold) {
+            h.normal = normalize(vec3(
+                sdMandleBox(h.path + eps.xyy, size) - sdMandleBox(h.path - eps.xyy, size),
+                sdMandleBox(h.path + eps.yxy, size) - sdMandleBox(h.path - eps.yxy, size),
+                sdMandleBox(h.path + eps.yyx, size) - sdMandleBox(h.path - eps.yyx, size)
+            ));
+            break;
+        }
+        h.dist += d;
+
+    }
+    return h;
+}
+
+vec4 processColor(Hit h, vec3 rd, vec3 ro, vec2 uv, vec3 li)
+{
+    vec3 c = color * (1.0 - (h.steps / float(maxSteps)));
+    c *= (1.0 - (h.dist > maxDistance ? 0.0 : h.dist / maxDistance));
+
+    float light = max(0.0, dot(-normalize(h.path - li), h.normal));
+
+    c *= light * lIntensity * vec3(0.4, 0.4, 0.4);
+    return vec4(c, alpha);
+}
+
+void main(void)
+{
+    float aspectRatio = resolution.y / resolution.x;
+    vec2 uv = (2.0 * gl_FragCoord.xy / resolution - 1.0) * aspectRatio;
+
+    vec3 forward = normalize(cLookAt - cPosition); 
+    vec3 right = normalize(vec3(forward.z, 0.0, -forward.x)); 
+    vec3 up = normalize(cross(forward, right)); 
+
+    vec3 rd = normalize(forward + fov * uv.x * right + fov * uv.y * up);
+    vec3 ro = vec3(cPosition.x, cPosition.y, cPosition.z);
+    Hit tt = raymarch(ro, rd);
+ 
+    fragColor = processColor(tt, rd, ro, uv, lPosition); 
+
+}
+
+#endif