Initial commit

Author: SalatielSauer

README.md

@@ -1,2 +1,40 @@
-# Sauer-Concept-Shaders
-Some GLSL Shaders tests for Cube 2 Sauerbraten
+# Sauer Concept Shaders  
+Some shader tests for the vanilla Cube 2 Sauerbraten, including:  
+
+- `packages/shaders/postfx_box.cfg`  
+    Draws a box at any position in world space.  
+
+- `packages/shaders/postfx_cone.cfg`  
+    Draws a cone at any position in world space.  
+
+- `packages/shaders/postfx_raycaster.cfg`  
+    Uses raycasting to render a 3D scene with lighting and textures.  
+
+- `packages/shaders/postfx_screentext.cfg`  
+    Uses an embedded bitmap font to draw text on the screen.  
+
+- `packages/shaders/worldtext.cfg`  
+    Uses an embedded bitmap font to draw text in the world.  
+
+- `packages/shaders/texture_daynight.cfg`  
+    Transitions between two lightmap states over a 10-minute period, with the option to add windows.  
+
+- `packages/shaders/postfx_camerashake.cfg`  
+    Makes you dizzy.  
+
+You can run them with the `/exec` command:
+
+```
+/exec packages/shaders/postfx_camerashake.cfg
+```
+
+There are also two maps:
+- `packages/base/conceptshaders_daynight.ogz`
+
+    Map setup to visualize the day-to-night texture shader working.
+
+- `packages/base/conceptshaders_playground.ogz`
+
+    A bunch of weird, unfinished texture/model shaders showing manipulation of vertex positions and colors, including a working light switch and flashlight!
+
+These shaders are still works in progress and not very useful on their own, but even in this incomplete state, I hope they serve as a reference for you to create your own :)

packages/base/conceptshaders_daynight.cfg

@@ -0,0 +1 @@
+exec "packages/shaders/texture_daynight.cfg"

packages/base/conceptshaders_daynight.jpg

@@ -0,0 +1,349 @@
+// This file consists of model/texture shader tests that don't result in anything useful,
+// it may contain unused uniforms and misplaced comments, I recommend using it for reference purposes only, but you are free to do whatever you want!
+
+//defuniformparam "transform" [@(_getRayHit)] 0 // x y z rotate
+//defuniformparam "transform" [@(_getRayHit)] 0 // x y z rotate
+defuniformparam "pivot" 0 0 0 0
+defuniformparam "debug" 0
+defuniformparam "position" 0 0 0 0
+defuniformparam "trigger" 0 0 0 0
+defuniformparam "triggerradius" 0.7 0 0 0
+
+shader 0 [_conceptshaders_shadersdemo@getmillis] [
+    attribute vec4 vvertex;
+    attribute vec3 vnormal;
+    attribute vec2 vtexcoord0, vtexcoord1;
+    uniform mat4 camprojmatrix;
+    uniform vec2 texgenscroll;
+    varying vec2 texcoord0, texcoord1;
+    varying vec4 dbgvvertex;
+    uniform vec3 camera;
+    uniform vec3 center;
+    uniform vec3 objectCenter;
+    uniform float millis;
+    varying vec3 objectCenterdbg;
+    varying vec3 positionOffset;
+    varying vec2 is_triggered;
+    mat4 getRotationMatrix(float angle) {
+        float c = cos(angle);
+        float s = sin(angle);
+        return mat4(
+            vec4(c, -s, 0.0, 0.0),
+            vec4(s,  c, 0.0, 0.0),
+            vec4(0.0, 0.0, 1.0, 0.0),
+            vec4(0.0, 0.0, 0.0, 1.0)
+        );
+    }
+
+    //:water
+    void main(void)
+    {
+        // 1. Define the object's world-space center (a known value or calculated from bounding box).
+        //vec3 objectCenter = vec3(2752+32, 2114+64, 2048); // Example: Midpoint of a 4096x4096x4096 world
+        dbgvvertex = vvertex;
+        //vec3 objectCenter = vec3(transform.xyz);
+        // Step 2: Use nearestZ for the z-component of objectCenter
+        vec3 objectCenter = vec3(pivot.w == 1 ? pivot.xyz : vvertex.xyz);
+
+        // 2. Compute the rotation matrix using transform.w (rotation angle).
+        mat4 rotationMatrix = getRotationMatrix(position.w == 0 ? sin(millis*2) : mod(millis, 2.0 * 3.14159));
+
+        is_triggered.x = float(abs(camera.x - trigger.x) <= triggerradius.x &&
+            abs(camera.y - trigger.y) <= triggerradius.y &&
+            abs(camera.z - trigger.z) <= triggerradius.z);
+
+
+        if (is_triggered.x == 1) {
+            if (trigger.w == 1) {
+                positionOffset.z -= 1.8;
+            }
+
+            if (trigger.w == 2) {
+                rotationMatrix = getRotationMatrix(mod(millis*5, 2.0 * 3.14159));
+            }
+
+            if (trigger.w == 5) {
+                positionOffset.x += 0.65;
+            }
+
+
+
+        }
+
+        if (trigger.w == 8) {
+            positionOffset.z += distance(vvertex.xy, camera.xy)/2;
+        }
+
+        if (trigger.w == 9) {
+            positionOffset.z += 20;
+            positionOffset.xyz += sin(vvertex.z+millis);
+        }
+
+        if (trigger.w == 10) {
+            positionOffset.z += 20;
+            positionOffset.y += 2-cos(vvertex.x+millis)*2;
+        }
+
+        if (trigger.w == 11) {
+            positionOffset.z += 10;
+            positionOffset.z += 2-cos(vvertex.x+millis)*2;
+        }
+
+
+        // 3. Translate the vertex relative to the object's center (bring the object to the origin).
+        vec4 translatedVertex = vec4(vvertex.xyz - objectCenter, 0.0);
+
+        // 4. Apply the rotation.
+        vec4 rotatedVertex = rotationMatrix * translatedVertex;
+
+        // 5. Translate the rotated vertex back to the object's world position.
+        vec4 finalVertex = rotatedVertex + vec4(objectCenter + position.xyz + positionOffset.xyz, 1.0);
+
+        // 6. Apply camera projection.
+        gl_Position = camprojmatrix * finalVertex;
+
+        texcoord0 = vtexcoord0 + texgenscroll;
+        texcoord1 = vtexcoord1 * @lmcoordscale;
+        objectCenterdbg = objectCenter;
+        //:shadowmap
+        //:dynlight
+    }
+] [
+    uniform vec4 colorparams;
+    varying vec2 texcoord0, texcoord1;
+    uniform sampler2D diffusemap, lightmap, tsky;
+    varying vec4 dbgvvertex;    // Vertex position in 3D space
+    varying vec3 objectCenterdbg;  // Center of the object
+    uniform vec3 camera;        // Camera position
+    uniform float millis;
+    uniform float alphatest;
+    varying vec2 is_triggered;
+    uniform vec4 ambient;
+    uniform mat4 camprojmatrix;
+
+    mat4 constructProjectionMatrix(float fovy, float aspect, float znear, float zfar) {
+        float f = 1.0 / tan(fovy / 2.0);
+        mat4 M = mat4(0.0);
+        M[0][0] = f / aspect;
+        M[1][1] = f;
+        M[2][2] = (zfar + znear) / (znear - zfar);
+        M[2][3] = -1.0;
+        M[3][2] = (2.0 * zfar * znear) / (znear - zfar);
+        return M;
+    }
+
+    vec2 extractYawPitch(mat4 cammatrix) {
+        mat3 R = mat3(cammatrix);
+        vec3 forward = -vec3(R[0][2], R[1][2], R[2][2]);
+        float yaw = atan(forward.x, forward.y);
+        float pitch = asin(forward.z);
+        return vec2(yaw, pitch);
+    }
+
+    void main(void) 
+    {
+
+        float A = camprojmatrix[2][2];
+        float B = camprojmatrix[2][3];
+        float nearPlane = B / (A - 1.0);
+        float farPlane = B / (A + 1.0);
+        float aspect = @scr_w / @scr_h;
+        mat4 proj = constructProjectionMatrix(@fov, aspect, nearPlane, farPlane);
+        mat4 invProj = inverse(proj);
+        mat4 view = invProj * camprojmatrix;
+        vec2 yawPitch = extractYawPitch(view);
+        float yaw = -yawPitch.x;   // Yaw in radians
+        float pitch = yawPitch.y; // Pitch in radians
+
+        vec4 lm = texture2D(lightmap, texcoord1);
+        vec4 diffuse = texture2D(diffusemap, texcoord0);
+
+        // Base color calculation with dynamic lighting
+        //:shadowmap lm
+        //:dynlight lm
+
+        gl_FragColor = pivot.w == 0 ? (diffuse*lm) :
+            (diffuse * lm) - vec4((round(dbgvvertex.x) == round(objectCenterdbg.x)) ? 1 : 0, 
+                (round(dbgvvertex.y) == round(objectCenterdbg.y)) ? 1 : 0, 
+                (round(dbgvvertex.z) == round(objectCenterdbg.z)) ? 1 : 0, 
+                0.0);
+
+        if (is_triggered.x == 1) {
+            //gl_FragColor = mix(gl_FragColor, vec4(1.0, 0.0, 1.0, 1.0), 1.0);
+            if (trigger.w == 1) { // pressure plate
+                gl_FragColor = mix(gl_FragColor, vec4(0.5, 0.0, 0.5, 1.0), 1.0);
+            }
+
+            if (trigger.w == -1 || trigger.w == 2) { // pressure plate room & spinning object
+                gl_FragColor = mix(gl_FragColor, vec4((round(dbgvvertex.x) == round(camera.x)) ? 1 : gl_FragColor.x, 
+                    (round(dbgvvertex.y) == round(camera.y)) ? 1 : gl_FragColor.y, 
+                    (round(dbgvvertex.z) == round(camera.z)) ? 1 : gl_FragColor.z, 
+                    0.0), 1.0);
+
+            }
+            if (trigger.w == 4 || trigger.w == 6) { // lantern cave
+                vec2 center = vec2(@scr_w / 2, @scr_h / 2);  // Center of the lantern effect
+                float outerRadius = 512.0;                   // Radius of the outer glow
+                float innerRadius = 128.0;                   // Radius of the bright center
+                float dist = length(gl_FragCoord.xy - center); // Distance from the center
+
+                if (trigger.w == 6) { // auggiedog
+                    diffuse = texture2D(tsky, texcoord0 + vec2(
+                        sin(texcoord0.y * 10.0 + millis * 2) * 0.02,
+                        cos(texcoord0.x * 10.0 + millis * 2) * 0.02
+                    ));
+                }
+
+                if (dist < outerRadius) { // Inside the outer lantern radius
+                    float outerFalloff = 1.0 - (dist / outerRadius); // Fade from edge to center of outer radius
+                    vec3 outerColor = mix(vec3(0.0), diffuse.rgb, outerFalloff); // Black to diffuse.rgb
+
+                    if (dist < innerRadius) { // Inside the bright center radius
+                        float innerFalloff = 1.0 - (dist / innerRadius); // Stronger fade for center
+                        vec3 innerColor = mix(outerColor, diffuse.rgb * 1.5, innerFalloff); // Brighten diffuse.rgb in the center
+                        gl_FragColor = vec4(innerColor, 1.0);
+                    } else {
+                        gl_FragColor = vec4(outerColor, 1.0);
+                    }
+                } else {
+                    // Outside the radius, set color to black
+                    gl_FragColor = vec4(diffuse.rgb-0.6, 1.0);
+                }
+            }
+
+            if (trigger.w == 5) { // switch
+                gl_FragColor = vec4(1.0, 1.0, 0.5, 0.0);
+            }
+
+            if (trigger.w == 3) { // house wall/ground (lights on)
+                gl_FragColor = diffuse * vec4(lm.b, lm.b, lm.b, 1.0);
+            }
+
+        } else {
+            if (trigger.w == 4 || trigger.w == 6) { // lantern cave
+                gl_FragColor = vec4((diffuse.rgb*lm.rgb)-0.05, 1.0);
+                //gl_FragColor = vec4(0.0);
+            }
+            if (trigger.w == 3) { // house wall/ground (lights off)
+                gl_FragColor = (diffuse-0.1) * vec4(lm.r, lm.r, lm.r, 1.0);
+            }
+        }
+        
+
+        if (trigger.w == 7) { // room psicodelic 
+            
+        }
+
+        
+
+    }
+]
+
+
+_SD_modeltrigger = [
+    local shadername position radius body
+    shadername = $arg1 
+    position = $arg2
+    radius = $arg3
+    body = $arg4
+    _SD_loadingmodelshader = $shadername
+    shader 0 $shadername [
+        // Vertex Shader
+        attribute vec4 vvertex, vcolor;
+        attribute vec2 vtexcoord0;
+        varying vec2 texcoord0;
+        varying vec4 color;
+        uniform mat4 modelmatrix;
+        uniform vec3 camera;
+        vec3 trigger = vec3(@(at $position 0), @(at $position 1), @(at $position 2));
+        vec3 triggerradius = vec3(@(at $radius 0), @(at $radius 1), @(at $radius 2));
+        varying vec2 is_triggered;
+
+        void main(void)
+        {
+            gl_Position = modelmatrix * vvertex;
+            texcoord0 = vtexcoord0;
+            color = vcolor;
+
+            is_triggered.x = float(abs(camera.x - trigger.x) <= triggerradius.x &&
+                abs(camera.y - trigger.y) <= triggerradius.y &&
+                abs(camera.z - trigger.z) <= triggerradius.z);
+        }
+    ] [
+        // Fragment Shader
+        uniform sampler2D diffusemap;
+        varying vec2 texcoord0;
+        varying vec4 color;
+        uniform vec3 camera;
+        vec4 diffuse = texture2D(diffusemap, texcoord0);
+        varying vec2 is_triggered;
+
+        int is_active = int(round(is_triggered.x));
+        
+        void main(void)
+        {
+            @body
+        }
+    ]
+]
+
+_SD_modeltrigger [_conceptshaders_lamp@getmillis] [1260 918 1040] [5 5 5] [
+    gl_FragColor = (is_active == 0) ? ((diffuse-0.1) - vec4(diffuse.r > 0.5, diffuse.g > 0.5, diffuse.b > 0.5, 0)) : diffuse;
+]
+mmodel "conceptshaders/bulb"
+clearmodel "conceptshaders/bulb"
+
+_SD_modeltrigger [_conceptshaders_furniture@getmillis] [1260 918 1040] [5 5 5] [
+    gl_FragColor = (is_active == 0) ? vec4(diffuse.rgb*0.05, 1)-0.01 : diffuse-0.05;
+]
+
+mmodel "conceptshaders/bed01"
+mmodel "conceptshaders/chair01"
+mmodel "conceptshaders/table01"
+clearmodel "conceptshaders/bed01"
+clearmodel "conceptshaders/chair01"
+clearmodel "conceptshaders/table01"
+
+setshader [_conceptshaders_shadersdemo@getmillis]
+
+texture 0 "textures/fatum/white.jpg"
+texture 0 "textures/philipk/pk02/floor09a_c.jpg"
+texture 0 "textures/yves_allaire/ex/cretebase_01_d.jpg"
+texture 0 "mitaman/mm-auggiedog.jpg"
+texture 0 "textures/nieb/rock02.jpg"
+texture 0 "dg/mad065.jpg"
+texture 0 "ik2k/ik_woodv256a.jpg"
+texture 0 "<mad:3>egyptsoc/wood17.jpg"
+
+_getRayHit = [
+	local PI X Y Z SZ YAW PITCH PLANE YAWRAD PITCHRAD DIRX DIRY DIRZ DISTANCE HITX HITY
+	PI = 3.141592653589793
+
+	X = (at (getcampos) 0)
+	Y = (at (getcampos) 1)
+	Z = (at (getcampos) 2)
+	SZ = (at (getselpos) 2)
+
+	YAW = (getcamyaw)
+	PITCH = (getcampitch)
+
+	PLANE = (? (< $Z $SZ) $SZ (+ $SZ (div (<< 2 $gridpower) 2)))
+
+	YAWRAD = (-f 90 $YAW)
+	PITCHRAD = $PITCH
+
+
+	DIRX = (*f (cos $PITCHRAD) (cos $YAWRAD))
+	DIRY = (*f (cos $PITCHRAD) (sin $YAWRAD))
+	DIRZ = (sin $PITCHRAD)
+
+	DISTANCE = (divf (-f $PLANE $Z) $DIRZ)
+
+	HITX = (-f $X (*f $DIRX $DISTANCE))
+	HITY = (+f $Y (*f $DIRY $DISTANCE))
+
+	concat $HITX $HITY $PLANE
+]
+
+
+