ruby_rpg 0.0.5 → 0.1.1

data/lib/engine/serialization/object_serializer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Engine
+  module Serialization
+    class ObjectSerializer
+      class UnauthorizedClassError < StandardError; end
+
+      UnresolvedRef = Struct.new(:uuid, :class_name)
+
+      class << self
+        def serialize(obj)
+          result = {
+            _class: obj.class.name,
+            uuid: obj.uuid
+          }
+
+          obj.class.serializable_attributes.each do |attr|
+            value = obj.instance_variable_get("@#{attr}")
+            result[attr] = serialize_value(value)
+          end
+
+          result
+        end
+
+        def deserialize(data)
+          class_name = data[:_class]
+          raise UnauthorizedClassError, "Class '#{class_name}' is not allowed" unless Serializable.allowed_class?(class_name)
+
+          klass = Serializable.get_class(class_name)
+          instance = klass.allocate
+          instance.instance_variable_set(:@uuid, data[:uuid])
+
+          klass.serializable_attributes.each do |attr|
+            value = deserialize_value(data[attr])
+            instance.instance_variable_set("@#{attr}", value)
+          end
+
+          instance
+        end
+
+        def serialize_value(value)
+          if value.is_a?(Serializable) && value.respond_to?(:serializable_data)
+            { _class: value.class.name, **value.serializable_data }
+          elsif value.is_a?(Serializable) && value.respond_to?(:uuid)
+            { _class: value.class.name, _ref: value.uuid }
+          elsif value.is_a?(Hash)
+            { _class: "Hash", value: value.transform_values { |v| serialize_value(v) } }
+          elsif value.is_a?(Array)
+            { _class: "Array", value: value.map { |v| serialize_value(v) } }
+          elsif value.is_a?(Symbol)
+            { _class: "Symbol", value: value.to_s }
+          elsif value.is_a?(Vector)
+            { _class: "Vector", value: value.to_a }
+          elsif value.is_a?(Matrix)
+            { _class: "Matrix", value: value.to_a }
+          elsif value.is_a?(Engine::Quaternion)
+            { _class: "Engine::Quaternion", value: [value.w, value.x, value.y, value.z] }
+          else
+            { _class: value.class.name, value: value }
+          end
+        end
+
+        def deserialize_value(data)
+          return nil if data.nil?
+
+          class_name = data[:_class]
+
+          if data.key?(:_ref)
+            UnresolvedRef.new(data[:_ref], class_name)
+          elsif %w[String Integer Float TrueClass FalseClass NilClass].include?(class_name)
+            data[:value]
+          elsif class_name == "Symbol"
+            data[:value].to_sym
+          elsif class_name == "Vector"
+            Vector[*data[:value]]
+          elsif class_name == "Matrix"
+            Matrix[*data[:value]]
+          elsif class_name == "Engine::Quaternion"
+            Engine::Quaternion.new(*data[:value])
+          elsif class_name == "Hash"
+            data[:value].transform_values { |v| deserialize_value(v) }
+          elsif class_name == "Array"
+            data[:value].map { |v| deserialize_value(v) }
+          elsif Serializable.allowed_class?(class_name)
+            klass = Serializable.get_class(class_name)
+            if klass.respond_to?(:from_serializable_data)
+              klass.from_serializable_data(data)
+            else
+              deserialize(data)
+            end
+          else
+            raise UnauthorizedClassError, "Class '#{class_name}' is not allowed"
+          end
+        end
+      end
+    end
+  end
+end

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,119 +1,215 @@
-module Engine
-  class Shader
-    def self.default
-      @default ||= Shader.new('./shaders/mesh_vertex.glsl', './shaders/mesh_frag.glsl')
-    end
-
-    def self.vertex_lit
-      @vertex_lit ||= Engine::Shader.new('./shaders/vertex_lit_vertex.glsl', './shaders/vertex_lit_frag.glsl')
-    end
-
-    def self.skybox
-      @skybox ||= Shader.new('./shaders/skybox_vert.glsl', './shaders/skybox_frag.glsl')
-    end
-
-    def self.sprite
-      @sprite ||= Engine::Shader.new('./shaders/sprite_vertex.glsl', './shaders/sprite_frag.glsl')
-    end
-
-    def self.text
-      @text ||= Engine::Shader.new('./shaders/text_vertex.glsl', './shaders/text_frag.glsl')
-    end
-
-    def self.ui_text
-      @ui_text ||= Engine::Shader.new('./shaders/text_vertex.glsl', './shaders/text_frag.glsl')
-    end
-
-    def self.ui_sprite
-      @ui_sprite ||= Engine::Shader.new('./shaders/ui_sprite_vertex.glsl', './shaders/ui_sprite_frag.glsl')
-    end
-
-    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)
-
-      linked_buf = ' ' * 4
-      GL.GetProgramiv(@program, GL::LINK_STATUS, linked_buf)
-      linked = linked_buf.unpack('L')[0]
-      if linked == 0
-        compile_log = ' ' * 1024
-        GL.GetProgramInfoLog(@program, 1023, nil, compile_log)
-        vertex_log = ' ' * 1024
-        GL.GetShaderInfoLog(@vertex_shader, 1023, nil, vertex_log)
-        fragment_log = ' ' * 1024
-        GL.GetShaderInfoLog(@fragment_shader, 1023, nil, fragment_log)
-        puts "Shader program failed to link"
-        puts compile_log.strip
-        puts vertex_log.strip
-        puts fragment_log.strip
-      end
-      @uniform_cache = {}
-      @uniform_locations = {}
-    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
-    end
-
-    def use
-      GL.UseProgram(@program)
-    end
-
-    def set_vec3(name, vec)
-      return if @uniform_cache[name] == vec
-      @uniform_cache[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])
-    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])
-    end
-
-    def set_mat4(name, mat)
-      return if @uniform_cache[name] == mat
-      @uniform_cache[name] = mat
-      mat_array = [
-        mat[0, 0], mat[0, 1], mat[0, 2], mat[0, 3],
-        mat[1, 0], mat[1, 1], mat[1, 2], mat[1, 3],
-        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*'))
-    end
-
-    def set_int(name, int)
-      return if @uniform_cache[name] == int
-      @uniform_cache[name] = int
-      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)
-    end
-
-    private
-
-    def uniform_location(name)
-      @uniform_locations[name] ||= GL.GetUniformLocation(@program, name)
-    end
-  end
-end
+module Engine
+  class Shader
+    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
+      Engine::GL.GetProgramiv(@program, Engine::GL::LINK_STATUS, linked_buf)
+      linked = linked_buf.unpack('L')[0]
+      if linked == 0
+        compile_log = ' ' * 1024
+        Engine::GL.GetProgramInfoLog(@program, 1023, nil, compile_log)
+        vertex_log = ' ' * 1024
+        Engine::GL.GetShaderInfoLog(@vertex_shader, 1023, nil, vertex_log)
+        fragment_log = ' ' * 1024
+        Engine::GL.GetShaderInfoLog(@fragment_shader, 1023, nil, fragment_log)
+        puts "Shader program failed to link"
+        puts compile_log.strip
+        puts vertex_log.strip
+        puts fragment_log.strip
+      end
+      @uniform_cache = {}
+      @uniform_locations = {}
+    end
+
+    def compile_shader(shader, type)
+      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
+      Engine::GL.UseProgram(@program)
+    end
+
+    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
+      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
+      Engine::GL.Uniform4f(uniform_location(name), vec[0], vec[1], vec[2], vec[3])
+    end
+
+    def set_mat4(name, mat)
+      return if @uniform_cache[name] == mat
+      @uniform_cache[name] = mat
+      mat_array = [
+        mat[0, 0], mat[0, 1], mat[0, 2], mat[0, 3],
+        mat[1, 0], mat[1, 1], mat[1, 2], mat[1, 3],
+        mat[2, 0], mat[2, 1], mat[2, 2], mat[2, 3],
+        mat[3, 0], mat[3, 1], mat[3, 2], mat[3, 3]
+      ]
+      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
+      Engine::GL.Uniform1i(uniform_location(name), int)
+    end
+
+    def set_float(name, float)
+      return if @uniform_cache[name] == float
+      @uniform_cache[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] ||= 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;
-in vec4 ourColour;
-
-void main()
-{
-    FragColour = ourColour;
+#version 330 core
+
+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;
-
-uniform mat4 camera;
-uniform mat4 model;
-
-void main()
-{
-    gl_Position = camera * model * vec4(aPos, 1.0);
-    ourColour = vec4(colour, 1.0);
+#version 330 core
+
+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;
+
+out vec4 ourColour;
+out vec3 Normal;
+
+void main()
+{
+    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;
+}