collada_scene: draw sci_fi_ship

collada_scene.lua

@@ -7,9 +7,12 @@ 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_static_data = love.filesystem.newFileData("vertex_static.glsl")
-local vertex_data = love.filesystem.newFileData("skinned_vertex.glsl")
+local vertex_skinned_data = love.filesystem.newFileData("vertex_skinned.glsl")
-local shader = love.graphics.newShader(pixel_data, vertex_data)
+local shader_static = love.graphics.newShader(pixel_data, vertex_static_data)
+local shader_skinned = love.graphics.newShader(pixel_data, vertex_skinned_data)
+
+local current_shader
 
 local images_textures = {}
 local node_instances = {}
@@ -19,12 +22,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 +39,21 @@ 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")
+      shader_static:send("VertexPNTLayout", vtx_shaderstorage_buffer)
-      local vjw_shaderstorage_buffer = love.graphics.newBuffer(vjw_format, vjw_data, { shaderstorage = true, usage = "static" })
+      shader_skinned:send("VertexPNTLayout", vtx_shaderstorage_buffer)
 
-      shader:send("VertexPNTLayout", vtx_shaderstorage_buffer)
+      local vjw_data = love.filesystem.newFileData(vjw_path)
-      shader:send("VertexJWLayout", vjw_shaderstorage_buffer)
+      if vjw_data:getSize() ~= 0 then
+         local vjw_shaderstorage_buffer = love.graphics.newBuffer(vjw_format, vjw_data, { shaderstorage = true, usage = "static" })
+         shader_skinned:send("VertexJWLayout", vjw_shaderstorage_buffer)
+      end
    end,
 
    load_images = function(base_path, images)
@@ -65,9 +71,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 +87,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 +97,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 +110,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)
@@ -119,7 +125,7 @@ collada_scene = {
          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 +148,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 +174,17 @@ collada_scene = {
          --joints[1].data,
          --joints[2].data,
          --joints[3].data)
-         shader:send("Joints", "column",
+         current_shader:send("Joints", "column",
-                     mat4.store_table(joints[1]),
+                             mat4.store_table(joints[1]),
-                     mat4.store_table(joints[2]),
+                             mat4.store_table(joints[2]),
-                     mat4.store_table(joints[3]))
+                             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(view_position, light_position, node_state, node, node_instance, transform)
       if node.type ~= collada_types.node_type.NODE then
          return
       end
@@ -189,22 +195,38 @@ collada_scene = {
 
       local world = node_instance.world
       transform = world * transform
-      shader:send("world_transform", "column", world.data)
-      shader:send("transform", "column", transform.data)
 
-      collada_scene.draw_instance_geometries(node.instance_geometries)
+      if node.instance_geometries_count > 0 then
-      collada_scene.draw_instance_controllers(node_state, node.instance_controllers)
+         current_shader = shader_static
+         love.graphics.setShader(current_shader)
+         current_shader:send("view_position", view_position)
+         current_shader:send("light_position", light_position)
+
+         current_shader:send("world_transform", "column", world.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 = shader_skinned
+         love.graphics.setShader(current_shader)
+         current_shader:send("view_position", view_position)
+         current_shader:send("light_position", light_position)
+
+         current_shader:send("world_transform", "column", world.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)
+      local view_position = {-630.43401, -528.53392, 474.3912, 1.0}
-      shader:send("view_position", {-88.57101, -71.71298, 104.5738, 1.0})
+      local light_position = {-403.649, -165.804, 317.237, 1.0}
-      shader:send("light_position", {-26.649, -56.804, 58.237, 1.0})
 
       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(view_position, light_position, node_state, node, node_instance, transform)
          node_index = node_index + 1
       end
    end,

main.lua

@@ -13,16 +13,21 @@ 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 node_state
 
 function love.load(args)
    love.window.setMode(1024, 1024, {depth=true})
 
-   collada_scene.load_buffers()
+   local scene = scene_sci_fi_ship
-   collada_scene.load_images("scene/noodle", scene_noodle.descriptor.images)
 
-   node_state = collada_scene_node_state(scene_noodle.descriptor.nodes)
+   local idx_path = "scene/sci_fi_ship/sci_fi_ship.idx"
+   local vtx_path = "scene/sci_fi_ship/sci_fi_ship.vtx"
+   local vjw_path = "scene/sci_fi_ship/sci_fi_ship.vjw"
+   collada_scene.load_buffers(idx_path, vtx_path, vjw_path)
+   collada_scene.load_images("scene/sci_fi_ship", scene.descriptor.images)
+   node_state = collada_scene_node_state(scene.descriptor.nodes)
 end
 
 local rotation = 0.0
@@ -35,12 +40,12 @@ function love.draw()
    width, height = love.graphics.getDimensions()
 
    local aspect_ratio = width / height
-   local projection = mat4.perspective_fov_rh(scalar.convert_to_radians(45),
+   local projection = mat4.perspective_fov_rh(scalar.convert_to_radians(45 * 0.5),
                                               aspect_ratio,
                                               0.1,
-                                              1000.0)
+                                              10000.0)
 
-   local view = mat4.look_at_rh(vec3(-54.43401, -35.53392, 57.3912),
+   local view = mat4.look_at_rh(vec3(-630.43401, -528.53392, 474.3912),
                                 vec3(0.0, 0.0, 13.41141),
                                 vec3(0, 0, 1))
 

pixel.glsl

@@ -57,7 +57,7 @@ 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;
 

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"
+

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_static.glsl

@@ -0,0 +1,33 @@
+#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 transform;
+
+varying vec4 PixelNormal;
+varying vec4 PixelTexture;
+varying vec4 PixelWorldPosition;
+
+void vertexmain()
+{
+  vertex_t VertexPNT = VertexPNTBuffer[VertexPNTOffset + gl_VertexID];
+
+  PixelNormal = world_transform * vec4(VertexPNT.Normal.xyz, 0);
+  PixelTexture = VertexPNT.Texture;
+
+  PixelWorldPosition = world_transform * vec4(VertexPNT.Position.xyz, 1);
+
+  love_Position = transform * vec4(VertexPNT.Position.xyz, 1);
+}