Makefile

@@ -50,10 +50,11 @@ SHADERS = \
 	$(BUILD_TYPE)/effect/collada.fxo \
 	$(BUILD_TYPE)/effect/collada_scene.fxo
 
-SCENES = \
+BUFFERS = \
-	src/scenes/curve_interpolation/curve_interpolation.cpp
+	models/curve_interpolation/curve_interpolation.vtx \
+	models/curve_interpolation/curve_interpolation.idx
 
-$(BUILD_TYPE)/%.res: %.rc $(SHADERS) $(SCENES)
+$(BUILD_TYPE)/%.res: %.rc $(SHADERS) $(BUFFERS)
 	@mkdir -p $(@D)
 	$(WINDRES) -O coff -I$(BUILD_TYPE)/effect -o $@ $<
 
@@ -61,17 +62,6 @@ $(BUILD_TYPE)/%.obj: src/%.cpp
 	@mkdir -p $(@D)
 	$(CXX) $(CXXSTD) $(CFLAGS) $(CXXFLAGS) $(WOPT) $(OPT) -o $@ -c $<
 
-COLLADA_PY_SOURCE = \
-	$(wildcard collada/*.py)
-
-include/scenes/%.hpp: $(COLLADA_PY_SOURCE)
-	@mkdir -p $(@D)
-	PYTHONPATH=. python -m collada.main $@
-
-src/scenes/%.cpp: scenes/%.DAE include/scenes/%.hpp
-	@mkdir -p $(@D)
-	PYTHONPATH=. python -m collada.main $< $@ $(<:.DAE=.vtx) $(<:.DAE=.idx)
-
 OBJS = \
 	$(BUILD_TYPE)/main.res \
 	$(BUILD_TYPE)/robot_player.obj \
@@ -82,7 +72,7 @@ OBJS = \
 	$(BUILD_TYPE)/input.obj \
 	$(BUILD_TYPE)/collada.obj \
 	$(BUILD_TYPE)/collada_scene.obj \
-	$(BUILD_TYPE)/scenes/curve_interpolation/curve_interpolation.obj
+	$(BUILD_TYPE)/scenes/curve_interpolation.obj
 
 $(BUILD_TYPE)/d3d10.exe: $(OBJS)
 	@mkdir -p $(@D)

collada/header.py

@@ -310,23 +310,12 @@ def render_node_channels(state, collada, node, node_name):
         yield f"&node_channel_{target_name},"
     yield "};"
 
-def render_node_instance_lights(state, collada, node_name, instance_lights):
-    yield f"instance_light const instance_lights_{node_name}[] = {{"
-    for instance_light in instance_lights:
-        light = collada.lookup(instance_light.url, types.Light)
-        light_name = sanitize_name(state, light.id, light)
-        yield "{"
-        yield f".light = &light_{light_name},"
-        yield "}"
-    yield "};"
-
 def render_node(state, collada, node, node_index):
     node_name_id = get_node_name_id(node)
     node_name = sanitize_name(state, node_name_id, node)
     #yield from render_node_children(state, collada, node_name, node.nodes)
     yield from render_node_transforms(state, collada, node_name, node.transformation_elements)
     yield from render_node_instance_geometries(state, collada, node_name, node.instance_geometries)
-    yield from render_node_instance_lights(state, collada, node_name, node.instance_lights)
     yield from render_node_channels(state, collada, node, node_name)
 
     type = {
@@ -345,9 +334,6 @@ def render_node(state, collada, node, node_index):
     yield f".instance_geometries = instance_geometries_{node_name},"
     yield f".instance_geometries_count = {len(node.instance_geometries)},"
     yield ""
-    yield f".instance_lights = instance_lights_{node_name},"
-    yield f".instance_lights_count = {len(node.instance_lights)},"
-    yield ""
     yield f".channels = node_channels_{node_name},"
     yield f".channels_count = {len(state.node_animation_channels[node.id])},"
     #yield ""
@@ -406,72 +392,69 @@ def render_opt_float(field_name, f):
         f = types.Float(value=0.0)
     yield f".{field_name} = {float(f.value)}f,"
 
-def render_effect(state, collada, effect):
-    profile_common, = effect.profile_common
-    assert profile_common.newparam == []
-    shader = profile_common.technique.shader
-    effect_name = sanitize_name(state, effect.id, effect)
-    yield f"effect const effect_{effect_name} = {{"
-
-    if type(shader) is types.Blinn:
-        yield ".type = effect_type::BLINN,"
-        yield ".blinn = {"
-        yield from render_opt_color_or_texture("emission", shader.emission)
-        yield from render_opt_color_or_texture("ambient", shader.ambient)
-        yield from render_opt_color_or_texture("diffuse", shader.diffuse)
-        yield from render_opt_color_or_texture("specular", shader.specular)
-        yield from render_opt_float("shininess", shader.shininess)
-        yield from render_opt_color_or_texture("reflective", shader.reflective)
-        yield from render_opt_float("reflectivity", shader.reflectivity)
-        yield from render_opt_color_or_texture("transparent", shader.transparent)
-        yield from render_opt_float("transparency", shader.transparency)
-        yield from render_opt_float("index_of_refraction", shader.index_of_refraction)
-        yield "}"
-    elif type(shader) is types.Lambert:
-        yield ".type = effect_type::LAMBERT,"
-        yield ".lambert = {"
-        yield from render_opt_color_or_texture("emission", shader.emission)
-        yield from render_opt_color_or_texture("ambient", shader.ambient)
-        yield from render_opt_color_or_texture("diffuse", shader.diffuse)
-        yield from render_opt_color_or_texture("reflective", shader.reflective)
-        yield from render_opt_float("reflectivity", shader.reflectivity)
-        yield from render_opt_color_or_texture("transparent", shader.transparent)
-        yield from render_opt_float("transparency", shader.transparency)
-        yield from render_opt_float("index_of_refraction", shader.index_of_refraction)
-        yield "}"
-    elif type(shader) is types.Phong:
-        yield ".type = effect_type::PHONG,"
-        yield ".phong = {"
-        yield from render_opt_color_or_texture("emission", shader.emission)
-        yield from render_opt_color_or_texture("ambient", shader.ambient)
-        yield from render_opt_color_or_texture("diffuse", shader.diffuse)
-        yield from render_opt_color_or_texture("specular", shader.specular)
-        yield from render_opt_float("shininess", shader.shininess)
-        yield from render_opt_color_or_texture("reflective", shader.reflective)
-        yield from render_opt_float("reflectivity", shader.reflectivity)
-        yield from render_opt_color_or_texture("transparent", shader.transparent)
-        yield from render_opt_float("transparency", shader.transparency)
-        yield from render_opt_float("index_of_refraction", shader.index_of_refraction)
-        yield "}"
-    elif type(shader) is types.Constant:
-        yield ".type = effect_type::CONSTANT,"
-        yield ".constant = {"
-        yield from render_opt_color("color", shader.color)
-        yield from render_opt_color_or_texture("reflective", shader.reflective)
-        yield from render_opt_float("reflectivity", shader.reflectivity)
-        yield from render_opt_color_or_texture("transparent", shader.transparent)
-        yield from render_opt_float("transparency", shader.transparency)
-        yield from render_opt_float("index_of_refraction", shader.index_of_refraction)
-        yield "}"
-    else:
-        assert False, type(shader)
-
-    yield "};"
-
 def render_library_effects(state, collada):
     for library_effects in collada.library_effects:
         for effect in library_effects.effects:
-            yield from render_effect(state, collada, effect)
+            profile_common, = effect.profile_common
+            assert profile_common.newparam == []
+            shader = profile_common.technique.shader
+            effect_name = sanitize_name(state, effect.id, effect)
+            yield f"effect const effect_{effect_name} = {{"
+
+            if type(shader) is types.Blinn:
+                yield ".type = effect_type::BLINN,"
+                yield ".blinn = {"
+                yield from render_opt_color_or_texture("emission", shader.emission)
+                yield from render_opt_color_or_texture("ambient", shader.ambient)
+                yield from render_opt_color_or_texture("diffuse", shader.diffuse)
+                yield from render_opt_color_or_texture("specular", shader.specular)
+                yield from render_opt_float("shininess", shader.shininess)
+                yield from render_opt_color_or_texture("reflective", shader.reflective)
+                yield from render_opt_float("reflectivity", shader.reflectivity)
+                yield from render_opt_color_or_texture("transparent", shader.transparent)
+                yield from render_opt_float("transparency", shader.transparency)
+                yield from render_opt_float("index_of_refraction", shader.index_of_refraction)
+                yield "}"
+            elif type(shader) is types.Lambert:
+                yield ".type = effect_type::LAMBERT,"
+                yield ".lambert = {"
+                yield from render_opt_color_or_texture("emission", shader.emission)
+                yield from render_opt_color_or_texture("ambient", shader.ambient)
+                yield from render_opt_color_or_texture("diffuse", shader.diffuse)
+                yield from render_opt_color_or_texture("reflective", shader.reflective)
+                yield from render_opt_float("reflectivity", shader.reflectivity)
+                yield from render_opt_color_or_texture("transparent", shader.transparent)
+                yield from render_opt_float("transparency", shader.transparency)
+                yield from render_opt_float("index_of_refraction", shader.index_of_refraction)
+                yield "}"
+            elif type(shader) is types.Phong:
+                yield ".type = effect_type::PHONG,"
+                yield ".phong = {"
+                yield from render_opt_color_or_texture("emission", shader.emission)
+                yield from render_opt_color_or_texture("ambient", shader.ambient)
+                yield from render_opt_color_or_texture("diffuse", shader.diffuse)
+                yield from render_opt_color_or_texture("specular", shader.specular)
+                yield from render_opt_float("shininess", shader.shininess)
+                yield from render_opt_color_or_texture("reflective", shader.reflective)
+                yield from render_opt_float("reflectivity", shader.reflectivity)
+                yield from render_opt_color_or_texture("transparent", shader.transparent)
+                yield from render_opt_float("transparency", shader.transparency)
+                yield from render_opt_float("index_of_refraction", shader.index_of_refraction)
+                yield "}"
+            elif type(shader) is types.Constant:
+                yield ".type = effect_type::CONSTANT,"
+                yield ".constant = {"
+                yield from render_opt_color("color", shader.color)
+                yield from render_opt_color_or_texture("reflective", shader.reflective)
+                yield from render_opt_float("reflectivity", shader.reflectivity)
+                yield from render_opt_color_or_texture("transparent", shader.transparent)
+                yield from render_opt_float("transparency", shader.transparency)
+                yield from render_opt_float("index_of_refraction", shader.index_of_refraction)
+                yield "}"
+            else:
+                assert False, type(shader)
+
+            yield "};"
 
 def render_library_materials(state, collada):
     for library_materials in collada.library_materials:
@@ -672,34 +655,10 @@ def render_library_animations(state, collada):
             yield from render_animation(state, collada, animation_name, animation)
             animation_ix += 1
 
-def render_light_type(technique_common: types.TechniqueCommon_Light):
-    return {
-        types.Ambient: "AMBIENT",
-        types.Directional: "DIRECTIONAL",
-        types.Point: "POINT",
-        types.Spot: "SPOT",
-    }[type(technique_common.light)]
-
-def render_light(state, collada, light):
-    technique_common = light.technique_common
-    light_name = sanitize_name(state, light.id, light)
-    color = ", ".join(f"{float(f)}f" for f in technique_common.light.color)
-    light_type = render_light_type(technique_common)
-    yield f"light const light_{light_name} = {{"
-    yield f".type = light_type::{light_type},"
-    yield f".color = {{ {color} }},"
-    yield "};"
-
-def render_library_lights(state, collada):
-    for library_lights in collada.library_lights:
-        for light in library_lights.lights:
-            yield from render_light(state, collada, light)
-
 def render_all(collada, namespace):
     state = State()
     render, out = renderer()
     render(render_header(namespace))
-    render(render_library_lights(state, collada))
     render(render_library_animations(state, collada))
     render(render_library_effects(state, collada))
     render(render_library_materials(state, collada))

collada/main.py

@@ -6,61 +6,44 @@ from collada import header
 
 def usage():
     name = sys.argv[0]
-    print("usage (source):")
+    print("usage:")
-    print(f"  {name} [input_collada.dae] [output_source.cpp] [output_vertex.vtx] [output_vertex.idx]")
+    print(f"  {name} [input_collada.dae] [output_source.cpp] [output_header.hpp] [output_vertex.vtx] [output_vertex.idx]")
-    print("usage (header):")
-    print(f"  {name} [output_header.hpp]")
     sys.exit(1)
 
-def parse_namespace(filename):
-    namespace = path.splitext(path.split(filename)[1])[0]
-    return namespace
-
 def main():
     try:
         input_collada = sys.argv[1]
         output_source = sys.argv[2]
-        output_vertex = sys.argv[3]
+        output_header = sys.argv[3]
-        output_index  = sys.argv[4]
+        output_vertex = sys.argv[4]
+        output_index  = sys.argv[5]
         assert input_collada.lower().endswith(".dae")
-        assert output_source.lower().endswith(".cpp")
+        assert output_header.lower().endswith(".hpp")
         assert output_vertex.lower().endswith(".vtx")
         assert output_index.lower().endswith(".idx")
     except Exception as e:
         usage()
 
     collada = parse.parse_collada_file(input_collada)
-    namespace = parse_namespace(input_collada)
+    namespace = path.splitext(path.split(input_collada)[1])[0]
     state, out_source = header.render_all(collada, namespace)
+    out_header = header.render_all_hpp(namespace)
 
     with open(output_source, 'wb') as f:
         source_buf = out_source.getvalue()
         assert "\r\n" in source_buf
         f.write(source_buf.encode('utf-8'))
 
+    with open(output_header, 'wb') as f:
+        header_buf = out_header.getvalue()
+        assert "\r\n" in header_buf
+        f.write(header_buf.encode('utf-8'))
+
     with open(output_vertex, 'wb') as f:
         f.write(state.vertex_buffer.getvalue())
 
     with open(output_index, 'wb') as f:
         f.write(state.index_buffer.getvalue())
 
-def main_header():
-    try:
-        output_header = sys.argv[1]
-        assert output_header.lower().endswith(".hpp")
-    except Exception as e:
-        usage()
-
-    namespace = parse_namespace(output_header)
-    out_header = header.render_all_hpp(namespace)
-
-    with open(output_header, 'wb') as f:
-        header_buf = out_header.getvalue()
-        assert "\r\n" in header_buf
-        f.write(header_buf.encode('utf-8'))
-
 if __name__ == "__main__":
-    if len(sys.argv) == 2:
+    main()
-        main_header()
-    else:
-        main()

include/collada_scene.hpp

@@ -37,33 +37,20 @@ namespace collada_scene {
 
     node_instance * m_nodeInstances = NULL;
 
-    XMFLOAT4 * m_lightPositions = NULL;
-    XMFLOAT4 * m_lightDirections = NULL;
-    XMFLOAT4 * m_lightColors = NULL;
-
-    int m_lightInstancesCount = 0;
-
     collada::descriptor const * m_descriptor;
 
     HRESULT load_scene(collada::descriptor const * const descriptor);
-    void update(float t);
+    void render(float t);
-    void render();
 
   private:
     HRESULT load_layouts();
     void allocate_node_instances();
     void allocate_node_instance(collada::node const * const node,
                                 node_instance * node_instance);
-    void allocate_light_instances();
-
-    void node_world_transform(collada::node const& node, node_instance& node_instance);
-    void update_light_instances();
-    void update_light_instance_vectors(collada::light const& light,
-                                       node_instance const& node_instance,
-                                       int light_index);
 
     void render_geometries(collada::instance_geometry const * const instance_geometries,
                            int const instance_geometries_count);
+    void node_world_transform(collada::node const& node, node_instance& node_instance);
   };
 
   HRESULT LoadEffect();

include/collada_types.hpp

@@ -81,24 +81,47 @@ namespace collada {
   };
 
   //////////////////////////////////////////////////////////////////////
-  // light
+  // node
   //////////////////////////////////////////////////////////////////////
 
-  enum class light_type {
+  struct lookat {
-    AMBIENT,
+    float3 const eye;
-    DIRECTIONAL,
+    float3 const at;
-    POINT,
+    float3 const up;
-    SPOT,
   };
 
-  struct light {
+  struct matrix {
-    light_type type;
+    float const _11, _12, _13, _14;
-    float3 color;
+    float const _21, _22, _23, _24;
+    float const _31, _32, _33, _34;
+    float const _41, _42, _43, _44;
   };
 
-  //////////////////////////////////////////////////////////////////////
+  enum class transform_type {
-  // effect
+    LOOKAT,
-  //////////////////////////////////////////////////////////////////////
+    MATRIX,
+    ROTATE,
+    SCALE,
+    SKEW,
+    TRANSLATE,
+  };
+
+  struct transform {
+    transform_type const type;
+    union {
+      lookat const lookat;
+      matrix const matrix;
+      float4 const rotate;
+      float3 const scale;
+      float7 const skew;
+      float3 const translate;
+    };
+  };
+
+  enum class node_type {
+    JOINT,
+    NODE,
+  };
 
   struct color_or_texture {
     union {
@@ -169,55 +192,12 @@ namespace collada {
     };
   };
 
-  //////////////////////////////////////////////////////////////////////
-  // node
-  //////////////////////////////////////////////////////////////////////
-
-  struct lookat {
-    float3 const eye;
-    float3 const at;
-    float3 const up;
-  };
-
-  struct matrix {
-    float const _11, _12, _13, _14;
-    float const _21, _22, _23, _24;
-    float const _31, _32, _33, _34;
-    float const _41, _42, _43, _44;
-  };
-
-  enum class transform_type {
-    LOOKAT,
-    MATRIX,
-    ROTATE,
-    SCALE,
-    SKEW,
-    TRANSLATE,
-  };
-
-  struct transform {
-    transform_type const type;
-    union {
-      lookat const lookat;
-      matrix const matrix;
-      float4 const rotate;
-      float3 const scale;
-      float7 const skew;
-      float3 const translate;
-    };
-  };
-
-  enum class node_type {
-    JOINT,
-    NODE,
-  };
-
   struct material {
     effect const * const effect;
   };
 
   struct instance_material {
-    int element_index; // an index into mesh.triangles
+    int element_index;
     material const * const material;
   };
 
@@ -228,10 +208,6 @@ namespace collada {
     int const instance_materials_count;
   };
 
-  struct instance_light {
-    light const * const light;
-  };
-
   //////////////////////////////////////////////////////////////////////
   // animation
   //////////////////////////////////////////////////////////////////////
@@ -310,9 +286,6 @@ namespace collada {
     instance_geometry const * const instance_geometries;
     int const instance_geometries_count;
 
-    instance_light const * const instance_lights;
-    int const instance_lights_count;
-
     channel const * const * const channels;
     int const channels_count;
 

main.rc

@@ -10,5 +10,5 @@ RES_FONT_TERMINUS_6X12 RCDATA "font/terminus_128x64_6x12.data"
 RES_COLLADA_FXO RCDATA "collada.fxo"
 
 RES_COLLADA_SCENE_FXO RCDATA "collada_scene.fxo"
-RES_MODELS_CURVE_INTERPOLATION_VTX RCDATA "scenes/curve_interpolation/curve_interpolation.vtx"
+RES_MODELS_CURVE_INTERPOLATION_VTX RCDATA "models/curve_interpolation/curve_interpolation.vtx"
-RES_MODELS_CURVE_INTERPOLATION_IDX RCDATA "scenes/curve_interpolation/curve_interpolation.idx"
+RES_MODELS_CURVE_INTERPOLATION_IDX RCDATA "models/curve_interpolation/curve_interpolation.idx"

src/collada_scene.cpp

@@ -9,7 +9,6 @@
 #include "new.hpp"
 
 extern ID3D10Device * g_pd3dDevice;
-extern XMVECTOR g_Eye;
 extern XMMATRIX g_View;
 extern XMMATRIX g_Projection;
 
@@ -23,11 +22,6 @@ namespace collada_scene {
   ID3D10EffectMatrixVariable * g_pViewVariable = NULL;
   ID3D10EffectMatrixVariable * g_pProjectionVariable = NULL;
 
-  ID3D10EffectVectorVariable * g_pViewEyeVariable = NULL;
-  ID3D10EffectVectorVariable * g_pLightPosVariable = NULL;
-  ID3D10EffectVectorVariable * g_pLightDirVariable = NULL;
-  ID3D10EffectVectorVariable * g_pLightColorVariable = NULL;
-
   ID3D10EffectVectorVariable * g_pEmissionVariable = NULL;
   ID3D10EffectVectorVariable * g_pAmbientVariable = NULL;
   ID3D10EffectVectorVariable * g_pDiffuseVariable = NULL;
@@ -73,52 +67,8 @@ namespace collada_scene {
     return S_OK;
   }
 
-  void scene_state::update_light_instance_vectors(light const& light,
-                                                  node_instance const& node_instance,
-                                                  int light_index)
-  {
-    const XMVECTOR position = XMVectorSet(0, 0, 0, 1);
-    const XMVECTOR direction = XMVectorSet(0, 0, -1, 0);
-    XMVECTOR light_position = XMVector3Transform(position, node_instance.world);
-    XMVECTOR light_direction = XMVector3TransformNormal(direction, node_instance.world);
-    XMVECTOR light_color = XMLoadFloat3((XMFLOAT3 *)&light.color);
-
-    XMStoreFloat4(&m_lightPositions[light_index], light_position);
-    XMStoreFloat4(&m_lightDirections[light_index], light_direction);
-    XMStoreFloat4(&m_lightColors[light_index], light_color);
-  }
-
-  void scene_state::update_light_instances()
-  {
-    int light_index = 0;
-    for (int i = 0; i < m_descriptor->nodes_count; i++) {
-      node const& node = *m_descriptor->nodes[i];
-      node_instance const& node_instance = m_nodeInstances[i];
-      for (int j = 0; j < node.instance_lights_count; j++) {
-        light const& light = *node.instance_lights[j].light;
-        update_light_instance_vectors(light, node_instance, light_index);
-        light_index += 1;
-      }
-    }
-  }
-
-  void scene_state::allocate_light_instances()
-  {
-    // count light instances
-    int count = 0;
-    for (int i = 0; i < m_descriptor->nodes_count; i++) {
-      count += m_descriptor->nodes[i]->instance_lights_count;
-    }
-
-    // allocate
-    m_lightInstancesCount = count;
-    m_lightPositions = New<XMFLOAT4>(m_lightInstancesCount);
-    m_lightDirections = New<XMFLOAT4>(m_lightInstancesCount);
-    m_lightColors = New<XMFLOAT4>(m_lightInstancesCount);
-  }
-
   static void initialize_node_transforms(node const * const node,
-                                         node_instance * const node_instance)
+                                         node_instance * node_instance)
   {
     for (int i = 0; i < node->transforms_count; i++) {
       transform& transform = node_instance->transforms[i];
@@ -148,7 +98,7 @@ namespace collada_scene {
   }
 
   void scene_state::allocate_node_instance(node const * const node,
-                                           node_instance * const node_instance)
+                                           node_instance * node_instance)
   {
     node_instance->transforms = New<transform>(node->transforms_count);
     initialize_node_transforms(node, node_instance);
@@ -183,7 +133,6 @@ namespace collada_scene {
       return E_FAIL;
 
     allocate_node_instances();
-    allocate_light_instances();
 
     return S_OK;
   }
@@ -194,7 +143,6 @@ namespace collada_scene {
 
     D3D10_INPUT_ELEMENT_DESC layout[inputs.elements_count];
 
-    assert(inputs.elements_count == 3);
     int byte_offset = 0;
     for (int i = 0; i < inputs.elements_count; i++) {
       layout[i].SemanticName = inputs.elements[i].semantic;
@@ -252,11 +200,6 @@ namespace collada_scene {
     g_pViewVariable = g_pEffect->GetVariableByName("View")->AsMatrix();
     g_pProjectionVariable = g_pEffect->GetVariableByName("Projection")->AsMatrix();
 
-    g_pViewEyeVariable = g_pEffect->GetVariableByName("ViewEye")->AsVector();
-    g_pLightPosVariable = g_pEffect->GetVariableByName("LightPos")->AsVector();
-    g_pLightDirVariable = g_pEffect->GetVariableByName("LightDir")->AsVector();
-    g_pLightColorVariable = g_pEffect->GetVariableByName("LightColor")->AsVector();
-
     g_pEmissionVariable = g_pEffect->GetVariableByName("Emission")->AsVector();
     g_pAmbientVariable = g_pEffect->GetVariableByName("Ambient")->AsVector();
     g_pDiffuseVariable = g_pEffect->GetVariableByName("Diffuse")->AsVector();
@@ -616,59 +559,28 @@ namespace collada_scene {
     }
   }
 
-  void scene_state::update(float t)
+  void scene_state::render(float t)
   {
+    g_pViewVariable->SetMatrix((float *)&g_View);
+    g_pProjectionVariable->SetMatrix((float *)&g_Projection);
+
+    g_pd3dDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+
     t = loop(t / 2.0f, 3.333333f);
 
-    // animate and update all world transforms
     for (int i = 0; i < m_descriptor->nodes_count; i++) {
       node const& node = *m_descriptor->nodes[i];
       node_instance& node_instance = m_nodeInstances[i];
 
       animate_node(node, node_instance, t);
       node_world_transform(node, node_instance);
-    }
 
-    // update all lights (after world transforms are computed)
+      g_pWorldVariable->SetMatrix((float *)&node_instance.world);
-    update_light_instances();
-  }
-
-  static int min(int a, int b)
-  {
-    return a < b ? a : b;
-  }
-
-  void scene_state::render()
-  {
-    XMFLOAT4 eye;
-    XMFLOAT4X4 projection;
-    XMFLOAT4X4 view;
-    XMStoreFloat4(&eye, g_Eye);
-    XMStoreFloat4x4(&view, g_View);
-    XMStoreFloat4x4(&projection, g_Projection);
-
-    g_pViewVariable->SetMatrix((float *)&view);
-    g_pProjectionVariable->SetMatrix((float *)&projection);
-
-    g_pViewEyeVariable->SetFloatVector((float *)&eye);
-
-    int lights = min(2, m_lightInstancesCount);
-    g_pLightPosVariable->SetFloatVectorArray((float *)m_lightPositions, 0, lights);
-    g_pLightDirVariable->SetFloatVectorArray((float *)m_lightDirections, 0, lights);
-    g_pLightColorVariable->SetFloatVectorArray((float *)m_lightColors, 0, lights);
-
-    g_pd3dDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
-
-    for (int i = 0; i < m_descriptor->nodes_count; i++) {
-      node const& node = *m_descriptor->nodes[i];
-      node_instance& node_instance = m_nodeInstances[i];
 
       // joints aren't rendered
       if (node.type != node_type::NODE)
         continue;
 
-      g_pWorldVariable->SetMatrix((float *)&node_instance.world);
-
       render_geometries(node.instance_geometries, node.instance_geometries_count);
     }
   }

src/effect/collada_scene.fx

@@ -2,12 +2,6 @@ cbuffer cbEveryFrame
 {
   matrix View;
   matrix Projection;
-
-  float4 ViewEye;
-
-  float4 LightPos[2];
-  float4 LightDir[2];
-  float4 LightColor[2];
 };
 
 cbuffer cbMultiplePerFrame
@@ -36,39 +30,30 @@ struct PS_INPUT
   float4 Pos : SV_POSITION;
   float3 Norm : NORMAL;
   float2 Tex : TEXCOORD0;
-  float4 WPos : POSITION;
 };
 
 PS_INPUT VS(VS_INPUT input)
 {
   PS_INPUT output;
 
-  float4 world_pos = mul(float4(input.Pos, 1), World);
+  output.Pos = mul(float4(input.Pos, 1), World);
-  output.Pos = mul(world_pos, View);
+  output.Pos = mul(output.Pos, View);
   output.Pos = mul(output.Pos, Projection);
 
   output.Norm = mul(input.Norm, (float3x3)World);
   output.Tex = input.Tex;
 
-  output.WPos = world_pos;
-
   return output;
 }
 
 float4 PS(PS_INPUT input) : SV_Target
 {
-  float3 normal = normalize(input.Norm);
+  float4 color = Emission + Diffuse * 1.0 + Specular * 0.0;
-  float3 view_dir = normalize(ViewEye.xyz - input.Pos.xyz);
-
-  float3 color = Emission.xyz;
-
-  for (int i = 0; i < 2; i++) {
-    float3 light_dir = normalize(-LightDir[i].xyz);
-    float diffuse_intensity = max(dot(normal, light_dir), 0.0);
-    color += Diffuse.xyz * diffuse_intensity * LightColor[i].xyz;
-  }
 
   return float4(color.xyz, 1);
+
+  //return float4(input.Normal * 0.5 + 0.5, 1);
+  //return float4(input.Tex.xy, 0, 1);
 }
 
 BlendState DisableBlending

src/main.cpp

@@ -20,7 +20,7 @@
 #include "collada.hpp"
 #include "collada_scene.hpp"
 
-#include "scenes/curve_interpolation/curve_interpolation.hpp"
+#include "scenes/curve_interpolation.hpp"
 
 HINSTANCE g_hInstance = NULL;
 HWND g_hWnd = NULL;
@@ -1843,8 +1843,7 @@ void Render(float t, float dt)
 
   //collada::Render(t);
 
-  g_SceneState.update(t);
+  g_SceneState.render(t);
-  g_SceneState.render();
 
   RenderFont(dt);
 

src/scenes/curve_interpolation.cpp

@@ -4,16 +4,6 @@ namespace curve_interpolation {
 
 using namespace collada;
 
-light const light_environmentambientlight = {
-  .type = light_type::AMBIENT,
-  .color = { 0.0f, 0.0f, 0.0f },
-};
-
-light const light_light_light = {
-  .type = light_type::DIRECTIONAL,
-  .color = { 1.0f, 1.0f, 1.0f },
-};
-
 float const array_node_cube_translation_x_input_array[] = {
   0.0f,
   1.666667f,
@@ -150,7 +140,7 @@ sampler const sampler_node_cube_translation_y_sampler = {
   },
 };
 
-float const array_node_torus_rotationx_angle_input_array[] = {
+float const array_node_torus001_rotationx_angle_input_array[] = {
   0.0f,
   0.8333334f,
   1.666667f,
@@ -158,7 +148,7 @@ float const array_node_torus_rotationx_angle_input_array[] = {
   3.333333f,
 };
 
-float const array_node_torus_rotationx_angle_output_array[] = {
+float const array_node_torus001_rotationx_angle_output_array[] = {
   0.0f,
   -90.0f,
   -180.0f,
@@ -166,7 +156,7 @@ float const array_node_torus_rotationx_angle_output_array[] = {
   -360.0f,
 };
 
-float const array_node_torus_rotationx_angle_intangent_array[] = {
+float const array_node_torus001_rotationx_angle_intangent_array[] = {
   0.9997917f, 0.0f,
   0.3270486f, -89.70257f,
   0.9961964f, -179.1937f,
@@ -174,7 +164,7 @@ float const array_node_torus_rotationx_angle_intangent_array[] = {
   2.6534f, -360.0f,
 };
 
-float const array_node_torus_rotationx_angle_outtangent_array[] = {
+float const array_node_torus001_rotationx_angle_outtangent_array[] = {
   0.6602973f, 0.0f,
   1.324714f, -90.28867f,
   2.332406f, -180.8006f,
@@ -182,7 +172,7 @@ float const array_node_torus_rotationx_angle_outtangent_array[] = {
   2.333542f, -360.0f,
 };
 
-enum interpolation const array_node_torus_rotationx_angle_interpolation_array[] = {
+enum interpolation const array_node_torus001_rotationx_angle_interpolation_array[] = {
   interpolation::BEZIER,
   interpolation::BEZIER,
   interpolation::BEZIER,
@@ -190,175 +180,175 @@ enum interpolation const array_node_torus_rotationx_angle_interpolation_array[]
   interpolation::BEZIER,
 };
 
-sampler const sampler_node_torus_rotationx_angle_sampler = {
+sampler const sampler_node_torus001_rotationx_angle_sampler = {
-  // node_torus_rotationx_angle_input
+  // node_torus001_rotationx_angle_input
   .input = {
-    .float_array = array_node_torus_rotationx_angle_input_array,
+    .float_array = array_node_torus001_rotationx_angle_input_array,
     .count = 5,
     .stride = 1,
   },
-  // node_torus_rotationx_angle_output
+  // node_torus001_rotationx_angle_output
   .output = {
-    .float_array = array_node_torus_rotationx_angle_output_array,
+    .float_array = array_node_torus001_rotationx_angle_output_array,
     .count = 5,
     .stride = 1,
   },
-  // node_torus_rotationx_angle_intangent
+  // node_torus001_rotationx_angle_intangent
   .in_tangent = {
-    .float_array = array_node_torus_rotationx_angle_intangent_array,
+    .float_array = array_node_torus001_rotationx_angle_intangent_array,
     .count = 5,
     .stride = 2,
   },
-  // node_torus_rotationx_angle_outtangent
+  // node_torus001_rotationx_angle_outtangent
   .out_tangent = {
-    .float_array = array_node_torus_rotationx_angle_outtangent_array,
+    .float_array = array_node_torus001_rotationx_angle_outtangent_array,
     .count = 5,
     .stride = 2,
   },
-  // node_torus_rotationx_angle_interpolation
+  // node_torus001_rotationx_angle_interpolation
   .interpolation = {
-    .interpolation_array = array_node_torus_rotationx_angle_interpolation_array,
+    .interpolation_array = array_node_torus001_rotationx_angle_interpolation_array,
     .count = 5,
     .stride = 1,
   },
 };
 
-float const array_node_geosphere_scale_input_array[] = {
+float const array_node_geosphere001_scale_input_array[] = {
   0.0f,
   1.666667f,
   3.333333f,
 };
 
-float const array_node_geosphere_scale_output_array[] = {
+float const array_node_geosphere001_scale_output_array[] = {
   1.0f, 1.0f, 1.0f,
   1.996525f, 1.996525f, 1.996525f,
   1.0f, 1.0f, 1.0f,
 };
 
-float const array_node_geosphere_scale_intangent_array[] = {
+float const array_node_geosphere001_scale_intangent_array[] = {
   0.9997917f, 1.0f, 0.9997917f, 1.0f, 0.9997917f, 1.0f,
   1.111167f, 1.996525f, 1.111167f, 1.996525f, 1.111167f, 1.996525f,
   2.777833f, 1.0f, 2.777833f, 1.0f, 2.777833f, 1.0f,
 };
 
-float const array_node_geosphere_scale_outtangent_array[] = {
+float const array_node_geosphere001_scale_outtangent_array[] = {
   0.5555f, 1.0f, 0.5555f, 1.0f, 0.5555f, 1.0f,
   2.222167f, 1.996525f, 2.222167f, 1.996525f, 2.222167f, 1.996525f,
   2.333542f, 1.0f, 2.333542f, 1.0f, 2.333542f, 1.0f,
 };
 
-enum interpolation const array_node_geosphere_scale_interpolation_array[] = {
+enum interpolation const array_node_geosphere001_scale_interpolation_array[] = {
   interpolation::BEZIER,
   interpolation::BEZIER,
   interpolation::BEZIER,
 };
 
-sampler const sampler_node_geosphere_scale_sampler = {
+sampler const sampler_node_geosphere001_scale_sampler = {
-  // node_geosphere_scale_input
+  // node_geosphere001_scale_input
   .input = {
-    .float_array = array_node_geosphere_scale_input_array,
+    .float_array = array_node_geosphere001_scale_input_array,
     .count = 3,
     .stride = 1,
   },
-  // node_geosphere_scale_output
+  // node_geosphere001_scale_output
   .output = {
-    .float_array = array_node_geosphere_scale_output_array,
+    .float_array = array_node_geosphere001_scale_output_array,
     .count = 3,
     .stride = 3,
   },
-  // node_geosphere_scale_intangent
+  // node_geosphere001_scale_intangent
   .in_tangent = {
-    .float_array = array_node_geosphere_scale_intangent_array,
+    .float_array = array_node_geosphere001_scale_intangent_array,
     .count = 3,
     .stride = 6,
   },
-  // node_geosphere_scale_outtangent
+  // node_geosphere001_scale_outtangent
   .out_tangent = {
-    .float_array = array_node_geosphere_scale_outtangent_array,
+    .float_array = array_node_geosphere001_scale_outtangent_array,
     .count = 3,
     .stride = 6,
   },
-  // node_geosphere_scale_interpolation
+  // node_geosphere001_scale_interpolation
   .interpolation = {
-    .interpolation_array = array_node_geosphere_scale_interpolation_array,
+    .interpolation_array = array_node_geosphere001_scale_interpolation_array,
     .count = 3,
     .stride = 1,
   },
 };
 
-float const array_node_geosphere_inversescaleaxisrotation_input_array[] = {
+float const array_node_geosphere001_inversescaleaxisrotation_input_array[] = {
   0.0f,
   1.666667f,
   3.333333f,
 };
 
-float const array_node_geosphere_inversescaleaxisrotation_output_array[] = {
+float const array_node_geosphere001_inversescaleaxisrotation_output_array[] = {
   0.0f, 0.0f, 0.0f, 0.0f,
   0.0f, 0.0f, 0.0f, 0.0f,
   0.0f, 0.0f, 0.0f, 0.0f,
 };
 
-enum interpolation const array_node_geosphere_inversescaleaxisrotation_interpolation_array[] = {
+enum interpolation const array_node_geosphere001_inversescaleaxisrotation_interpolation_array[] = {
   interpolation::LINEAR,
   interpolation::LINEAR,
   interpolation::LINEAR,
 };
 
-sampler const sampler_node_geosphere_inversescaleaxisrotation_sampler = {
+sampler const sampler_node_geosphere001_inversescaleaxisrotation_sampler = {
-  // node_geosphere_inversescaleaxisrotation_input
+  // node_geosphere001_inversescaleaxisrotation_input
   .input = {
-    .float_array = array_node_geosphere_inversescaleaxisrotation_input_array,
+    .float_array = array_node_geosphere001_inversescaleaxisrotation_input_array,
     .count = 3,
     .stride = 1,
   },
-  // node_geosphere_inversescaleaxisrotation_output
+  // node_geosphere001_inversescaleaxisrotation_output
   .output = {
-    .float_array = array_node_geosphere_inversescaleaxisrotation_output_array,
+    .float_array = array_node_geosphere001_inversescaleaxisrotation_output_array,
     .count = 3,
     .stride = 4,
   },
-  // node_geosphere_inversescaleaxisrotation_interpolation
+  // node_geosphere001_inversescaleaxisrotation_interpolation
   .interpolation = {
-    .interpolation_array = array_node_geosphere_inversescaleaxisrotation_interpolation_array,
+    .interpolation_array = array_node_geosphere001_inversescaleaxisrotation_interpolation_array,
     .count = 3,
     .stride = 1,
   },
 };
 
-float const array_node_geosphere_scaleaxisrotation_input_array[] = {
+float const array_node_geosphere001_scaleaxisrotation_input_array[] = {
   0.0f,
   1.666667f,
   3.333333f,
 };
 
-float const array_node_geosphere_scaleaxisrotation_output_array[] = {
+float const array_node_geosphere001_scaleaxisrotation_output_array[] = {
   0.0f, 0.0f, 0.0f, 0.0f,
   0.0f, 0.0f, 0.0f, 0.0f,
   0.0f, 0.0f, 0.0f, 0.0f,
 };
 
-enum interpolation const array_node_geosphere_scaleaxisrotation_interpolation_array[] = {
+enum interpolation const array_node_geosphere001_scaleaxisrotation_interpolation_array[] = {
   interpolation::LINEAR,
   interpolation::LINEAR,
   interpolation::LINEAR,
 };
 
-sampler const sampler_node_geosphere_scaleaxisrotation_sampler = {
+sampler const sampler_node_geosphere001_scaleaxisrotation_sampler = {
-  // node_geosphere_scaleaxisrotation_input
+  // node_geosphere001_scaleaxisrotation_input
   .input = {
-    .float_array = array_node_geosphere_scaleaxisrotation_input_array,
+    .float_array = array_node_geosphere001_scaleaxisrotation_input_array,
     .count = 3,
     .stride = 1,
   },
-  // node_geosphere_scaleaxisrotation_output
+  // node_geosphere001_scaleaxisrotation_output
   .output = {
-    .float_array = array_node_geosphere_scaleaxisrotation_output_array,
+    .float_array = array_node_geosphere001_scaleaxisrotation_output_array,
     .count = 3,
     .stride = 4,
   },
-  // node_geosphere_scaleaxisrotation_interpolation
+  // node_geosphere001_scaleaxisrotation_interpolation
   .interpolation = {
-    .interpolation_array = array_node_geosphere_scaleaxisrotation_interpolation_array,
+    .interpolation_array = array_node_geosphere001_scaleaxisrotation_interpolation_array,
     .count = 3,
     .stride = 1,
   },
@@ -376,27 +366,27 @@ channel const node_channel_node_cube_translation_y = {
   .target_attribute = target_attribute::Y,
 };
 
-channel const node_channel_node_torus_rotationx_angle = {
+channel const node_channel_node_torus001_rotationx_angle = {
-  .source_sampler = &sampler_node_torus_rotationx_angle_sampler,
+  .source_sampler = &sampler_node_torus001_rotationx_angle_sampler,
   .target_transform_index = 3,
   .target_attribute = target_attribute::ANGLE,
 };
 
-channel const node_channel_node_geosphere_scale = {
+channel const node_channel_node_geosphere001_scale = {
-  .source_sampler = &sampler_node_geosphere_scale_sampler,
+  .source_sampler = &sampler_node_geosphere001_scale_sampler,
+  .target_transform_index = 2,
+  .target_attribute = target_attribute::ALL,
+};
+
+channel const node_channel_node_geosphere001_inversescaleaxisrotation = {
+  .source_sampler = &sampler_node_geosphere001_inversescaleaxisrotation_sampler,
   .target_transform_index = 1,
   .target_attribute = target_attribute::ALL,
 };
 
-channel const node_channel_node_geosphere_inversescaleaxisrotation = {
+channel const node_channel_node_geosphere001_scaleaxisrotation = {
-  .source_sampler = &sampler_node_geosphere_inversescaleaxisrotation_sampler,
+  .source_sampler = &sampler_node_geosphere001_scaleaxisrotation_sampler,
-  .target_transform_index = 0,
+  .target_transform_index = 3,
-  .target_attribute = target_attribute::ALL,
-};
-
-channel const node_channel_node_geosphere_scaleaxisrotation = {
-  .source_sampler = &sampler_node_geosphere_scaleaxisrotation_sampler,
-  .target_transform_index = 2,
   .target_attribute = target_attribute::ALL,
 };
 
@@ -680,34 +670,6 @@ effect const effect_coloreffectr198g224b87 = {
   }
 };
 
-effect const effect_lightemit = {
-  .type = effect_type::BLINN,
-  .blinn = {
-    .emission = {
-      .color = {1.0f, 1.0f, 1.0f, 1.0f},
-    },
-    .ambient = {
-      .color = {0.0f, 0.0f, 0.0f, 1.0f},
-    },
-    .diffuse = {
-      .color = {0.0f, 0.0f, 0.0f, 1.0f},
-    },
-    .specular = {
-      .color = {0.0f, 0.0f, 0.0f, 1.0f},
-    },
-    .shininess = 10.0f,
-    .reflective = {
-      .color = {0.0f, 0.0f, 0.0f, 1.0f},
-    },
-    .reflectivity = 0.0f,
-    .transparent = {
-      .color = {1.0f, 1.0f, 1.0f, 1.0f},
-    },
-    .transparency = 1.0f,
-    .index_of_refraction = 0.0f,
-  }
-};
-
 material const material_coloreffectr26g177b26_material = {
   .effect = &effect_coloreffectr26g177b26,
 };
@@ -748,10 +710,6 @@ material const material_material__20_material = {
   .effect = &effect_material__20,
 };
 
-material const material_lightemit_material = {
-  .effect = &effect_lightemit,
-};
-
 input_element const input_elements_position_0_3_normal_0_3_texcoord_0_3[] = {
   {
     .semantic = "POSITION",
@@ -816,7 +774,7 @@ geometry const geometry_geom_cube = {
   }
 };
 
-triangles const triangles_geom_torus[] = {
+triangles const triangles_geom_torus001[] = {
   {
     .count = 240, // triangles
     .index_offset = 0, // indices
@@ -824,9 +782,9 @@ triangles const triangles_geom_torus[] = {
   },
 };
 
-geometry const geometry_geom_torus = {
+geometry const geometry_geom_torus001 = {
   .mesh = {
-    .triangles = triangles_geom_torus,
+    .triangles = triangles_geom_torus001,
     .triangles_count = 1,
 
     .vertex_buffer_offset = 864,
@@ -837,7 +795,7 @@ geometry const geometry_geom_torus = {
   }
 };
 
-triangles const triangles_geom_cylinder[] = {
+triangles const triangles_geom_cylinder001[] = {
   {
     .count = 30, // triangles
     .index_offset = 0, // indices
@@ -845,9 +803,9 @@ triangles const triangles_geom_cylinder[] = {
   },
 };
 
-geometry const geometry_geom_cylinder = {
+geometry const geometry_geom_cylinder001 = {
   .mesh = {
-    .triangles = triangles_geom_cylinder,
+    .triangles = triangles_geom_cylinder001,
     .triangles_count = 1,
 
     .vertex_buffer_offset = 6012,
@@ -858,7 +816,7 @@ geometry const geometry_geom_cylinder = {
   }
 };
 
-triangles const triangles_geom_plane[] = {
+triangles const triangles_geom_plane001[] = {
   {
     .count = 2, // triangles
     .index_offset = 0, // indices
@@ -866,9 +824,9 @@ triangles const triangles_geom_plane[] = {
   },
 };
 
-geometry const geometry_geom_plane = {
+geometry const geometry_geom_plane001 = {
   .mesh = {
-    .triangles = triangles_geom_plane,
+    .triangles = triangles_geom_plane001,
     .triangles_count = 1,
 
     .vertex_buffer_offset = 7164,
@@ -879,7 +837,7 @@ geometry const geometry_geom_plane = {
   }
 };
 
-triangles const triangles_geom_geosphere[] = {
+triangles const triangles_geom_geosphere001[] = {
   {
     .count = 40, // triangles
     .index_offset = 0, // indices
@@ -887,9 +845,9 @@ triangles const triangles_geom_geosphere[] = {
   },
 };
 
-geometry const geometry_geom_geosphere = {
+geometry const geometry_geom_geosphere001 = {
   .mesh = {
-    .triangles = triangles_geom_geosphere,
+    .triangles = triangles_geom_geosphere001,
     .triangles_count = 1,
 
     .vertex_buffer_offset = 7308,
@@ -900,34 +858,12 @@ geometry const geometry_geom_geosphere = {
   }
 };
 
-triangles const triangles_geom_lightindicator[] = {
-  {
-    .count = 8, // triangles
-    .index_offset = 0, // indices
-    .inputs_index = 0, // index into inputs_list
-  },
-};
-
-geometry const geometry_geom_lightindicator = {
-  .mesh = {
-    .triangles = triangles_geom_lightindicator,
-    .triangles_count = 1,
-
-    .vertex_buffer_offset = 11628,
-    .vertex_buffer_size = 864,
-
-    .index_buffer_offset = 3888,
-    .index_buffer_size = 96,
-  }
-};
-
 geometry const * const geometries[] = {
   &geometry_geom_cube,
-  &geometry_geom_torus,
+  &geometry_geom_torus001,
-  &geometry_geom_cylinder,
+  &geometry_geom_cylinder001,
-  &geometry_geom_plane,
+  &geometry_geom_plane001,
-  &geometry_geom_geosphere,
+  &geometry_geom_geosphere001,
-  &geometry_geom_lightindicator,
 };
 
 transform const transforms_node_environmentambientlight[] = {
@@ -936,12 +872,6 @@ transform const transforms_node_environmentambientlight[] = {
 instance_geometry const instance_geometries_node_environmentambientlight[] = {
 };
 
-instance_light const instance_lights_node_environmentambientlight[] = {
-  {
-    .light = &light_environmentambientlight,
-  }
-};
-
 channel const * const node_channels_node_environmentambientlight[] = {};
 
 node const node_node_environmentambientlight = {
@@ -955,9 +885,6 @@ node const node_node_environmentambientlight = {
   .instance_geometries = instance_geometries_node_environmentambientlight,
   .instance_geometries_count = 0,
 
-  .instance_lights = instance_lights_node_environmentambientlight,
-  .instance_lights_count = 1,
-
   .channels = node_channels_node_environmentambientlight,
   .channels_count = 0,
 };
@@ -1004,9 +931,6 @@ instance_geometry const instance_geometries_node_cube[] = {
   },
 };
 
-instance_light const instance_lights_node_cube[] = {
-};
-
 channel const * const node_channels_node_cube[] = {
   &node_channel_node_cube_translation_y,
   &node_channel_node_cube_translation_x,
@@ -1023,14 +947,11 @@ node const node_node_cube = {
   .instance_geometries = instance_geometries_node_cube,
   .instance_geometries_count = 1,
 
-  .instance_lights = instance_lights_node_cube,
-  .instance_lights_count = 0,
-
   .channels = node_channels_node_cube,
   .channels_count = 2,
 };
 
-transform const transforms_node_torus[] = {
+transform const transforms_node_torus001[] = {
   {
     .type = transform_type::TRANSLATE,
     .translate = {5.0f, 1.14258e-07f, 2.0f},
@@ -1053,89 +974,77 @@ transform const transforms_node_torus[] = {
   },
 };
 
-instance_material const instance_materials_node_torus_0[] = {
+instance_material const instance_materials_node_torus001_0[] = {
   {
     .element_index = 0, // an index into mesh.triangles
     .material = &material_coloreffectr26g177b26_material,
   },
 };
 
-instance_geometry const instance_geometries_node_torus[] = {
+instance_geometry const instance_geometries_node_torus001[] = {
   {
-    .geometry = &geometry_geom_torus,
+    .geometry = &geometry_geom_torus001,
-    .instance_materials = instance_materials_node_torus_0,
+    .instance_materials = instance_materials_node_torus001_0,
     .instance_materials_count = 1,
   },
 };
 
-instance_light const instance_lights_node_torus[] = {
+channel const * const node_channels_node_torus001[] = {
+  &node_channel_node_torus001_rotationx_angle,
 };
 
-channel const * const node_channels_node_torus[] = {
+node const node_node_torus001 = {
-  &node_channel_node_torus_rotationx_angle,
-};
-
-node const node_node_torus = {
   .parent_index = 1,
 
   .type = node_type::NODE,
 
-  .transforms = transforms_node_torus,
+  .transforms = transforms_node_torus001,
   .transforms_count = 5,
 
-  .instance_geometries = instance_geometries_node_torus,
+  .instance_geometries = instance_geometries_node_torus001,
   .instance_geometries_count = 1,
 
-  .instance_lights = instance_lights_node_torus,
+  .channels = node_channels_node_torus001,
-  .instance_lights_count = 0,
-
-  .channels = node_channels_node_torus,
   .channels_count = 1,
 };
 
-transform const transforms_node_cylinder[] = {
+transform const transforms_node_cylinder001[] = {
 };
 
-instance_material const instance_materials_node_cylinder_0[] = {
+instance_material const instance_materials_node_cylinder001_0[] = {
   {
     .element_index = 0, // an index into mesh.triangles
     .material = &material_coloreffectr229g154b215_material,
   },
 };
 
-instance_geometry const instance_geometries_node_cylinder[] = {
+instance_geometry const instance_geometries_node_cylinder001[] = {
   {
-    .geometry = &geometry_geom_cylinder,
+    .geometry = &geometry_geom_cylinder001,
-    .instance_materials = instance_materials_node_cylinder_0,
+    .instance_materials = instance_materials_node_cylinder001_0,
     .instance_materials_count = 1,
   },
 };
 
-instance_light const instance_lights_node_cylinder[] = {
+channel const * const node_channels_node_cylinder001[] = {
 };
 
-channel const * const node_channels_node_cylinder[] = {
+node const node_node_cylinder001 = {
-};
-
-node const node_node_cylinder = {
   .parent_index = -1,
 
   .type = node_type::NODE,
 
-  .transforms = transforms_node_cylinder,
+  .transforms = transforms_node_cylinder001,
   .transforms_count = 0,
 
-  .instance_geometries = instance_geometries_node_cylinder,
+  .instance_geometries = instance_geometries_node_cylinder001,
   .instance_geometries_count = 1,
 
-  .instance_lights = instance_lights_node_cylinder,
+  .channels = node_channels_node_cylinder001,
-  .instance_lights_count = 0,
-
-  .channels = node_channels_node_cylinder,
   .channels_count = 0,
 };
 
-transform const transforms_node_plane[] = {
+transform const transforms_node_plane001[] = {
   {
     .type = transform_type::TRANSLATE,
     .translate = {0.0f, 0.0f, 0.01f},
@@ -1146,46 +1055,44 @@ transform const transforms_node_plane[] = {
   },
 };
 
-instance_material const instance_materials_node_plane_0[] = {
+instance_material const instance_materials_node_plane001_0[] = {
   {
     .element_index = 0, // an index into mesh.triangles
     .material = &material_coloreffectr28g149b177_material,
   },
 };
 
-instance_geometry const instance_geometries_node_plane[] = {
+instance_geometry const instance_geometries_node_plane001[] = {
   {
-    .geometry = &geometry_geom_plane,
+    .geometry = &geometry_geom_plane001,
-    .instance_materials = instance_materials_node_plane_0,
+    .instance_materials = instance_materials_node_plane001_0,
     .instance_materials_count = 1,
   },
 };
 
-instance_light const instance_lights_node_plane[] = {
+channel const * const node_channels_node_plane001[] = {
 };
 
-channel const * const node_channels_node_plane[] = {
+node const node_node_plane001 = {
-};
-
-node const node_node_plane = {
   .parent_index = -1,
 
   .type = node_type::NODE,
 
-  .transforms = transforms_node_plane,
+  .transforms = transforms_node_plane001,
   .transforms_count = 2,
 
-  .instance_geometries = instance_geometries_node_plane,
+  .instance_geometries = instance_geometries_node_plane001,
   .instance_geometries_count = 1,
 
-  .instance_lights = instance_lights_node_plane,
+  .channels = node_channels_node_plane001,
-  .instance_lights_count = 0,
-
-  .channels = node_channels_node_plane,
   .channels_count = 0,
 };
 
-transform const transforms_node_geosphere[] = {
+transform const transforms_node_geosphere001[] = {
+  {
+    .type = transform_type::TRANSLATE,
+    .translate = {0.03164387f, -0.03838623f, 0.0f},
+  },
   {
     .type = transform_type::ROTATE,
     .rotate = {0.0f, 0.0f, 0.0f, 0.0f},
@@ -1200,140 +1107,49 @@ transform const transforms_node_geosphere[] = {
   },
 };
 
-instance_material const instance_materials_node_geosphere_0[] = {
+instance_material const instance_materials_node_geosphere001_0[] = {
   {
     .element_index = 0, // an index into mesh.triangles
     .material = &material_coloreffectr198g224b87_material,
   },
 };
 
-instance_geometry const instance_geometries_node_geosphere[] = {
+instance_geometry const instance_geometries_node_geosphere001[] = {
   {
-    .geometry = &geometry_geom_geosphere,
+    .geometry = &geometry_geom_geosphere001,
-    .instance_materials = instance_materials_node_geosphere_0,
+    .instance_materials = instance_materials_node_geosphere001_0,
     .instance_materials_count = 1,
   },
 };
 
-instance_light const instance_lights_node_geosphere[] = {
+channel const * const node_channels_node_geosphere001[] = {
+  &node_channel_node_geosphere001_inversescaleaxisrotation,
+  &node_channel_node_geosphere001_scale,
+  &node_channel_node_geosphere001_scaleaxisrotation,
 };
 
-channel const * const node_channels_node_geosphere[] = {
+node const node_node_geosphere001 = {
-  &node_channel_node_geosphere_scale,
-  &node_channel_node_geosphere_inversescaleaxisrotation,
-  &node_channel_node_geosphere_scaleaxisrotation,
-};
-
-node const node_node_geosphere = {
   .parent_index = -1,
 
   .type = node_type::NODE,
 
-  .transforms = transforms_node_geosphere,
+  .transforms = transforms_node_geosphere001,
-  .transforms_count = 3,
+  .transforms_count = 4,
 
-  .instance_geometries = instance_geometries_node_geosphere,
+  .instance_geometries = instance_geometries_node_geosphere001,
   .instance_geometries_count = 1,
 
-  .instance_lights = instance_lights_node_geosphere,
+  .channels = node_channels_node_geosphere001,
-  .instance_lights_count = 0,
-
-  .channels = node_channels_node_geosphere,
   .channels_count = 3,
 };
 
-transform const transforms_node_light[] = {
-  {
-    .type = transform_type::TRANSLATE,
-    .translate = {2.124535f, 8.291501f, 6.185831f},
-  },
-};
-
-instance_geometry const instance_geometries_node_light[] = {
-};
-
-instance_light const instance_lights_node_light[] = {
-  {
-    .light = &light_light_light,
-  }
-};
-
-channel const * const node_channels_node_light[] = {
-};
-
-node const node_node_light = {
-  .parent_index = -1,
-
-  .type = node_type::NODE,
-
-  .transforms = transforms_node_light,
-  .transforms_count = 1,
-
-  .instance_geometries = instance_geometries_node_light,
-  .instance_geometries_count = 0,
-
-  .instance_lights = instance_lights_node_light,
-  .instance_lights_count = 1,
-
-  .channels = node_channels_node_light,
-  .channels_count = 0,
-};
-
-transform const transforms_node_lightindicator[] = {
-  {
-    .type = transform_type::ROTATE,
-    .rotate = {0.5773504f, -0.5773501f, -0.5773504f, -120.0f},
-  },
-};
-
-instance_material const instance_materials_node_lightindicator_0[] = {
-  {
-    .element_index = 0, // an index into mesh.triangles
-    .material = &material_lightemit_material,
-  },
-};
-
-instance_geometry const instance_geometries_node_lightindicator[] = {
-  {
-    .geometry = &geometry_geom_lightindicator,
-    .instance_materials = instance_materials_node_lightindicator_0,
-    .instance_materials_count = 1,
-  },
-};
-
-instance_light const instance_lights_node_lightindicator[] = {
-};
-
-channel const * const node_channels_node_lightindicator[] = {
-};
-
-node const node_node_lightindicator = {
-  .parent_index = 6,
-
-  .type = node_type::NODE,
-
-  .transforms = transforms_node_lightindicator,
-  .transforms_count = 1,
-
-  .instance_geometries = instance_geometries_node_lightindicator,
-  .instance_geometries_count = 1,
-
-  .instance_lights = instance_lights_node_lightindicator,
-  .instance_lights_count = 0,
-
-  .channels = node_channels_node_lightindicator,
-  .channels_count = 0,
-};
-
 node const * const nodes[] = {
   &node_node_environmentambientlight,
   &node_node_cube,
-  &node_node_torus,
+  &node_node_torus001,
-  &node_node_cylinder,
+  &node_node_cylinder001,
-  &node_node_plane,
+  &node_node_plane001,
-  &node_node_geosphere,
+  &node_node_geosphere001,
-  &node_node_light,
-  &node_node_lightindicator,
 };
 
 inputs const inputs_list[] = {