ruby_rpg 0.0.4 → 0.1.0

data/lib/engine/serialization/serializable.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Engine
+  module Serializable
+    class InitializeNotAllowedError < StandardError; end
+
+    @allowed_classes = {}
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      @allowed_classes[base.name] = base if base.name
+
+      # Prevent subclasses from defining initialize
+      base.define_singleton_method(:method_added) do |method_name|
+        if method_name == :initialize
+          raise InitializeNotAllowedError,
+            "#{self.name} cannot define 'initialize'. " \
+            "Serializable classes must use 'awake' for initialization logic and be created with '.create'"
+        end
+        super(method_name) if defined?(super)
+      end
+    end
+
+    # Default awake implementation - override in subclasses
+    def awake
+    end
+
+    def self.allowed_class?(class_name)
+      @allowed_classes.key?(class_name)
+    end
+
+    def self.get_class(class_name)
+      @allowed_classes[class_name]
+    end
+
+    def self.register_class(klass)
+      @allowed_classes[klass.name] = klass if klass.name
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        super
+        Serializable.register_class(subclass)
+      end
+
+      def serialize(*attributes)
+        @own_serializable_attributes ||= []
+        @own_serializable_attributes.concat(attributes)
+      end
+
+      def serializable_attributes
+        parent_attrs = if superclass.respond_to?(:serializable_attributes)
+                         superclass.serializable_attributes
+                       else
+                         []
+                       end
+        own_attrs = @own_serializable_attributes || []
+        parent_attrs + own_attrs
+      end
+
+      def create(**attrs)
+        instance = allocate
+        instance.instance_variable_set(:@uuid, SecureRandom.uuid)
+        attrs.each do |attr, value|
+          instance.instance_variable_set("@#{attr}", value)
+        end
+        instance.awake
+        instance
+      end
+    end
+
+    def uuid
+      @uuid ||= SecureRandom.uuid
+    end
+  end
+end

data/lib/engine/serialization/yaml_persistence.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Engine
+  module Serialization
+    class YamlPersistence
+      class << self
+        def save(obj, path)
+          data = GraphSerializer.serialize(obj)
+          File.write(path, data.to_yaml)
+        end
+
+        def save_all(objects, path)
+          all_data = objects.flat_map { |obj| GraphSerializer.serialize(obj) }
+          seen_uuids = {}
+          unique_data = all_data.select do |obj_data|
+            uuid = obj_data[:uuid]
+            if seen_uuids[uuid]
+              false
+            else
+              seen_uuids[uuid] = true
+              true
+            end
+          end
+          File.write(path, unique_data.to_yaml)
+        end
+
+        def load(path)
+          data = YAML.load_file(path, permitted_classes: [Symbol])
+          data_array = data.is_a?(Array) ? data : [data]
+          GraphSerializer.deserialize(data_array).first
+        end
+
+        def load_all(paths)
+          data_array = paths.flat_map do |path|
+            data = YAML.load_file(path, permitted_classes: [Symbol])
+            data.is_a?(Array) ? data : [data]
+          end
+          GraphSerializer.deserialize(data_array)
+        end
+      end
+    end
+  end
+end

data/lib/engine/shader.rb

@@ -1,23 +1,96 @@
 module Engine
   class Shader
-    def initialize(vertex_shader, fragment_shader)
-      @vertex_shader = compile_shader(vertex_shader, GL::VERTEX_SHADER)
-      @fragment_shader = compile_shader(fragment_shader, GL::FRAGMENT_SHADER)
-      @program = GL.CreateProgram
-      GL.AttachShader(@program, @vertex_shader)
-      GL.AttachShader(@program, @fragment_shader)
-      GL.LinkProgram(@program)
+    include Serializable
+
+    attr_reader :source
+
+    @cache = {}
+
+    def self.for(vertex_path, fragment_path, source: :game)
+      key = [vertex_path, fragment_path, source]
+      @cache[key] ||= create(vertex_path: vertex_path, fragment_path: fragment_path, source: source)
+    end
+
+    def self.from_file(vertex_path, fragment_path, source: :game)
+      self.for(vertex_path, fragment_path, source: source)
+    end
+
+    def self.from_serializable_data(data)
+      self.for(data[:vertex_path], data[:fragment_path], source: (data[:source] || :game).to_sym)
+    end
+
+    def serializable_data
+      { vertex_path: @vertex_path, fragment_path: @fragment_path, source: @source }
+    end
+
+    def self.default
+      @default ||= Shader.for('mesh_vertex.glsl', 'mesh_frag.glsl', source: :engine)
+    end
+
+    def self.vertex_lit
+      @vertex_lit ||= Engine::Shader.for('vertex_lit_vertex.glsl', 'vertex_lit_frag.glsl', source: :engine)
+    end
+
+    def self.skybox_cubemap
+      @skybox_cubemap ||= Shader.for('fullscreen_vertex.glsl', 'skybox_cubemap_frag.glsl', source: :engine)
+    end
+
+    def self.sprite
+      @sprite ||= Engine::Shader.for('sprite_vertex.glsl', 'sprite_frag.glsl', source: :engine)
+    end
+
+    def self.instanced_sprite
+      @instanced_sprite ||= Engine::Shader.for('instanced_sprite_vertex.glsl', 'instanced_sprite_frag.glsl', source: :engine)
+    end
+
+    def self.text
+      @text ||= Engine::Shader.for('text_vertex.glsl', 'text_frag.glsl', source: :engine)
+    end
+
+    def self.ui_text
+      @ui_text ||= Engine::Shader.for('text_vertex.glsl', 'text_frag.glsl', source: :engine)
+    end
+
+    def self.ui_sprite
+      @ui_sprite ||= Engine::Shader.for('ui_sprite_vertex.glsl', 'ui_sprite_frag.glsl', source: :engine)
+    end
+
+    def self.fullscreen
+      @fullscreen ||= Engine::Shader.for('fullscreen_vertex.glsl', 'fullscreen_frag.glsl', source: :engine)
+    end
+
+    def self.colour
+      @colour ||= Engine::Shader.for('colour_vertex.glsl', 'colour_frag.glsl', source: :engine)
+    end
+
+    def self.shadow
+      @shadow ||= Engine::Shader.for('shadow_vertex.glsl', 'shadow_frag.glsl', source: :engine)
+    end
+
+    def self.point_shadow
+      @point_shadow ||= Engine::Shader.for('point_shadow_vertex.glsl', 'point_shadow_frag.glsl', source: :engine)
+    end
+
+    def awake
+      @texture_fallbacks = {}
+      @cubemap_fallbacks = {}
+      @vertex_shader = compile_shader(@vertex_path, Engine::GL::VERTEX_SHADER)
+      @fragment_shader = compile_shader(@fragment_path, Engine::GL::FRAGMENT_SHADER)
+      @program = Engine::GL.CreateProgram
+      Engine::GL.AttachShader(@program, @vertex_shader)
+      Engine::GL.AttachShader(@program, @fragment_shader)
+      Engine::GL.LinkProgram(@program)
 
       linked_buf = ' ' * 4
-      GL.GetProgramiv(@program, GL::LINK_STATUS, linked_buf)
+      Engine::GL.GetProgramiv(@program, Engine::GL::LINK_STATUS, linked_buf)
       linked = linked_buf.unpack('L')[0]
       if linked == 0
         compile_log = ' ' * 1024
-        GL.GetProgramInfoLog(@program, 1023, nil, compile_log)
+        Engine::GL.GetProgramInfoLog(@program, 1023, nil, compile_log)
         vertex_log = ' ' * 1024
-        GL.GetShaderInfoLog(@vertex_shader, 1023, nil, vertex_log)
+        Engine::GL.GetShaderInfoLog(@vertex_shader, 1023, nil, vertex_log)
         fragment_log = ' ' * 1024
-        GL.GetShaderInfoLog(@fragment_shader, 1023, nil, fragment_log)
+        Engine::GL.GetShaderInfoLog(@fragment_shader, 1023, nil, fragment_log)
         puts "Shader program failed to link"
         puts compile_log.strip
         puts vertex_log.strip
@@ -28,34 +101,76 @@ module Engine
     end
 
     def compile_shader(shader, type)
-      handle = GL.CreateShader(type)
-      path = File.join(File.dirname(__FILE__), shader)
-      s_srcs = [File.read(path)].pack('p')
-      s_lens = [File.size(path)].pack('I')
-      GL.ShaderSource(handle, 1, s_srcs, s_lens)
-      GL.CompileShader(handle)
+      handle = Engine::GL.CreateShader(type)
+      path = resolve_shader_path(shader)
+      source = preprocess_shader(path)
+      parse_texture_fallbacks(source)
+      s_srcs = [source].pack('p')
+      s_lens = [source.bytesize].pack('I')
+      Engine::GL.ShaderSource(handle, 1, s_srcs, s_lens)
+      Engine::GL.CompileShader(handle)
       handle
     end
 
+    def resolve_shader_path(shader)
+      if @source == :engine
+        File.join(ENGINE_DIR, "shaders", shader)
+      else
+        File.join(GAME_DIR, "shaders", shader)
+      end
+    end
+
+    def texture_fallback(name)
+      @texture_fallbacks[name] || :white
+    end
+
+    def expected_textures
+      @texture_fallbacks.keys
+    end
+
+    def cubemap_fallback(name)
+      @cubemap_fallbacks[name]
+    end
+
+    def preprocess_shader(path, included = [])
+      return "" if included.include?(path)
+      included << path
+
+      source = File.read(path)
+      dir = File.dirname(path)
+
+      source.gsub(/#include\s+"([^"]+)"/) do
+        include_path = File.join(dir, $1)
+        preprocess_shader(include_path, included)
+      end
+    end
+
     def use
-      GL.UseProgram(@program)
+      Engine::GL.UseProgram(@program)
     end
 
-    def set_vec3(name, vec)
+    def set_vec2(name, vec)
       return if @uniform_cache[name] == vec
       @uniform_cache[name] = vec
+      Engine::GL.Uniform2f(uniform_location(name), vec[0], vec[1])
+    end
+
+    def set_vec3(name, vec)
       vector = if vec.is_a?(Vector)
                  vec
                else
                  Vector[vec[:r], vec[:g], vec[:b]]
                end
-      GL.Uniform3f(uniform_location(name), vector[0], vector[1], vector[2])
+      cache_key = [vector[0], vector[1], vector[2]]
+      return if @uniform_cache[name] == cache_key
+      @uniform_cache[name] = cache_key
+      Engine::GL.Uniform3f(uniform_location(name), vector[0], vector[1], vector[2])
     end
 
     def set_vec4(name, vec)
       return if @uniform_cache[name] == vec
       @uniform_cache[name] = vec
-      GL.Uniform4f(uniform_location(name), vec[0], vec[1], vec[2], vec[3])
+      Engine::GL.Uniform4f(uniform_location(name), vec[0], vec[1], vec[2], vec[3])
     end
 
     def set_mat4(name, mat)
@@ -67,25 +182,34 @@ module Engine
         mat[2, 0], mat[2, 1], mat[2, 2], mat[2, 3],
         mat[3, 0], mat[3, 1], mat[3, 2], mat[3, 3]
       ]
-      GL.UniformMatrix4fv(uniform_location(name), 1, GL::FALSE, mat_array.pack('F*'))
+      Engine::GL.UniformMatrix4fv(uniform_location(name), 1, Engine::GL::FALSE, mat_array.pack('F*'))
     end
 
     def set_int(name, int)
       return if @uniform_cache[name] == int
       @uniform_cache[name] = int
-      GL.Uniform1i(uniform_location(name), int)
+      Engine::GL.Uniform1i(uniform_location(name), int)
     end
 
     def set_float(name, float)
       return if @uniform_cache[name] == float
       @uniform_cache[name] = float
-      GL.Uniform1f(uniform_location(name), float)
+      Engine::GL.Uniform1f(uniform_location(name), float)
     end
 
     private
 
+    def parse_texture_fallbacks(source)
+      source.scan(/uniform\s+sampler2D\s+(\w+)\s*;.*\/\/\s*@fallback\s+(\w+)/) do |name, fallback|
+        @texture_fallbacks[name] = fallback.to_sym
+      end
+      source.scan(/uniform\s+samplerCube\s+(\w+)\s*;.*\/\/\s*@fallback\s+(\w+)/) do |name, fallback|
+        @cubemap_fallbacks[name] = fallback.to_sym
+      end
+    end
+
     def uniform_location(name)
-      @uniform_locations[name] ||= GL.GetUniformLocation(@program, name)
+      @uniform_locations[name] ||= Engine::GL.GetUniformLocation(@program, name)
     end
   end
 end

data/lib/engine/shaders/colour_frag.glsl

@@ -1,9 +1,17 @@
 #version 330 core
 
-out vec4 FragColour;
+layout(location = 0) out vec4 FragColour;
+layout(location = 1) out vec4 normalRoughness;
+
 in vec4 ourColour;
+in vec3 Normal;
+
+uniform float roughness;
 
 void main()
 {
     FragColour = ourColour;
+    // Output world-space normal (encoded to 0-1) and roughness
+    vec3 norm = normalize(Normal);
+    normalRoughness = vec4(norm * 0.5 + 0.5, roughness);
 }

data/lib/engine/shaders/colour_vertex.glsl

@@ -1,14 +1,21 @@
 #version 330 core
-layout (location = 0) in vec3 aPos;
 
-uniform vec3 colour;
-out vec4 ourColour;
+layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoord;
+layout (location = 2) in vec3 normal;
+layout (location = 3) in vec3 tangent;
+layout (location = 7) in mat4 model;
 
+uniform vec3 colour;
 uniform mat4 camera;
-uniform mat4 model;
+
+out vec4 ourColour;
+out vec3 Normal;
 
 void main()
 {
-    gl_Position = camera * model * vec4(aPos, 1.0);
+    gl_Position = camera * model * vec4(vertex, 1.0);
     ourColour = vec4(colour, 1.0);
+    // Transform normal to world space (using upper-left 3x3 of model matrix)
+    Normal = mat3(model) * normal;
 }

data/lib/engine/shaders/fullscreen_frag.glsl

@@ -0,0 +1,11 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;
+
+void main()
+{
+    color = texture(screenTexture, TexCoords);
+}

data/lib/engine/shaders/fullscreen_vertex.glsl

@@ -0,0 +1,12 @@
+#version 330 core
+
+layout (location = 0) in vec2 position;
+layout (location = 1) in vec2 texCoord;
+
+out vec2 TexCoords;
+
+void main()
+{
+    TexCoords = texCoord;
+    gl_Position = vec4(position, 0.0, 1.0);
+}

data/lib/engine/shaders/instanced_sprite_frag.glsl

@@ -0,0 +1,21 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D image;
+uniform vec4 spriteColor;
+uniform vec4 frameCoords;
+
+void main()
+{
+    vec2 interpolatedCoords = vec2(
+        frameCoords.x + (TexCoords.x * frameCoords.z),
+        frameCoords.y + TexCoords.y * frameCoords.w
+    );
+    vec4 texColor = texture(image, interpolatedCoords);
+    if (texColor.a < 0.05)
+        discard;
+    else
+        color = spriteColor * texColor;
+}

data/lib/engine/shaders/{skybox_vert.glsl → instanced_sprite_vertex.glsl}

@@ -1,14 +1,15 @@
 #version 330 core
 
 layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoord;
 layout (location = 7) in mat4 model;
 
-out vec3 FragPos;
+out vec2 TexCoords;
 
 uniform mat4 camera;
 
 void main()
 {
-    FragPos = vec3(model * vec4(vertex, 1.0));
+    TexCoords = texCoord;
     gl_Position = camera * model * vec4(vertex, 1.0);
 }

data/lib/engine/shaders/lighting/directional_light.glsl

@@ -0,0 +1,49 @@
+// Directional light structure and calculation functions
+
+#include "lighting_common.glsl"
+
+struct DirectionalLight {
+    vec3 direction;
+    vec3 colour;
+    mat4 lightSpaceMatrix;
+    bool castsShadows;
+};
+#define NR_DIRECTIONAL_LIGHTS 4
+uniform DirectionalLight directionalLights[NR_DIRECTIONAL_LIGHTS];
+uniform sampler2DArray directionalShadowMaps;
+
+float CalcDirectionalShadow(DirectionalLight light, int lightIndex, vec3 fragPos)
+{
+    if (!light.castsShadows) {
+        return 0.0;
+    }
+
+    vec4 fragPosLightSpace = light.lightSpaceMatrix * vec4(fragPos, 1.0);
+    vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
+    projCoords = projCoords * 0.5 + 0.5;
+
+    // Fragment is beyond the shadow map frustum
+    if (projCoords.z > 1.0) {
+        return 0.0;
+    }
+
+    // Check if coords are in valid range
+    if (projCoords.x < 0.0 || projCoords.x > 1.0 ||
+        projCoords.y < 0.0 || projCoords.y > 1.0) {
+        return 0.0;  // Outside frustum XY
+    }
+
+    float closestDepth = texture(directionalShadowMaps, vec3(projCoords.xy, float(lightIndex))).r;
+    float currentDepth = projCoords.z;
+    float bias = 0.005;
+
+    return currentDepth - bias > closestDepth ? 1.0 : 0.0;
+}
+
+vec3 CalcDirectionalLight(DirectionalLight light, int lightIndex, vec3 normal, vec3 fragPos, vec3 viewDir, float diffuseStrength, float specularStrength, float specularPower)
+{
+    float shadow = CalcDirectionalShadow(light, lightIndex, fragPos);
+    vec3 lightDir = -light.direction;
+    vec2 phong = CalcPhong(normal, lightDir, viewDir, diffuseStrength, specularStrength, specularPower);
+    return light.colour * (phong.x + phong.y) * (1.0 - shadow);
+}

data/lib/engine/shaders/lighting/lighting.glsl

@@ -0,0 +1,33 @@
+// Lighting - includes all light types and provides combined calculation
+// Include this file in shaders that need lighting support
+
+#include "directional_light.glsl"
+#include "point_light.glsl"
+#include "spot_light.glsl"
+
+uniform samplerCube skybox; // @fallback skybox
+uniform float ambientStrength = 0.3;
+
+vec3 CalcAllLights(vec3 normal, vec3 fragPos, vec3 viewDir, float diffuseStrength, float specularStrength, float specularPower)
+{
+    // Sample skybox using surface normal for ambient lighting
+    vec3 ambientLight = texture(skybox, normal).rgb * ambientStrength;
+    vec3 result = ambientLight;
+
+    for (int i = 0; i < NR_POINT_LIGHTS; i++) {
+        if (pointLights[i].sqrRange == 0.0) break;
+        result += CalcPointLight(pointLights[i], i, normal, fragPos, viewDir, diffuseStrength, specularStrength, specularPower);
+    }
+
+    for (int i = 0; i < NR_DIRECTIONAL_LIGHTS; i++) {
+        if (directionalLights[i].colour == vec3(0.0)) break;
+        result += CalcDirectionalLight(directionalLights[i], i, normal, fragPos, viewDir, diffuseStrength, specularStrength, specularPower);
+    }
+
+    for (int i = 0; i < NR_SPOT_LIGHTS; i++) {
+        if (spotLights[i].sqrRange == 0.0) break;
+        result += CalcSpotLight(spotLights[i], i, normal, fragPos, viewDir, diffuseStrength, specularStrength, specularPower);
+    }
+
+    return result;
+}

data/lib/engine/shaders/lighting/lighting_common.glsl

@@ -0,0 +1,13 @@
+// Common lighting calculations shared by all light types
+
+// Calculates Phong diffuse and specular contribution
+// lightDir: normalized direction FROM fragment TO light
+// Returns vec2(diffuse, specular)
+vec2 CalcPhong(vec3 normal, vec3 lightDir, vec3 viewDir,
+               float diffuseStrength, float specularStrength, float specularPower)
+{
+    float diff = max(dot(normal, lightDir), 0.0);
+    vec3 reflectDir = reflect(lightDir, normal);
+    float spec = pow(max(dot(-viewDir, reflectDir), 0.0), specularPower);
+    return vec2(diff * diffuseStrength, spec * specularStrength);
+}

data/lib/engine/shaders/lighting/point_light.glsl

@@ -0,0 +1,46 @@
+// Point light structure and calculation functions
+
+#include "lighting_common.glsl"
+
+struct PointLight {
+    vec3 position;
+    float sqrRange;
+    vec3 colour;
+    bool castsShadows;
+    int shadowLayerIndex;
+    float shadowFar;
+};
+#define NR_POINT_LIGHTS 16
+#define NR_SHADOW_CASTING_POINT_LIGHTS 4
+uniform PointLight pointLights[NR_POINT_LIGHTS];
+uniform samplerCubeArray pointShadowMaps;
+
+float CalcPointShadow(PointLight light, int lightIndex, vec3 fragPos)
+{
+    if (!light.castsShadows) {
+        return 0.0;
+    }
+
+    vec3 fragToLight = fragPos - light.position;
+    float currentDepth = length(fragToLight);
+
+    // Sample from cubemap array using vec4(direction, layerIndex)
+    float closestDepth = texture(pointShadowMaps, vec4(fragToLight, float(light.shadowLayerIndex))).r;
+    closestDepth *= light.shadowFar;  // Convert from [0,1] to world units
+
+    float bias = 0.5;
+    return currentDepth - bias > closestDepth ? 1.0 : 0.0;
+}
+
+vec3 CalcPointLight(PointLight light, int lightIndex, vec3 normal, vec3 fragPos, vec3 viewDir, float diffuseStrength, float specularStrength, float specularPower)
+{
+    vec3 lightOffset = light.position - fragPos;
+    float sqrDistance = dot(lightOffset, lightOffset);
+    vec3 lightDir = normalize(lightOffset);
+
+    float attenuation = light.sqrRange / sqrDistance;
+    float shadow = CalcPointShadow(light, lightIndex, fragPos);
+
+    vec2 phong = CalcPhong(normal, lightDir, viewDir, diffuseStrength, specularStrength, specularPower);
+    return light.colour * (phong.x + phong.y) * attenuation * (1.0 - shadow);
+}