separate posterizer shader, new testing map
This commit is contained in:
		@ -113,6 +113,7 @@ lights := [MAX_LIGHTS]Light{}
 | 
			
		||||
main :: proc() {
 | 
			
		||||
	rl.SetConfigFlags({.WINDOW_RESIZABLE, .MSAA_4X_HINT})
 | 
			
		||||
	rl.InitWindow(900, 600, "flash")
 | 
			
		||||
	// rl.SetTargetFPS(60)
 | 
			
		||||
	// rl.ToggleBorderlessWindowed()
 | 
			
		||||
 | 
			
		||||
	checker := rl.GenImageChecked(128, 128, 32, 32, {128, 128, 128, 255}, {150, 150, 150, 255})
 | 
			
		||||
@ -126,7 +127,7 @@ main :: proc() {
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
	w, h := rl.GetScreenWidth(), rl.GetScreenHeight()
 | 
			
		||||
	pixelize: i32 = 2
 | 
			
		||||
	pixelize: i32 = 4
 | 
			
		||||
	target := rl.LoadRenderTexture(w / pixelize, h / pixelize)
 | 
			
		||||
	posttarget := rl.LoadRenderTexture(w / pixelize, h / pixelize)
 | 
			
		||||
 | 
			
		||||
@ -139,20 +140,24 @@ main :: proc() {
 | 
			
		||||
	checkmtl.shader = shader
 | 
			
		||||
 | 
			
		||||
	for i := 0; i < 4; i += 1 {
 | 
			
		||||
		light_new(&shader, {}, 0, 10, 0.8)
 | 
			
		||||
		light_new(&shader, {}, 0, 6, 0.8)
 | 
			
		||||
		hsvcol := rl.ColorFromHSV((f32(i) - 1.0) * 360 / 3, 1, 1)
 | 
			
		||||
		col := rl.ColorNormalize(hsvcol)
 | 
			
		||||
		if i > 0 do lights[i].color = col
 | 
			
		||||
		light_update_uniforms(&lights[i])
 | 
			
		||||
	}
 | 
			
		||||
	lights[0].power = 0.9
 | 
			
		||||
	lights[0].distanceNear = 0
 | 
			
		||||
	lights[0].distanceFar = 25
 | 
			
		||||
	lights[0].distanceFar = 6
 | 
			
		||||
	light_update_uniforms(&lights[0])
 | 
			
		||||
	rl.SetShaderValue(shader, lights[0].distanceNearLoc, &(lights[0].distanceNear), .FLOAT)
 | 
			
		||||
	rl.SetShaderValue(shader, lights[0].powerLoc, &(lights[0].power), .FLOAT)
 | 
			
		||||
	// rl.SetShaderValue(shader, lights[0].distanceNearLoc, &(lights[0].distanceNear), .FLOAT)
 | 
			
		||||
	// rl.SetShaderValue(shader, lights[0].powerLoc, &(lights[0].power), .FLOAT)
 | 
			
		||||
 | 
			
		||||
	// sponza := rl.LoadModel("assets/models/sponza.glb")
 | 
			
		||||
	// for &material in sponza.materials[:sponza.materialCount] {
 | 
			
		||||
	// 	material.shader = shader
 | 
			
		||||
	// }
 | 
			
		||||
	mdl := rl.LoadModel("assets/models/unnamed.obj")
 | 
			
		||||
	mdl := rl.LoadModel("assets/mapping/testdungeon.obj")
 | 
			
		||||
	for &material in mdl.materials[:mdl.materialCount] {
 | 
			
		||||
		material.shader = shader
 | 
			
		||||
	}
 | 
			
		||||
@ -165,7 +170,7 @@ main :: proc() {
 | 
			
		||||
	meshes := [dynamic]Mesh{}
 | 
			
		||||
 | 
			
		||||
	// vtx := [dynamic]f32{}
 | 
			
		||||
	scale: f32 = 0.04
 | 
			
		||||
	scale: f32 = 32
 | 
			
		||||
	for &mesh in mdl.meshes[:mdl.meshCount] {
 | 
			
		||||
		// mesh := mdl.meshes[mdl.meshCount-1]
 | 
			
		||||
		append(&meshes, Mesh{aabb = {{9999, 9999, 9999}, {-9999, -9999, -9999}}})
 | 
			
		||||
@ -176,7 +181,7 @@ main :: proc() {
 | 
			
		||||
			for j: i32 = 0; j < 3; j += 1 {
 | 
			
		||||
				c := j * 3
 | 
			
		||||
				for k: i32 = 0; k < 3; k += 1 {
 | 
			
		||||
					value := mesh.vertices[i + c + k] * scale
 | 
			
		||||
					value := mesh.vertices[i + c + k] / scale
 | 
			
		||||
					if value < m.aabb[0][k] {
 | 
			
		||||
						m.aabb[0][k] = value
 | 
			
		||||
					}
 | 
			
		||||
@ -218,7 +223,7 @@ main :: proc() {
 | 
			
		||||
 | 
			
		||||
	look_angles: rl.Vector2 = 0
 | 
			
		||||
	cam := rl.Camera3D {
 | 
			
		||||
		position   = {0, 5, 0},
 | 
			
		||||
		position   = {0, 2, 0},
 | 
			
		||||
		target     = {1, 2, 0},
 | 
			
		||||
		up         = {0, 1, 0},
 | 
			
		||||
		fovy       = 90,
 | 
			
		||||
@ -252,8 +257,8 @@ main :: proc() {
 | 
			
		||||
		look_angles.y -= rl.GetMouseDelta().x * 0.0015
 | 
			
		||||
		look_angles.x += rl.GetMouseDelta().y * 0.0015
 | 
			
		||||
 | 
			
		||||
		SPEED :: 40
 | 
			
		||||
		RAD :: 1
 | 
			
		||||
		SPEED :: 20
 | 
			
		||||
		RAD :: 0.5
 | 
			
		||||
 | 
			
		||||
		moving := false
 | 
			
		||||
		if rl.IsKeyDown(.W) {
 | 
			
		||||
@ -272,7 +277,7 @@ main :: proc() {
 | 
			
		||||
			vel.xz += right.xz * delta * SPEED
 | 
			
		||||
			moving = true
 | 
			
		||||
		}
 | 
			
		||||
		vel.xz = rl.Vector2ClampValue(vel.xz, 0, 5)
 | 
			
		||||
		vel.xz = rl.Vector2ClampValue(vel.xz, 0, 3)
 | 
			
		||||
 | 
			
		||||
		if rl.IsKeyDown(.E) do vel.y += delta * SPEED
 | 
			
		||||
		if rl.IsKeyDown(.Q) do vel.y -= delta * SPEED
 | 
			
		||||
@ -285,28 +290,30 @@ main :: proc() {
 | 
			
		||||
		// damping
 | 
			
		||||
		vel *= 1.0 / (1.0 + delta * 2)
 | 
			
		||||
 | 
			
		||||
		campos := cam.position + {0, -0.4, 0}
 | 
			
		||||
		// Collide
 | 
			
		||||
		for mesh in meshes {
 | 
			
		||||
			if cam.position.x + RAD < mesh.aabb[0].x &&
 | 
			
		||||
			   cam.position.y + RAD < mesh.aabb[0].y &&
 | 
			
		||||
			   cam.position.z + RAD < mesh.aabb[0].z &&
 | 
			
		||||
			   cam.position.x - RAD > mesh.aabb[1].x &&
 | 
			
		||||
			   cam.position.y - RAD > mesh.aabb[1].y &&
 | 
			
		||||
			   cam.position.z - RAD > mesh.aabb[1].z {continue}
 | 
			
		||||
			// if cam.position.x + RAD < mesh.aabb[0].x &&
 | 
			
		||||
			//    cam.position.y + RAD < mesh.aabb[0].y &&
 | 
			
		||||
			//    cam.position.z + RAD < mesh.aabb[0].z &&
 | 
			
		||||
			//    cam.position.x - RAD > mesh.aabb[1].x &&
 | 
			
		||||
			//    cam.position.y - RAD > mesh.aabb[1].y &&
 | 
			
		||||
			//    cam.position.z - RAD > mesh.aabb[1].z {continue}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
			for t in mesh.triangles {
 | 
			
		||||
				closest := closest_point_on_triangle(cam.position, t[0], t[1], t[2])
 | 
			
		||||
				diff := cam.position - closest
 | 
			
		||||
				closest := closest_point_on_triangle(campos, t[0], t[1], t[2])
 | 
			
		||||
				diff := campos - closest
 | 
			
		||||
				dist := linalg.length(diff)
 | 
			
		||||
				normal := diff / dist
 | 
			
		||||
				diff.xz *= 2
 | 
			
		||||
				// diff.xz *= 2
 | 
			
		||||
				dist = linalg.length(diff)
 | 
			
		||||
 | 
			
		||||
				rl.DrawCubeV(closest, 0.05, dist > RAD ? rl.ORANGE : rl.WHITE)
 | 
			
		||||
 | 
			
		||||
				if dist < RAD {
 | 
			
		||||
					cam.position += normal * (RAD - dist)
 | 
			
		||||
				if dist <= RAD {
 | 
			
		||||
					// cam.position += normal * (RAD - dist)
 | 
			
		||||
					cam.position = closest + normal * RAD - {0, -0.4, 0}
 | 
			
		||||
					// project velocity to the normal plane, if moving towards it
 | 
			
		||||
					vel_normal_dot := linalg.dot(vel, normal)
 | 
			
		||||
					if vel_normal_dot < 0 {
 | 
			
		||||
@ -339,9 +346,9 @@ main :: proc() {
 | 
			
		||||
			move_light(
 | 
			
		||||
				&light,
 | 
			
		||||
				{
 | 
			
		||||
					math.cos_f32(rotation + (f32(i) / f32(3)) * math.PI * 2) * 5,
 | 
			
		||||
					3,
 | 
			
		||||
					math.sin_f32(rotation + (f32(i) / f32(3)) * math.PI * 2) * 5,
 | 
			
		||||
					math.cos_f32(rotation + (f32(i) / f32(3)) * math.PI * 2) * 3,
 | 
			
		||||
					2,
 | 
			
		||||
					-1.5 + math.sin_f32(rotation + (f32(i) / f32(3)) * math.PI * 2) * 3,
 | 
			
		||||
				},
 | 
			
		||||
			)
 | 
			
		||||
			rl.DrawSphere(light.position, 0.1, transmute(rl.Color)color)
 | 
			
		||||
@ -363,7 +370,7 @@ main :: proc() {
 | 
			
		||||
		// 	}
 | 
			
		||||
		// }
 | 
			
		||||
		rl.BeginShaderMode(shader)
 | 
			
		||||
		rl.DrawModelEx(mdl, {}, {}, 0, 0.04, rl.WHITE)
 | 
			
		||||
		rl.DrawModelEx(mdl, {}, {}, 0, 1 / scale, rl.WHITE)
 | 
			
		||||
 | 
			
		||||
		rl.EndShaderMode()
 | 
			
		||||
		rl.EndMode3D()
 | 
			
		||||
@ -385,7 +392,7 @@ main :: proc() {
 | 
			
		||||
			0,
 | 
			
		||||
			rl.WHITE,
 | 
			
		||||
		)
 | 
			
		||||
		rl.DrawFPS(0, 0)
 | 
			
		||||
		rl.DrawFPS(10, 10)
 | 
			
		||||
		rl.EndDrawing()
 | 
			
		||||
	}
 | 
			
		||||
}
 | 
			
		||||
@ -393,7 +400,7 @@ main :: proc() {
 | 
			
		||||
 | 
			
		||||
vshader: cstring = #load("../assets/shaders/vshader.glsl", cstring)
 | 
			
		||||
fshader: cstring = #load("../assets/shaders/fshader.glsl", cstring)
 | 
			
		||||
postprocess: cstring = #load("../assets/shaders/postprocess.glsl", cstring)
 | 
			
		||||
postprocess: cstring = #load("../assets/shaders/posterizer.glsl", cstring)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
// Real Time collision detection 5.1.5
 | 
			
		||||
 | 
			
		||||
		Reference in New Issue
	
	Block a user