aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/main/kotlin/phenax/utils/program.kt36
-rw-r--r--src/main/kotlin/play/PlayProgram.kt84
-rw-r--r--src/main/resources/shaders/modules/sdf.cs12
-rw-r--r--src/main/resources/shaders/modules/utils.cs4
-rw-r--r--src/main/resources/shaders/play_shader.cs204
5 files changed, 281 insertions, 59 deletions
diff --git a/src/main/kotlin/phenax/utils/program.kt b/src/main/kotlin/phenax/utils/program.kt
index a05307c..d3788ea 100644
--- a/src/main/kotlin/phenax/utils/program.kt
+++ b/src/main/kotlin/phenax/utils/program.kt
@@ -8,6 +8,11 @@ import org.openrndr.draw.*
import org.openrndr.extra.filewatcher.watchingFile
import org.openrndr.extra.olive.oliveProgram as oliveProgramOriginal
+enum class ActionType {
+ PAN,
+ LIGHT_MOVE
+}
+
fun Int.seconds(): Int = this * 1000
fun Int.minutes(): Int = this.seconds() * 60
@@ -37,11 +42,31 @@ fun ApplicationBuilder.oliveProgram(init: Program.() -> Unit) {
}
}
+fun preprocessShader(shaderCode: String): String {
+ val pattern = Regex("#include\\s+<([A-Za-z0-9-_/.]+)>")
+ val includes = pattern.findAll(shaderCode)
+ var parts: MutableList<String> = mutableListOf()
+ var lastIndex = 0
+ includes.forEach {
+ parts.add(shaderCode.slice(lastIndex..(it.range.first - 1)))
+ lastIndex = it.range.last + 1
+ val modulePath = it.groupValues[1]
+ val moduleContents = File("src/main/resources/shaders/modules/${modulePath}.cs").readText()
+ parts.add("/* Module ${modulePath} */")
+ parts.add(moduleContents)
+ parts.add("/* End module ${modulePath} */")
+ }
+ parts.add(shaderCode.slice(lastIndex..(shaderCode.length - 1)))
+ return parts.joinToString(separator = "\n")
+}
+
+val defaultShaderCode: String = ""
+
fun Program.liveComputeShader(name: String): ReadOnlyProperty<Any?, ComputeShader> {
val shaderCode by
watchingFile(File("src/main/resources/shaders/${name}.cs")) { file ->
println("change")
- file.readText()
+ preprocessShader(file.readText().toString())
}
var cs: ComputeShader = ComputeShader.fromCode(shaderCode, name)
@@ -55,9 +80,14 @@ fun Program.liveComputeShader(name: String): ReadOnlyProperty<Any?, ComputeShade
try {
cs = ComputeShader.fromCode(shaderCode, name)
} catch (e: Exception) {
- // Restore old shader if new code has error
- cs = ComputeShader.fromCode(lastCompiledCode, name)
println("Shader compile failed: ${e.message}")
+ // Restore old shader if new code has error or default shader
+ try {
+ cs = ComputeShader.fromCode(lastCompiledCode, name)
+ } catch (e: Exception) {
+ println("Falling back to default shader")
+ cs = ComputeShader.fromCode(defaultShaderCode, name)
+ }
}
lastCompiledCode = shaderCode
}
diff --git a/src/main/kotlin/play/PlayProgram.kt b/src/main/kotlin/play/PlayProgram.kt
index 0ec0133..4840a89 100644
--- a/src/main/kotlin/play/PlayProgram.kt
+++ b/src/main/kotlin/play/PlayProgram.kt
@@ -1,9 +1,11 @@
package play
-import java.io.File
-import org.openrndr.Program
+import org.openrndr.KeyModifier
import org.openrndr.application
+import org.openrndr.color.*
import org.openrndr.draw.*
+import org.openrndr.extra.noise.filters.SimplexNoise3D
+import org.openrndr.math.Vector3
import phenax.utils.*
fun main() = application {
@@ -16,32 +18,78 @@ fun main() = application {
}
oliveProgram {
+ val font = loadFont("data/fonts/default.otf", 16.0)
val cs by liveComputeShader("play_shader")
- // val image = loadImage("data/images/pm5544.png")
- // val font = loadFont("data/fonts/default.otf", 64.0)
- // val inputBuffer = colorBuffer(width, height, type = ColorType.UINT8)
val outputBuffer = colorBuffer(width, height, type = ColorType.UINT8)
- extend {
- // drawer.drawStyle.colorMatrix = tint(ColorRGBa.WHITE.shade(0.2))
- // drawer.image(image)
+ var cameraPosition: Vector3 = Vector3(0.0, 1.0, 0.0)
+ var lightPosition: Vector3 = Vector3(1.0, 2.0, 1.0)
+ var actionType: ActionType? = null
+ var lastPos: Vector3? = null
+
+ mouse.moved.listen {
+ val dimens = Vector3(program.width.toDouble(), program.height.toDouble(), 1.0)
+ val pos = (Vector3(it.position.x, -it.position.y, 0.0) - dimens / 2.0).div(dimens)
+ if (actionType == ActionType.PAN) {
+ lastPos?.let { prev -> cameraPosition -= (pos - prev) }
+ } else if (actionType == ActionType.LIGHT_MOVE) {
+ lastPos?.let { prev -> lightPosition += (pos - prev) }
+ }
+ actionType?.let { lastPos = pos }
+ }
+ mouse.buttonDown.listen {
+ val isCtrl = KeyModifier.CTRL in it.modifiers
+ actionType =
+ if (isCtrl) {
+ ActionType.LIGHT_MOVE
+ } else {
+ ActionType.PAN
+ }
+ }
+ mouse.scrolled.listen {
+ val isCtrl = KeyModifier.CTRL in it.modifiers
+ if (isCtrl) {
+ lightPosition += Vector3(0.0, 0.0, it.rotation.y * 0.1)
+ } else {
+ cameraPosition += Vector3(0.0, 0.0, it.rotation.y * 0.1)
+ }
+ }
+ mouse.buttonUp.listen {
+ actionType = null
+ lastPos = null
+ }
- // drawer.fill = ColorRGBa.PINK
- // drawer.circle(
- // cos(seconds) * width / 2.0 + width / 2.0,
- // sin(0.5 * seconds) * height / 2.0 + height / 2.0,
- // 140.0
- // )
+ val noiseBuffer = colorBuffer(width, height, type = ColorType.UINT8)
+ val noiseFilter = SimplexNoise3D()
- // drawer.fontMap = font
- // drawer.fill = ColorRGBa.WHITE
- // drawer.text("OPENRNDR", width / 2.0, height / 2.0)
+ extend {
+ noiseFilter.seed = Vector3(0.0, 0.0, 0.1)
+ noiseFilter.scale = Vector3.ONE * 1.0
+ noiseFilter.octaves = 8
+ noiseFilter.premultipliedAlpha = true
+ noiseFilter.apply(emptyArray(), noiseBuffer)
+ cs.image("noise_texture", 0, noiseBuffer.imageBinding(0, ImageAccess.READ))
cs.uniform("seconds", seconds)
- cs.image("outputImg", 1, outputBuffer.imageBinding(0, ImageAccess.WRITE))
+ cs.uniform("camera_position", cameraPosition)
+ cs.uniform("primary_light_position", lightPosition)
+ cs.image("output_image", 1, outputBuffer.imageBinding(0, ImageAccess.WRITE))
cs.execute(outputBuffer.width, outputBuffer.height, 1)
drawer.image(outputBuffer)
+
+ drawer.fontMap = font
+ drawer.fill = ColorRGBa.WHITE
+ drawer.text(
+ "C: %.2f %.2f %.2f".format(cameraPosition.x, cameraPosition.y, cameraPosition.z),
+ 8.0,
+ 16.0
+ )
+ drawer.text(
+ "L: %.2f %.2f %.2f".format(lightPosition.x, lightPosition.y, lightPosition.z),
+ 8.0,
+ 32.0
+ )
}
}
}
diff --git a/src/main/resources/shaders/modules/sdf.cs b/src/main/resources/shaders/modules/sdf.cs
new file mode 100644
index 0000000..8121b18
--- /dev/null
+++ b/src/main/resources/shaders/modules/sdf.cs
@@ -0,0 +1,12 @@
+float sdf_circle(in vec3 p, in float radius) {
+ return length(p) - radius;
+}
+
+float sdf_plane(in vec3 p, in vec3 normal, in float offset) {
+ return dot(p, normal) + offset;
+}
+
+float sdf_box(in vec3 p, in vec3 dimens, in float rounding) {
+ vec3 q = abs(p) - dimens + rounding;
+ return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0) - rounding;
+}
diff --git a/src/main/resources/shaders/modules/utils.cs b/src/main/resources/shaders/modules/utils.cs
new file mode 100644
index 0000000..1616e8c
--- /dev/null
+++ b/src/main/resources/shaders/modules/utils.cs
@@ -0,0 +1,4 @@
+float smin(float a, float b, float k) {
+ float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
+ return mix(b, a, h) - k * h * (1.0 - h);
+}
diff --git a/src/main/resources/shaders/play_shader.cs b/src/main/resources/shaders/play_shader.cs
index d3cd4f5..c92e8b6 100644
--- a/src/main/resources/shaders/play_shader.cs
+++ b/src/main/resources/shaders/play_shader.cs
@@ -1,75 +1,203 @@
#version 430
layout(local_size_x = 1, local_size_y = 1) in;
+#include <sdf>
+#include <utils>
+
uniform float seconds = 0;
-layout(rgba8) uniform writeonly image2D outputImg;
+layout(rgba8) uniform readonly image2D noise_texture;
+layout(rgba8) uniform writeonly image2D output_image;
+uniform vec3 camera_position = vec3(0, 1, 0);
+uniform vec3 uv_direction = vec3(0);
+uniform vec3 primary_light_position = vec3(1, 2, 1);
-#define MAX_ITERATIONS 500
+#define MAX_RAYMARCH_ITERATIONS 500
#define MAX_DISTANCE 100.0
-#define SURF_DIST 0.01
+#define SURFACE_DIST 0.01
+
+// Noise Related Functions
+float mod289(float x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 perm(vec4 x) { return mod289(((x * 34.0) + 1.0) * x); }
+float noise(vec3 p) {
+ vec3 a = floor(p);
+ vec3 d = p - a;
+ d = d * d * (3.0 - 2.0 * d);
+ vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);
+ vec4 k1 = perm(b.xyxy);
+ vec4 k2 = perm(k1.xyxy + b.zzww);
+ vec4 c = k2 + a.zzzz;
+ vec4 k3 = perm(c);
+ vec4 k4 = perm(c + 1.0);
+ vec4 o1 = fract(k3 * (1.0 / 41.0));
+ vec4 o2 = fract(k4 * (1.0 / 41.0));
+ vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);
+ vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);
+ return o4.y * d.y + o4.x * (1.0 - d.y);
+}
+float PHI = 1.61803398874989484820459; // Φ = Golden Ratio
+float gold_noise(in vec2 xy, in float seed) {
+ return fract(tan(distance(xy * PHI, xy) * seed) * xy.x);
+}
+float random(vec3 scale, float seed) {
+ return fract(sin(dot(gl_GlobalInvocationID.xyz + seed, scale)) * 43758.5453 +
+ seed);
+}
-float sdfCircle(in vec3 p, in vec3 origin, in float radius) {
- return length(p - origin) - radius;
+// Fractal Brownian Noise
+float fbm(vec3 x, int octaves) {
+ float v = 0.0;
+ float a = 0.5;
+ vec3 shift = vec3(100);
+ for (int i = 0; i < octaves; ++i) {
+ v += a * noise(x);
+ x = x * 2.0 + shift;
+ a *= 0.5;
+ }
+ return v;
}
-float smin(float a, float b, float k) {
- float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
- return mix(b, a, h) - k * h * (1.0 - h);
+float random(vec2 st) {
+ return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
}
-float scene(in vec3 p) {
- float c1 = sdfCircle(p, vec3(0, 1, 2.4), 0.2);
- float c2 = sdfCircle(p, vec3(-0.6, 1, 3), 0.3);
- return min(c1, c2);
+float noise(vec2 st) {
+ vec2 i = floor(st);
+ vec2 f = fract(st);
+ float a = random(i);
+ float b = random(i + vec2(1.0, 0.0));
+ float c = random(i + vec2(0.0, 1.0));
+ float d = random(i + vec2(1.0, 1.0));
+ vec2 u = f * f * (3.0 - 2.0 * f);
+ return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
}
-float ray_march_scene(in vec3 ray_origin, in vec3 ray_direction) {
+float fbm(vec2 st) {
+ float value = 0.0;
+ float amplitude = 0.5;
+ for (int i = 0; i < 5; i++) {
+ value += amplitude * noise(st);
+ st *= 2.0;
+ amplitude *= 0.5;
+ }
+ return value;
+}
+
+// TODO: Enumify
+#define OID_TERRAIN 4.
+
+vec2 scene(in vec3 p) {
+ float c1 = sdf_circle(p - vec3(0, 1, 2.4), 0.2);
+ float c2 = sdf_circle(p - vec3(-0.6, 1, 3), 0.3);
+ float box = sdf_box(p - vec3(1, 0.5, 3), vec3(0.5, 0.18, 0.2), 0.07);
+ float terrain_noise =
+ 3.0 * noise(p / 20.0) + noise(p / 4.0) + noise(p * 5) / 30.0;
+ float terrain =
+ sdf_plane(p + vec3(0.0, terrain_noise, 0.0), vec3(0.0, 1.0, 0.0), 0.0);
+ float light_indicator =
+ sdf_circle(p - primary_light_position + vec3(0.1, 0.1, -0.4), 0.01);
+ float dist = min(min(min(min(c1, c2), terrain), box), light_indicator);
+ float oid = 0.;
+ if (dist == c1)
+ oid = 1.;
+ else if (dist == c2)
+ oid = 2.;
+ else if (dist == box)
+ oid = 3.;
+ else if (dist == terrain)
+ oid = OID_TERRAIN;
+ else if (dist == light_indicator)
+ oid = -1.;
+ return vec2(dist, oid);
+}
+
+vec2 ray_march_scene(in vec3 ray_origin, in vec3 ray_direction) {
float dist = 0.;
- for (int i = 0; i < MAX_ITERATIONS && dist < MAX_DISTANCE; i++) {
+ for (int i = 0; i < MAX_RAYMARCH_ITERATIONS && dist < MAX_DISTANCE; i++) {
vec3 p = ray_origin + dist * ray_direction;
- float gap = scene(p);
+ vec2 obj = scene(p);
+ float gap = obj.x;
dist += gap;
- if (gap <= SURF_DIST)
- return dist;
+ if (gap <= SURFACE_DIST)
+ return vec2(dist, obj.y);
}
- return dist;
+ return vec2(dist, 0.0);
}
vec3 surface_normal_scene(in vec3 p) {
vec2 inc = vec2(0.01, 0);
- return normalize(vec3(scene(p + inc.xyy) - scene(p - inc.xyy),
- scene(p + inc.yxy) - scene(p - inc.yxy),
- scene(p + inc.yyx) - scene(p - inc.yyx)));
+ return normalize(vec3(scene(p + inc.xyy).x - scene(p - inc.xyy).x,
+ scene(p + inc.yxy).x - scene(p - inc.yxy).x,
+ scene(p + inc.yyx).x - scene(p - inc.yyx).x));
+}
+
+float shadow_scene(in vec3 ray_origin, in vec3 ray_direction,
+ in float light_intensity) {
+ float dist = 0.;
+ float res = 1.;
+ float ph = 1e10;
+ for (int i = 0; i < 50 && dist < MAX_DISTANCE; i++) {
+ vec3 p = ray_origin + dist * ray_direction;
+ vec2 obj = scene(p);
+ float gap = obj.x;
+ if (obj.y < 0.) // Debug objects dont cast shadows
+ continue;
+ float y = gap * gap / (2.0 * ph);
+ float d = sqrt(gap * gap - y * y);
+ res = min(res, light_intensity * d / max(0.0, dist - y));
+ ph = gap;
+ dist += gap;
+
+ if (res < 0.0001)
+ break;
+ }
+ res = clamp(res, 0.08, 1.0);
+
+ return res * res * (3.0 - 2.0 * res);
}
void main() {
- vec2 resolution = vec2(imageSize(outputImg).xy);
+ vec2 resolution = vec2(imageSize(output_image).xy);
vec3 uv = vec3((gl_GlobalInvocationID.xy - resolution / 2.0) / resolution, 0);
float aspect_ratio = resolution.y / resolution.x;
uv /= vec3(aspect_ratio, 1, 1);
- vec3 camera_pos = vec3(0, 1, 0);
- vec3 camera_direction = normalize(vec3(uv.x, uv.y, 1.));
+ vec3 uv_direction = normalize(vec3(uv.x, uv.y, 1));
- vec3 light_pos = vec3(1, 2. * sin(seconds), 1);
+ vec3 light_pos = primary_light_position;
- float depth = ray_march_scene(camera_pos, camera_direction);
- vec3 p = camera_pos + camera_direction * depth;
+ vec2 obj = ray_march_scene(camera_position, uv_direction);
+ float depth = obj.x;
+ float oid = obj.y;
+ vec3 p = camera_position + uv_direction * depth;
vec3 normal = surface_normal_scene(p);
- vec3 light_vec = normalize(light_pos - p);
+ vec3 light_dir = normalize(light_pos - p);
+ vec3 hal = normalize(light_dir - uv_direction);
- float contrast = dot(normal, light_vec);
- contrast = clamp(contrast, 0.1, 1.);
+ vec3 col = vec3(0.9, 0.3, 0.4);
+ if (oid < 0.) // Debug objects
+ col = vec3(1.0, 0.2, 0.2);
+ else if (oid == OID_TERRAIN)
+ col = vec3(0.24, 0.61, 0.08);
+ else if (oid == 0) { // Sky
+ vec4 cloud_noise =
+ imageLoad(noise_texture, ivec2(gl_GlobalInvocationID.xy));
+ col = vec3(0.35, 0.6, 0.9);
+ col = mix(col, cloud_noise.xyz, clamp(0.5, 0., 1.));
+ }
- vec3 col = vec3(0.15);
- if (depth < MAX_DISTANCE) {
- float light_ray_dist =
- ray_march_scene(p + 10. * normal * SURF_DIST, light_vec);
- if (light_ray_dist < length(light_pos - p))
- contrast *= 0.3;
- col = vec3(0, 1. - (depth / MAX_DISTANCE), 0.4);
+ if (depth < MAX_DISTANCE && oid > 0.) {
+ float illumination = shadow_scene(p, light_dir, 24.0);
+ float contrast = clamp(dot(normal, light_dir), 0, 1.) * illumination;
+ float spe =
+ pow(clamp(dot(normal, hal), 0.0, 1.0), 16.0) * contrast *
+ (0.04 + 0.96 * pow(clamp(1.0 + dot(hal, uv_direction), 0.0, 1.0), 5.0));
+ col = col * 1.1 + 0.01;
+ col += 12.0 * spe * vec3(1.00, 0.70, 0.5);
col *= contrast;
+ // col *= max(0.2, exp(-0.00005 * depth * depth * depth));
}
- imageStore(outputImg, ivec2(gl_GlobalInvocationID.xy), vec4(col, 1.));
+ imageStore(output_image, ivec2(gl_GlobalInvocationID.xy),
+ vec4(clamp(col, 0., 1.), 1));
}