collada_scene: shadow mapping

_math.lua

@@ -498,6 +498,36 @@ mat4 = {
       return M
    end,
 
+   orthographic_rh = function(view_width, view_height, near_z, far_z)
+      assert(not scalar.near_equal(view_width, 0.0, 0.00001))
+      assert(not scalar.near_equal(view_height, 0.0, 0.00001))
+      assert(not scalar.near_equal(far_z, near_z, 0.00001))
+
+      local f_range = 1.0 / (near_z - far_z)
+
+      local M = mat4()
+        M.m[0 * 4 + 0] = 2.0 / view_width
+      --M.m[0 * 4 + 1] = 0.0
+      --M.m[0 * 4 + 2] = 0.0
+      --M.m[0 * 4 + 3] = 0.0
+
+      --M.m[1 * 4 + 0] = 0.0
+        M.m[1 * 4 + 1] = 2.0 / view_height
+      --M.m[1 * 4 + 2] = 0.0
+      --M.m[1 * 4 + 3] = 0.0
+
+      --M.m[2 * 4 + 0] = 0.0
+      --M.m[2 * 4 + 1] = 0.0
+        M.m[2 * 4 + 2] = f_range
+      --M.m[2 * 4 + 3] = 0.0
+
+      --M.m[3 * 4 + 0] = 0.0
+      --M.m[3 * 4 + 1] = 0.0
+        M.m[3 * 4 + 2] = f_range * near_z
+        M.m[3 * 4 + 3] = 1.0
+        return M
+   end,
+
    near_equal = function(M1, M2, epsilon)
       local d00 = abs(M1.m[0 * 4 + 0] - M2.m[0 * 4 + 0])
       local d01 = abs(M1.m[0 * 4 + 1] - M2.m[0 * 4 + 1])
@@ -759,6 +789,41 @@ vec3 = {
       return result
    end,
 
+   transform = function(v, M)
+      local x = ((M.m[0 * 4 + 0] * v.f[0])
+               + (M.m[1 * 4 + 0] * v.f[1])
+               + (M.m[2 * 4 + 0] * v.f[2])
+               + (M.m[3 * 4 + 0]))
+
+      local y = ((M.m[0 * 4 + 1] * v.f[0])
+               + (M.m[1 * 4 + 1] * v.f[1])
+               + (M.m[2 * 4 + 1] * v.f[2])
+               + (M.m[3 * 4 + 1]))
+
+      local z = ((M.m[0 * 4 + 2] * v.f[0])
+               + (M.m[1 * 4 + 2] * v.f[1])
+               + (M.m[2 * 4 + 2] * v.f[2])
+               + (M.m[3 * 4 + 2]))
+
+      return vec4(x, y, z, 1)
+   end,
+
+   transform_normal = function(v, M)
+      local x = ((M.m[0 * 4 + 0] * v.f[0])
+               + (M.m[1 * 4 + 0] * v.f[1])
+               + (M.m[2 * 4 + 0] * v.f[2]))
+
+      local y = ((M.m[0 * 4 + 1] * v.f[0])
+               + (M.m[1 * 4 + 1] * v.f[1])
+               + (M.m[2 * 4 + 1] * v.f[2]))
+
+      local z = ((M.m[0 * 4 + 2] * v.f[0])
+               + (M.m[1 * 4 + 2] * v.f[1])
+               + (M.m[2 * 4 + 2] * v.f[2]))
+
+      return vec4(x, y, z, 0)
+   end,
+
    equal = function(v1, v2)
       return (
          (v1.f[0] == v2.f[0]) and

build_scene.sh

@@ -0,0 +1,13 @@
+set -eux
+
+cd scene/$1
+
+PYTHONPATH=~/d3d10 \
+    python -m collada.main \
+    $1.DAE \
+    $1.lua \
+    $1.vtx \
+    $1.vjw \
+    $1.idx \
+    $1.rc \
+    $1.mk

collada_scene.lua

@@ -6,10 +6,29 @@ local scalar = _math.scalar
 
 local collada_types = require 'collada_types'
 
-local pixel_data = love.filesystem.newFileData("pixel.glsl")
---local vertex_data = love.filesystem.newFileData("vertex.glsl")
-local vertex_data = love.filesystem.newFileData("skinned_vertex.glsl")
-local shader = love.graphics.newShader(pixel_data, vertex_data)
+local pixel_color_data = love.filesystem.newFileData("pixel_color.glsl")
+local pixel_shadow_data = love.filesystem.newFileData("pixel_shadow.glsl")
+local vertex_static_data = love.filesystem.newFileData("vertex_static.glsl")
+local vertex_skinned_data = love.filesystem.newFileData("vertex_skinned.glsl")
+local shader_color_static = love.graphics.newShader(pixel_color_data, vertex_static_data)
+local shader_color_skinned = love.graphics.newShader(pixel_color_data, vertex_skinned_data)
+local shader_shadow_static = love.graphics.newShader(pixel_shadow_data, vertex_static_data)
+local shader_shadow_skinned = love.graphics.newShader(pixel_shadow_data, vertex_skinned_data)
+
+local shader_set = {
+   shadow = {
+      static = shader_shadow_static,
+      skinned = shader_shadow_skinned,
+   },
+   color = {
+      static = shader_color_static,
+      skinned = shader_color_skinned,
+   },
+}
+
+local send_material
+local current_shader_set
+local current_shader
 
 local images_textures = {}
 local node_instances = {}
@@ -19,12 +38,12 @@ local collada_scene
 local index_buffer
 
 collada_scene = {
-   load_buffers = function()
+   load_buffers = function(idx_path, vtx_path, vjw_path)
       ----------------------------------------------------------------------
       -- index buffer
       ----------------------------------------------------------------------
 
-      local index_data = love.filesystem.newFileData("scene/noodle/noodle.idx")
+      local index_data = love.filesystem.newFileData(idx_path)
       index_buffer = love.graphics.newBuffer("uint32", index_data, { index = true, usage = "static" })
 
       ----------------------------------------------------------------------
@@ -36,18 +55,24 @@ collada_scene = {
          { name = 'Normal', format = 'floatvec4' },
          { name = 'Texture', format = 'floatvec4' },
       }
-      local vtx_data = love.filesystem.newFileData("scene/noodle/noodle.vtx")
+      local vtx_data = love.filesystem.newFileData(vtx_path)
       local vtx_shaderstorage_buffer = love.graphics.newBuffer(vtx_format, vtx_data, { shaderstorage = true, usage = "static" })
 
       local vjw_format = {
          { name = 'Joint', format = 'int32vec4' },
          { name = 'Weight', format = 'floatvec4' },
       }
-      local vjw_data = love.filesystem.newFileData("scene/noodle/noodle.vjw")
-      local vjw_shaderstorage_buffer = love.graphics.newBuffer(vjw_format, vjw_data, { shaderstorage = true, usage = "static" })
+      shader_color_static:send("VertexPNTLayout", vtx_shaderstorage_buffer)
+      shader_color_skinned:send("VertexPNTLayout", vtx_shaderstorage_buffer)
+      shader_shadow_static:send("VertexPNTLayout", vtx_shaderstorage_buffer)
+      shader_shadow_skinned:send("VertexPNTLayout", vtx_shaderstorage_buffer)
 
-      shader:send("VertexPNTLayout", vtx_shaderstorage_buffer)
-      shader:send("VertexJWLayout", vjw_shaderstorage_buffer)
+      local vjw_data = love.filesystem.newFileData(vjw_path)
+      if vjw_data:getSize() ~= 0 then
+         local vjw_shaderstorage_buffer = love.graphics.newBuffer(vjw_format, vjw_data, { shaderstorage = true, usage = "static" })
+         shader_color_skinned:send("VertexJWLayout", vjw_shaderstorage_buffer)
+         shader_shadow_skinned:send("VertexJWLayout", vjw_shaderstorage_buffer)
+      end
    end,
 
    load_images = function(base_path, images)
@@ -65,9 +90,9 @@ collada_scene = {
 
    set_color_or_texture = function(color_or_texture, color_uniform, sampler_uniform)
       if color_or_texture.type == collada_types.color_or_texture_type.COLOR then
-         shader:send(color_uniform, color_or_texture.color)
+         current_shader:send(color_uniform, color_or_texture.color)
       elseif color_or_texture.type == collada_types.color_or_texture_type.TEXTURE then
-         shader:send(sampler_uniform, images_textures[color_or_texture.texture.image_index])
+         current_shader:send(sampler_uniform, images_textures[color_or_texture.texture.image_index])
       else
          assert(false)
       end
@@ -81,7 +106,7 @@ collada_scene = {
          collada_scene.set_color_or_texture(effect.blinn.ambient, "ambient_color", "ambient_sampler");
          collada_scene.set_color_or_texture(effect.blinn.diffuse, "diffuse_color", "diffuse_sampler");
          collada_scene.set_color_or_texture(effect.blinn.specular, "specular_color", "specular_sampler");
-         shader:send("shininess", effect.blinn.shininess);
+         current_shader:send("shininess", effect.blinn.shininess);
       elseif effect.type == collada_types.effect_type.LAMBERT then
          collada_scene.set_color_or_texture(effect.lambert.emission, "emission_color", "emission_sampler");
          collada_scene.set_color_or_texture(effect.lambert.ambient, "ambient_color", "ambient_sampler");
@@ -91,9 +116,9 @@ collada_scene = {
          collada_scene.set_color_or_texture(effect.phong.ambient, "ambient_color", "ambient_sampler");
          collada_scene.set_color_or_texture(effect.phong.diffuse, "diffuse_color", "diffuse_sampler");
          collada_scene.set_color_or_texture(effect.phong.specular, "specular_color", "specular_sampler");
-         shader:send("shininess", effect.phong.shininess);
+         current_shader:send("shininess", effect.phong.shininess);
       elseif effect.type == collada_types.effect_type.CONSTANT then
-         shader:send("emission_color", effect.constant.color)
+         current_shader:send("emission_color", effect.constant.color)
       else
          assert(false)
       end
@@ -104,7 +129,7 @@ collada_scene = {
          instance_material.diffuse.input_set,
          instance_material.specular.input_set,
       }
-      shader:send("texture_channel", texture_channel)
+      current_shader:send("texture_channel", texture_channel)
    end,
 
    draw_geometry = function(geometry, instance_materials)
@@ -112,14 +137,16 @@ collada_scene = {
       local base_index_buffer_offset = mesh.index_buffer_offset / 4
 
       for _, instance_material in ipairs(instance_materials) do
-         collada_scene.set_instance_material(instance_material)
+         if send_material then
+            collada_scene.set_instance_material(instance_material)
+         end
          local triangles = mesh.triangles[instance_material.element_index + 1]
 
          local index_offset = base_index_buffer_offset + triangles.index_offset
          local index_count = triangles.count * 3
 
          local vertex_offset = mesh.vertex_buffer_offset / (4 * 4 * 3)
-         shader:send("VertexPNTOffset", vertex_offset)
+         current_shader:send("VertexPNTOffset", vertex_offset)
          love.graphics.drawFromShader(index_buffer, index_count, 1, 1 + index_offset)
       end
    end,
@@ -142,9 +169,9 @@ collada_scene = {
          local index_count = triangles.count * 3
 
          local mesh_vertex_offset = mesh.vertex_buffer_offset / (4 * 4 * 3)
-         shader:send("VertexPNTOffset", mesh_vertex_offset)
+         current_shader:send("VertexPNTOffset", mesh_vertex_offset)
          local skin_vertex_offset = skin.vertex_buffer_offset / (4 * 4 * 2)
-         shader:send("VertexJWOffset", skin_vertex_offset)
+         current_shader:send("VertexJWOffset", skin_vertex_offset)
 
          love.graphics.drawFromShader(index_buffer, index_count, 1, 1 + index_offset)
       end
@@ -168,17 +195,17 @@ collada_scene = {
          --joints[1].data,
          --joints[2].data,
          --joints[3].data)
-         shader:send("Joints", "column",
-                     mat4.store_table(joints[1]),
-                     mat4.store_table(joints[2]),
-                     mat4.store_table(joints[3]))
+         current_shader:send("Joints", "column",
+                             mat4.store_table(joints[1]),
+                             mat4.store_table(joints[2]),
+                             mat4.store_table(joints[3]))
 
          collada_scene.draw_skin(instance_controller.controller.skin,
                                  instance_controller.instance_materials)
       end
    end,
 
-   draw_node = function(node_state, node, node_instance, transform)
+   draw_node = function(node_state, transform, light_transform, node, node_instance)
       if node.type ~= collada_types.node_type.NODE then
          return
       end
@@ -189,29 +216,87 @@ collada_scene = {
 
       local world = node_instance.world
       transform = world * transform
-      shader:send("world_transform", "column", world.data)
-      shader:send("transform", "column", transform.data)
+      light_transform = world * light_transform
 
-      collada_scene.draw_instance_geometries(node.instance_geometries)
-      collada_scene.draw_instance_controllers(node_state, node.instance_controllers)
+      if node.instance_geometries_count > 0 then
+         current_shader = current_shader_set.static
+         love.graphics.setShader(current_shader)
+         current_shader:send("world_transform", "column", world.data)
+         current_shader:send("light_transform", "column", light_transform.data)
+         current_shader:send("transform", "column", transform.data)
+         collada_scene.draw_instance_geometries(node.instance_geometries)
+      end
+
+      if node.instance_controllers_count > 0 then
+         current_shader = current_shader_set.skinned
+         love.graphics.setShader(current_shader)
+         current_shader:send("world_transform", "column", world.data)
+         current_shader:send("light_transform", "column", light_transform.data)
+         current_shader:send("transform", "column", transform.data)
+         collada_scene.draw_instance_controllers(node_state, node.instance_controllers)
+      end
    end,
 
-   draw_nodes = function(node_state, transform)
-      love.graphics.setShader(shader)
-      shader:send("view_position", {-88.57101, -71.71298, 104.5738, 1.0})
-      shader:send("light_position", {-26.649, -56.804, 58.237, 1.0})
-
+   draw_nodes = function(node_state, transform, light_transform)
       local node_index = 0
       for _, node in ipairs(node_state.nodes) do
          local node_instance = node_state.node_instances[node_index]
-         collada_scene.draw_node(node_state, node, node_instance, transform)
+         collada_scene.draw_node(node_state, transform, light_transform, node, node_instance)
          node_index = node_index + 1
       end
    end,
+
+   draw_scene = function(node_state, perspective_projection, orthographic_projection)
+      local camera_world = node_state.node_instances[node_state.camera].world
+      local view_position = vec3.transform(vec3._zero, camera_world)
+
+      local camera_target_world = node_state.node_instances[node_state.camera_target].world
+      local view_target_position = vec3.transform(vec3._zero, camera_target_world)
+
+      local light_world = node_state.node_instances[node_state.light].world
+      local light_position = vec3.transform(vec3._zero, light_world)
+
+      local up = vec3(0, 0, 1)
+
+      local view = mat4.look_at_rh(view_position, view_target_position, up)
+      local transform = view * perspective_projection
+
+      local light_view = mat4.look_at_rh(light_position, vec3._zero, up)
+      local light_transform = light_view * orthographic_projection
+
+      ----------------------------------------------------------------------
+      -- shadow
+      ----------------------------------------------------------------------
+
+      love.graphics.setCanvas({g_shadow_canvas, depth=true})
+      love.graphics.clear({0.0, 0.0, 0.0, 1.0})
+      current_shader_set = shader_set.shadow
+      send_material = false
+      collada_scene.draw_nodes(node_state, light_transform, light_transform)
+
+      ----------------------------------------------------------------------
+      -- color
+      ----------------------------------------------------------------------
+
+      shader_color_static:send("view_position", view_position.data)
+      shader_color_static:send("light_position", light_position.data)
+      shader_color_static:send("shadow_sampler", g_shadow_canvas)
+
+      shader_color_skinned:send("view_position", view_position.data)
+      shader_color_skinned:send("light_position", light_position.data)
+      shader_color_skinned:send("shadow_sampler", g_shadow_canvas)
+
+      love.graphics.setCanvas()
+      love.graphics.clear({0.0, 0.0, 0.0, 1.0})
+      current_shader_set = shader_set.color
+      send_material = true
+      collada_scene.draw_nodes(node_state, transform, light_transform)
+   end,
 }
 
 return {
    draw_nodes = collada_scene.draw_nodes,
+   draw_scene = collada_scene.draw_scene,
    load_buffers = collada_scene.load_buffers,
    load_node_instances = collada_scene.load_node_instances,
    load_images = collada_scene.load_images,

collada_scene/node_state.lua

@@ -61,6 +61,19 @@ local instance_transforms_from_node = function(node)
    return transforms
 end
 
+local find_node_index_by_name = function(nodes, name)
+   local value = nil
+   local node_index = 0
+   for _, node in ipairs(nodes) do
+      if node.node_name == name then
+         return node_index
+      end
+      node_index = node_index + 1
+   end
+   print(name)
+   assert(false)
+end
+
 local collada_scene_node_state
 
 collada_scene_node_state = {
@@ -103,12 +116,24 @@ collada_scene_node_state = {
             node_index = node_index + 1
          end
       end,
+
+      set_camera = function(this, camera_name, camera_target_name)
+         this.camera = find_node_index_by_name(this.nodes, camera_name)
+         this.camera_target = find_node_index_by_name(this.nodes, camera_target_name)
+      end,
+
+      set_light = function(this, light_name)
+         this.light = find_node_index_by_name(this.nodes, light_name)
+      end,
    },
 
    __call = function(_t, nodes)
       local value = {
          nodes = nodes,
          node_instances = {},
+         camera = nil,
+         camera_target = nil,
+         light = nil,
       }
       setmetatable(value, collada_scene_node_state)
       value:node_instances_new(nodes)

main.lua

@@ -13,16 +13,73 @@ local collada_scene_node_state = require 'collada_scene.node_state'
 
 local scene_test = require 'scene.test.test'
 local scene_noodle = require 'scene.noodle.noodle'
+local scene_sci_fi_ship = require 'scene.sci_fi_ship.sci_fi_ship'
+local scene_shadow_test = require 'scene.shadow_test.shadow_test'
+
+local scenes = {
+   sci_fi_ship = {
+      descriptor = scene_sci_fi_ship.descriptor,
+      image_path = "scene/sci_fi_ship",
+      idx_path = "scene/sci_fi_ship/sci_fi_ship.idx",
+      vtx_path = "scene/sci_fi_ship/sci_fi_ship.vtx",
+      vjw_path = "scene/sci_fi_ship/sci_fi_ship.vjw",
+   },
+   shadow_test = {
+      descriptor = scene_shadow_test.descriptor,
+      image_path = "scene/shadow_test",
+      idx_path = "scene/shadow_test/shadow_test.idx",
+      vtx_path = "scene/shadow_test/shadow_test.vtx",
+      vjw_path = "scene/shadow_test/shadow_test.vjw",
+   },
+}
 
 local node_state
 
+local screen_index_buffer
+local screen_shader
+
+local load_screen_index_buffer = function()
+   local screen_index_data = love.data.newByteData(3 * 2 * 4)
+   local ptr = ffi.cast('uint32_t*', screen_index_data:getFFIPointer())
+   ptr[0] = 0
+   ptr[1] = 1
+   ptr[2] = 2
+
+   ptr[3] = 0
+   ptr[4] = 2
+   ptr[5] = 3
+   screen_index_buffer = love.graphics.newBuffer("uint32", screen_index_data, { index = true, usage = "static" })
+end
+
+local load_screen_shader = function()
+   load_screen_index_buffer()
+
+   local pixel_data = love.filesystem.newFileData("pixel_screen.glsl")
+   local vertex_data = love.filesystem.newFileData("vertex_screen.glsl")
+   screen_shader = love.graphics.newShader(pixel_data, vertex_data)
+end
+
 function love.load(args)
-   love.window.setMode(1024, 1024, {depth=true})
+   love.window.setMode(1024, 1024, {depth=true, resizable=false})
 
-   collada_scene.load_buffers()
-   collada_scene.load_images("scene/noodle", scene_noodle.descriptor.images)
+   local scene = scenes.shadow_test
+   collada_scene.load_buffers(scene.idx_path, scene.vtx_path, scene.vjw_path)
+   collada_scene.load_images(scene.image_path, scene.descriptor.images)
+   node_state = collada_scene_node_state(scene.descriptor.nodes)
+   node_state:set_camera("node_camera001", "node_camera001_target")
+   node_state:set_light("node_direct001")
 
-   node_state = collada_scene_node_state(scene_noodle.descriptor.nodes)
+   ----------------------------------------------------------------------
+   -- canvas
+   ----------------------------------------------------------------------
+
+   g_position_canvas = love.graphics.newCanvas(1024, 1024, {format = "rgba32f"})
+   g_normal_canvas = love.graphics.newCanvas(1024, 1024, {format = "rgba32f"})
+   g_color_canvas = love.graphics.newCanvas(1024, 1024, {format = "rgba32f"})
+
+   g_shadow_canvas = love.graphics.newCanvas(2048, 2048, {format = "r32f"})
+
+   load_screen_shader()
 end
 
 local rotation = 0.0
@@ -35,24 +92,39 @@ function love.draw()
    width, height = love.graphics.getDimensions()
 
    local aspect_ratio = width / height
-   local projection = mat4.perspective_fov_rh(scalar.convert_to_radians(45),
-                                              aspect_ratio,
-                                              0.1,
-                                              1000.0)
+   local perspective_projection = mat4.perspective_fov_rh(scalar.convert_to_radians(45 * 0.5),
+                                                          aspect_ratio,
+                                                          0.1,
+                                                          10000.0)
 
-   local view = mat4.look_at_rh(vec3(-54.43401, -35.53392, 57.3912),
-                                vec3(0.0, 0.0, 13.41141),
-                                vec3(0, 0, 1))
+   local orthographic_projection = mat4.orthographic_rh(300, 300, 200, 400.0)
 
-   local world1 = mat4.rotation_x(rotation)
+   local world1 = mat4.rotation_z(rotation)
    local world2 = mat4.rotation_z(rotation * 0.5)
    --local world3 = mat4.translation(0, 0, -0.5)
-
-   local transform = view * projection
+   rotation = rotation + 0.01
 
    collada_scene_animate.update(t, node_state)
-   t = t + 0.016
+   t = t + 0.016 * 0.1
 
+   love.graphics.setBlendMode("replace", "premultiplied")
    love.graphics.setDepthMode("less", true)
-   collada_scene.draw_nodes(node_state, transform)
+   collada_scene.draw_scene(node_state, perspective_projection, orthographic_projection)
+
+   -- love.graphics.setCanvas({
+   --       g_color_canvas,
+   --       g_position_canvas,
+   --       g_normal_canvas,
+   --       depth = true
+   -- })
+   -- love.graphics.clear(
+   --    {0.0, 0.0, 0.0, 1.0},
+   --    {0.0, 0.0, 0.0, 1.0},
+   --    {0.0, 0.0, 0.0, 1.0})
+   -- collada_scene.draw_nodes(node_state, transform)
+
+   -- love.graphics.setCanvas()
+   -- love.graphics.setShader(screen_shader)
+   -- screen_shader:send("g_sampler", g_shadow_canvas)
+   -- love.graphics.drawFromShader(screen_index_buffer, 3 * 2, 1, 1)
 end

pixel_color.glsl

@@ -3,6 +3,7 @@
 varying vec4 PixelNormal;
 varying vec4 PixelTexture;
 varying vec4 PixelWorldPosition;
+varying vec4 PixelLightPosition;
 
 uniform vec4 emission_color;
 uniform vec4 ambient_color;
@@ -15,11 +16,27 @@ uniform sampler2D ambient_sampler;
 uniform sampler2D diffuse_sampler;
 uniform sampler2D specular_sampler;
 
+uniform sampler2D shadow_sampler;
+
 uniform vec4 view_position;
 uniform vec4 light_position;
 uniform ivec4 texture_channel;
 
-out vec4 out_color;
+layout (location = 0) out vec4 g_color;
+layout (location = 1) out vec4 g_position;
+layout (location = 2) out vec4 g_normal;
+
+float Shadow(vec3 normal, vec3 light_direction)
+{
+  vec3 projected = PixelLightPosition.xyz / PixelLightPosition.w;
+  projected = projected * vec3(0.5, -0.5, 0.5) + 0.5;
+  float shadow_depth = texture(shadow_sampler, projected.xy).x;
+  float fragment_depth = projected.z;
+
+  float bias = max(0.05 * (1.0 - dot(normal, light_direction)), 0.005);
+  return fragment_depth - bias > shadow_depth ? 0.3 : 1.0;
+  //return shadow_depth;
+}
 
 void pixelmain()
 {
@@ -57,9 +74,15 @@ void pixelmain()
   float specular_intensity = pow(max(dot(view_direction, reflect_light_direction), 0.0), shininess);
 
   vec3 color = emission.xyz * 0;
-  color += ambient.xyz * 0;
+  color += ambient.xyz * 0.05;
   color += diffuse.xyz * diffuse_intensity;
   color += specular.xyz * specular_intensity * 0.3;
 
-  out_color = vec4(color, 1.0);
+  color *= Shadow(normal, light_direction);
+
+  g_color = vec4(color, 1.0);
+  //float s = Shadow();
+  //g_color = vec4(s, s, s, 1.0);
+  g_position = vec4(PixelWorldPosition.xyz, 1.0);
+  g_normal = vec4(normal, 0.0);
 }

pixel_screen.glsl

@@ -0,0 +1,12 @@
+#pragma language glsl3
+
+uniform sampler2D g_sampler;
+
+out vec4 out_color;
+
+void pixelmain()
+{
+  vec4 color = texelFetch(g_sampler, ivec2(gl_FragCoord), 0);
+
+  out_color = vec4(color.xyz, 1.0);
+}

pixel_shadow.glsl

@@ -0,0 +1,8 @@
+#pragma language glsl3
+
+layout (location = 0) out float g_out;
+
+void pixelmain()
+{
+  g_out = gl_FragCoord.z;
+}

pixel_sobel.glsl

@@ -0,0 +1,60 @@
+#pragma language glsl3
+
+uniform sampler2D g_position_sampler;
+uniform sampler2D g_normal_sampler;
+uniform sampler2D g_color_sampler;
+
+varying vec4 PixelTexture;
+
+out vec4 out_color;
+
+mat3 sobel_x = mat3( 1.0,  2.0,  1.0,
+                     0.0,  0.0,  0.0,
+                    -1.0, -2.0, -1.0);
+mat3 sobel_y = mat3(1.0, 0.0, -1.0,
+                    2.0, 0.0, -2.0,
+                    1.0, 0.0, -1.0);
+
+float sobel(mat3 K)
+{
+
+  float sx = dot(sobel_x[0], K[0]) + dot(sobel_x[1], K[1]) + dot(sobel_x[2], K[2]);
+  float sy = dot(sobel_y[0], K[0]) + dot(sobel_y[1], K[1]) + dot(sobel_y[2], K[2]);
+  float edge = sqrt(pow(sx, 2.0) + pow(sy, 2.0));
+  //float edge = max(sx, sy);
+  return edge;
+}
+
+float kernel()
+{
+  mat3 K;
+  mat3 Kz;
+  //mat3 Kx;
+  //mat3 Ky;
+  //mat3 Kz;
+  for (int x = 0; x < 3; x++) {
+    for (int y = 0; y < 3; y++) {
+      vec4 sample = texelFetch(g_normal_sampler, ivec2(gl_FragCoord) + ivec2(x-1, y-1), 0);
+      //Kx[x][y] = sample.x;
+      //Ky[x][y] = sample.y;
+      //Kz[x][y] = sample.z;
+      K[x][y] = length(sample.xyz);
+    }
+  }
+
+  //return max(sobel(Kx), max(sobel(Ky), sobel(Kz)));
+  return float(sobel(K) < 0.1);
+}
+
+void pixelmain()
+{
+  vec4 color = texelFetch(g_color_sampler, ivec2(gl_FragCoord), 0);
+
+  if (color.xyz == vec3(0, 0, 0)) {
+    out_color = vec4(0.1, 0.1, 0.2, 1.0);
+  } else {
+    float edge = kernel();
+    out_color = vec4(edge * color.xyz, 1.0);
+    //out_color = vec4(edge, edge, edge, 1.0);
+  }
+}

scene/sci_fi_ship/sci_fi_ship.rc

@@ -0,0 +1,4 @@
+RES_SCENES_SCI_FI_SHIP_VTX RCDATA "sci_fi_ship.vtx"
+RES_SCENES_SCI_FI_SHIP_VJW RCDATA "sci_fi_ship.vjw"
+RES_SCENES_SCI_FI_SHIP_IDX RCDATA "sci_fi_ship.idx"
+

scene/shadow_test/shadow_test.rc

@@ -0,0 +1,4 @@
+RES_SCENES_SHADOW_TEST_VTX RCDATA "shadow_test.vtx"
+RES_SCENES_SHADOW_TEST_VJW RCDATA "shadow_test.vjw"
+RES_SCENES_SHADOW_TEST_IDX RCDATA "shadow_test.idx"
+

vertex.glsl

@@ -1,33 +0,0 @@
-#pragma language glsl4
-
-struct vertex_t {
-  vec4 Position;
-  vec4 Normal;
-  vec4 Texture;
-};
-
-layout (std430) readonly buffer VertexLayout
-{
-  vertex_t VertexBuffer[];
-};
-
-uniform int VertexOffset;
-
-uniform mat4 world_transform;
-uniform mat4 transform;
-
-varying vec4 PixelNormal;
-varying vec4 PixelTexture;
-varying vec4 PixelWorldPosition;
-
-void vertexmain()
-{
-  vertex_t Vertex = VertexBuffer[VertexOffset + gl_VertexID];
-
-  PixelNormal = world_transform * vec4(Vertex.Normal.xyz, 0);
-  PixelTexture = Vertex.Texture;
-
-  PixelWorldPosition = world_transform * vec4(Vertex.Position.xyz, 1);
-
-  love_Position = transform * vec4(Vertex.Position.xyz, 1);
-}

vertex_screen.glsl

@@ -0,0 +1,17 @@
+#pragma language glsl3
+
+const vec4 vtx[4] = vec4[](vec4(-1.0,  1.0, 0.0, 1.0),  // tl
+                           vec4( 1.0,  1.0, 0.0, 1.0),  // tr
+                           vec4( 1.0, -1.0, 0.0, 1.0),  // br
+                           vec4(-1.0, -1.0, 0.0, 1.0)); // bl
+
+varying vec4 PixelTexture;
+
+void vertexmain()
+{
+  vec4 vertex = vtx[gl_VertexID];
+
+  PixelTexture = vec4(vertex.xy * vec2(0.5, -0.5) + 0.5, 0, 0);
+
+  love_Position = vertex;
+}

vertex_skinned.glsl

@@ -26,12 +26,14 @@ uniform int VertexJWOffset;
 
 uniform mat4 Joints[3];
 
+uniform mat4 light_transform;
 uniform mat4 world_transform;
 uniform mat4 transform;
 
 varying vec4 PixelNormal;
 varying vec4 PixelTexture;
 varying vec4 PixelWorldPosition;
+varying vec4 PixelLightPosition;
 
 void vertexmain()
 {
@@ -49,7 +51,8 @@ void vertexmain()
   PixelTexture = VertexPNT.Texture;
 
   vec4 Position = mSkin * vec4(VertexPNT.Position.xyz, 1);
-  //vec4 Position = Joints * vec4(VertexPNT.Position.xyz, 1);
+
   PixelWorldPosition = world_transform * Position;
+  PixelLightPosition = light_transform * Position;
   love_Position = transform * Position;
 }

vertex_sobel.glsl

@@ -0,0 +1,17 @@
+#pragma language glsl3
+
+const vec4 vtx[4] = vec4[](vec4(-1.0,  1.0, 0.0, 1.0),  // tl
+                           vec4( 1.0,  1.0, 0.0, 1.0),  // tr
+                           vec4( 1.0, -1.0, 0.0, 1.0),  // br
+                           vec4(-1.0, -1.0, 0.0, 1.0)); // bl
+
+varying vec4 PixelTexture;
+
+void vertexmain()
+{
+  vec4 vertex = vtx[gl_VertexID];
+
+  PixelTexture = vec4(vertex.xy * vec2(0.5, -0.5) + 0.5, 0, 0);
+
+  love_Position = vertex;
+}

vertex_static.glsl

@@ -0,0 +1,37 @@
+#pragma language glsl4
+
+struct vertex_t {
+  vec4 Position;
+  vec4 Normal;
+  vec4 Texture;
+};
+
+layout (std430) readonly buffer VertexPNTLayout
+{
+  vertex_t VertexPNTBuffer[];
+};
+
+uniform int VertexPNTOffset;
+
+uniform mat4 world_transform;
+uniform mat4 light_transform;
+uniform mat4 transform;
+
+varying vec4 PixelNormal;
+varying vec4 PixelTexture;
+varying vec4 PixelWorldPosition;
+varying vec4 PixelLightPosition;
+
+void vertexmain()
+{
+  vertex_t VertexPNT = VertexPNTBuffer[VertexPNTOffset + gl_VertexID];
+
+  PixelNormal = world_transform * vec4(VertexPNT.Normal.xyz, 0);
+  PixelTexture = VertexPNT.Texture;
+
+  vec4 Position = vec4(VertexPNT.Position.xyz, 1);
+
+  PixelWorldPosition = world_transform * Position;
+  PixelLightPosition = light_transform * Position;
+  love_Position = transform * Position;
+}