ruby_rpg 0.0.5 → 0.1.0

data/lib/engine/shaders/vertex_lit_frag.glsl

@@ -1,89 +1,33 @@
-#version 330 core
-
-in vec3 Normal;
-in vec3 FragPos;
-
-in vec3 Diffuse;
-in vec3 Specular;
-in vec3 Albedo;
-
-out vec4 color;
-
-uniform vec3 cameraPos;
-uniform float diffuseStrength;
-uniform float specularStrength;
-uniform float specularPower;
-uniform vec3 ambientLight;
-
-struct DirectionalLight {
-    vec3 direction;
-    vec3 colour;
-};
-#define NR_DIRECTIONAL_LIGHTS 4
-uniform DirectionalLight directionalLights[NR_DIRECTIONAL_LIGHTS];
-
-struct PointLight {
-    vec3 position;
-    float sqrRange;
-    vec3 colour;
-};
-#define NR_POINT_LIGHTS 16
-uniform PointLight pointLights[NR_POINT_LIGHTS];
-
-vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
-{
-    vec3 lightOffset = light.position - fragPos;
-    float sqrDistance = dot(lightOffset, lightOffset);
-    vec3 lightDir = normalize(lightOffset);
-    float diff = max(dot(normal, lightDir), 0.0);
-
-    vec3 reflectDir = reflect(lightDir, normal);
-    float spec = pow(max(dot(-viewDir, reflectDir), 0.0), specularPower);
-
-    float attenuation = light.sqrRange / sqrDistance;
-
-    float diffuse = diff * diffuseStrength;
-    float specular = spec * specularStrength;
-
-    return light.colour * (diffuse + specular) * attenuation;
-}
-
-vec3 CalcDirectionalLight(DirectionalLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
-{
-    float diff = max(dot(normal, -light.direction), 0.0);
-
-    vec3 reflectDir = reflect(-light.direction, normal);
-    float spec = pow(max(dot(-viewDir, reflectDir), 0.0), specularPower);
-
-    float diffuse = diff * diffuseStrength;
-    float specular = spec * specularStrength;
-
-    return light.colour * (diffuse + specular);
-}
-
-void main()
-{
-    vec3 norm = normalize(Normal);
-    vec3 viewDir = normalize(cameraPos - FragPos);
-
-    vec3 result = ambientLight;
-
-    for (int i = 0; i < NR_POINT_LIGHTS; i++) {
-        if (pointLights[i].sqrRange == 0.0)
-        {
-            break;
-        }
-        result += CalcPointLight(pointLights[i], norm, FragPos, viewDir);
-    }
-
-    for (int i = 0; i < NR_DIRECTIONAL_LIGHTS; i++) {
-        if (directionalLights[i].colour == vec3(0.0))
-        {
-            break;
-        }
-        result += CalcDirectionalLight(directionalLights[i], norm, FragPos, viewDir);
-    }
-
-    vec4 c = vec4(Diffuse, 1.0);
-    color = c * vec4(result, 1.0);
-}
+#version 400 core
+
+in vec3 Normal;
+in vec3 FragPos;
+
+in vec3 Diffuse;
+in vec3 Specular;
+in vec3 Albedo;
+
+layout(location = 0) out vec4 FragColour;
+layout(location = 1) out vec4 normalRoughness;
+
+uniform vec3 cameraPos;
+uniform float roughness;
+uniform float diffuseStrength;
+uniform float specularStrength;
+uniform float specularPower;
+
+#include "lighting/lighting.glsl"
+
+void main()
+{
+    vec3 norm = normalize(Normal);
+    vec3 viewDir = normalize(cameraPos - FragPos);
+
+    vec3 result = CalcAllLights(norm, FragPos, viewDir, diffuseStrength, specularStrength, specularPower);
+
+    vec4 c = vec4(Diffuse, 1.0);
+    FragColour = c * vec4(result, 1.0);
+
+    // Output world-space normal (encoded to 0-1) and roughness in alpha
+    normalRoughness = vec4(norm * 0.5 + 0.5, roughness);
+}

data/lib/engine/shaders/vertex_lit_vertex.glsl

@@ -1,28 +1,28 @@
-#version 330 core
-
-// <vec2 position, vec2 texCoords, vec3 normal, vec3 tangent>
-layout (location = 0) in vec3 vertex;
-layout (location = 2) in vec3 normal;
-layout (location = 4) in vec3 diffuse;
-layout (location = 5) in vec3 specular;
-layout (location = 6) in vec3 albedo;
-layout (location = 7) in mat4 model;
-
-out vec3 Normal;
-out vec3 FragPos;
-out vec3 Diffuse;
-out vec3 Specular;
-out vec3 Albedo;
-
-uniform mat4 camera;
-
-void main()
-{
-    mat3 normalMatrix = mat3(transpose(inverse(model)));
-    Normal = normalMatrix * normal;
-    FragPos = vec3(model * vec4(vertex, 1.0));
-    gl_Position = camera * model * vec4(vertex, 1.0);
-    Diffuse = diffuse;
-    Specular = specular;
-    Albedo = albedo;
-}
+#version 400 core
+
+// <vec2 position, vec2 texCoords, vec3 normal, vec3 tangent>
+layout (location = 0) in vec3 vertex;
+layout (location = 2) in vec3 normal;
+layout (location = 4) in vec3 diffuse;
+layout (location = 5) in vec3 specular;
+layout (location = 6) in vec3 albedo;
+layout (location = 7) in mat4 model;
+
+out vec3 Normal;
+out vec3 FragPos;
+out vec3 Diffuse;
+out vec3 Specular;
+out vec3 Albedo;
+
+uniform mat4 camera;
+
+void main()
+{
+    mat3 normalMatrix = mat3(transpose(inverse(model)));
+    Normal = normalMatrix * normal;
+    FragPos = vec3(model * vec4(vertex, 1.0));
+    gl_Position = camera * model * vec4(vertex, 1.0);
+    Diffuse = diffuse;
+    Specular = specular;
+    Albedo = albedo;
+}

data/lib/engine/standard_meshes/quad_mesh.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Engine
+  class QuadMesh
+    # Vertex format: pos(3) + uv(2) + normal(3) + tangent(3) + bitangent(3) + extra(6) = 20 floats
+    def vertex_data
+      @vertex_data ||= [
+        # top-left
+        -0.5,  0.5, 0.0,   0.0, 0.0,   0.0, 0.0, 1.0,   1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 0.0,   0.0, 0.0, 0.0,
+        # top-right
+         0.5,  0.5, 0.0,   1.0, 0.0,   0.0, 0.0, 1.0,   1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 0.0,   0.0, 0.0, 0.0,
+        # bottom-right
+         0.5, -0.5, 0.0,   1.0, 1.0,   0.0, 0.0, 1.0,   1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 0.0,   0.0, 0.0, 0.0,
+        # bottom-left
+        -0.5, -0.5, 0.0,   0.0, 1.0,   0.0, 0.0, 1.0,   1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 0.0,   0.0, 0.0, 0.0,
+      ]
+    end
+
+    def index_data
+      @index_data ||= [
+        0, 2, 1,
+        2, 0, 3
+      ]
+    end
+  end
+end

data/lib/engine/standard_objects/cube.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Engine
+  module StandardObjects
+    module Cube
+      def self.create(pos: Vector[0, 0, 0], rotation: 0, scale: Vector[1, 1, 1], components: [], material: nil)
+        Engine::GameObject.create(
+          name: "Cube",
+          pos: pos,
+          rotation: rotation,
+          scale: scale,
+          components: [
+            Engine::Components::MeshRenderer.create(
+              mesh: Engine::Mesh.for("cube", source: :engine),
+              material: material || StandardObjects.default_material
+            ),
+            *components
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/engine/standard_objects/default_material.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Engine
+  module StandardObjects
+    def self.default_material
+      @default_material ||= begin
+        mat = Engine::Material.create(shader: Engine::Shader.default)
+        mat.set_vec3("baseColour", Vector[1.0, 1.0, 1.0])
+        mat.set_texture("image", nil)
+        mat.set_texture("normalMap", nil)
+        mat.set_float("diffuseStrength", 0.5)
+        mat.set_float("specularStrength", 0.5)
+        mat.set_float("specularPower", 32.0)
+        mat.set_vec3("ambientLight", Vector[0.02, 0.02, 0.02])
+        mat.set_float("roughness", 0.5)
+        mat
+      end
+    end
+  end
+end

data/lib/engine/standard_objects/plane.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Engine
+  module StandardObjects
+    module Plane
+      def self.create(pos: Vector[0, 0, 0], rotation: 0, scale: Vector[1, 1, 1], components: [], material: nil)
+        Engine::GameObject.create(
+          name: "Plane",
+          pos: pos,
+          rotation: rotation,
+          scale: scale,
+          components: [
+            Engine::Components::MeshRenderer.create(
+              mesh: Engine::Mesh.for("plane", source: :engine),
+              material: material || StandardObjects.default_material
+            ),
+            *components
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/engine/standard_objects/sphere.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Engine
+  module StandardObjects
+    module Sphere
+      def self.create(pos: Vector[0, 0, 0], rotation: 0, scale: Vector[1, 1, 1], components: [], material: nil)
+        Engine::GameObject.create(
+          name: "Sphere",
+          pos: pos,
+          rotation: rotation,
+          scale: scale,
+          components: [
+            Engine::Components::MeshRenderer.create(
+              mesh: Engine::Mesh.for("sphere", source: :engine),
+              material: material || StandardObjects.default_material
+            ),
+            *components
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/engine/tangent_calculator.rb

@@ -1,42 +1,42 @@
-# frozen_string_literal: true
-
-module Engine
-  class TangentCalculator
-    attr_reader :vertices, :normals, :texture_coords
-
-    def initialize(vertices, normals, texture_coords)
-      @vertices = vertices
-      @normals = normals
-      @texture_coords = texture_coords
-    end
-
-    def calculate_tangents
-      delta_pos1 = @vertices[1] - @vertices[0]
-      delta_pos2 = @vertices[2] - @vertices[0]
-
-      delta_uv1 = @texture_coords[1] - @texture_coords[0]
-      delta_uv2 = @texture_coords[2] - @texture_coords[0]
-
-      if delta_uv1[0] * delta_uv2[1] - delta_uv1[1] * delta_uv2[0] == 0
-        return normals.map { |normal| Vector[0, 0, 0] }
-      end
-
-      uv_matrix = Matrix[
-        [delta_uv1[0], delta_uv1[1]],
-        [delta_uv2[0], delta_uv2[1]]
-      ]
-
-      world_matrix = Matrix[
-        [delta_pos1[0], delta_pos1[1], delta_pos1[2]],
-        [delta_pos2[0], delta_pos2[1], delta_pos2[2]]
-      ]
-
-      tangent_matrix = uv_matrix.inv * world_matrix
-
-      flat_tangent = Vector[tangent_matrix[0, 0], tangent_matrix[0, 1], tangent_matrix[0, 2]]
-      bitangents = normals.map { |normal| normal.cross(flat_tangent).normalize }
-
-      normals.map { |normal| bitangents[0].cross(normal).normalize }
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  class TangentCalculator
+    attr_reader :vertices, :normals, :texture_coords
+
+    def initialize(vertices, normals, texture_coords)
+      @vertices = vertices
+      @normals = normals
+      @texture_coords = texture_coords
+    end
+
+    def calculate_tangents
+      delta_pos1 = @vertices[1] - @vertices[0]
+      delta_pos2 = @vertices[2] - @vertices[0]
+
+      delta_uv1 = @texture_coords[1] - @texture_coords[0]
+      delta_uv2 = @texture_coords[2] - @texture_coords[0]
+
+      if delta_uv1[0] * delta_uv2[1] - delta_uv1[1] * delta_uv2[0] == 0
+        return normals.map { |normal| Vector[0, 0, 0] }
+      end
+
+      uv_matrix = Matrix[
+        [delta_uv1[0], delta_uv1[1]],
+        [delta_uv2[0], delta_uv2[1]]
+      ]
+
+      world_matrix = Matrix[
+        [delta_pos1[0], delta_pos1[1], delta_pos1[2]],
+        [delta_pos2[0], delta_pos2[1], delta_pos2[2]]
+      ]
+
+      tangent_matrix = uv_matrix.inv * world_matrix
+
+      flat_tangent = Vector[tangent_matrix[0, 0], tangent_matrix[0, 1], tangent_matrix[0, 2]]
+      bitangents = normals.map { |normal| normal.cross(flat_tangent).normalize }
+
+      normals.map { |normal| bitangents[0].cross(normal).normalize }
+    end
+  end
+end

data/lib/engine/texture.rb

@@ -1,53 +1,62 @@
-require 'chunky_png'
-
-module Engine
-  class Texture
-    attr_reader :texture
-    private_class_method :new
-
-    def initialize(file_path, flip)
-      @file_path = file_path
-      @flip = flip
-      @texture = ' ' * 4
-      load_texture
-    end
-
-    def self.for(path, flip: false)
-      full_path = File.expand_path(File.join(GAME_DIR, path))
-      texture_cache[[full_path, flip]]
-    end
-
-    def self.texture_cache
-      @texture_cache ||= Hash.new do |hash, key|
-        hash[key] = new(key[0], key[1])
-      end
-    end
-
-    def load_texture
-      tex = ' ' * 4
-      GL.GenTextures(1, tex)
-      @texture = tex.unpack('L')[0]
-      GL.BindTexture(GL::TEXTURE_2D, @texture)
-      GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_S, GL::REPEAT)
-      GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_T, GL::REPEAT)
-      GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MIN_FILTER, GL::LINEAR)
-      GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
-
-      image = read_image
-      image_data = image.to_rgba_stream
-      image_width = image.width
-      image_height = image.height
-
-      GL.TexImage2D(GL::TEXTURE_2D, 0, GL::RGBA32F, image_width, image_height, 0, GL::RGBA, GL::UNSIGNED_BYTE, image_data)
-      GL.GenerateMipmap(GL::TEXTURE_2D)
-    end
-
-    def read_image
-      if @flip
-        ChunkyPNG::Image.from_file(@file_path).flip_horizontally
-      else
-        ChunkyPNG::Image.from_file(@file_path)
-      end
-    end
-  end
-end
+require 'chunky_png'
+
+module Engine
+  class Texture
+    include Serializable
+
+    attr_reader :texture, :source
+
+    def self.from_serializable_data(data)
+      self.for(data[:path], flip: data[:flip] || false, source: (data[:source] || :game).to_sym)
+    end
+
+    def serializable_data
+      { path: @relative_path, flip: @flip, source: @source }
+    end
+
+    def awake
+      @texture = ' ' * 4
+      load_texture
+    end
+
+    def self.for(path, flip: false, source: :game)
+      full_path = if source == :engine
+        File.expand_path(File.join(ENGINE_DIR, "assets", path))
+      else
+        File.expand_path(File.join(GAME_DIR, path))
+      end
+      texture_cache[[path, flip, source]] ||= create(relative_path: path, file_path: full_path, flip: flip, source: source)
+    end
+
+    def self.texture_cache
+      @texture_cache ||= {}
+    end
+
+    def load_texture
+      tex = ' ' * 4
+      Engine::GL.GenTextures(1, tex)
+      @texture = tex.unpack('L')[0]
+      Engine::GL.BindTexture(Engine::GL::TEXTURE_2D, @texture)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_WRAP_S, Engine::GL::REPEAT)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_WRAP_T, Engine::GL::REPEAT)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MIN_FILTER, Engine::GL::LINEAR)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MAG_FILTER, Engine::GL::LINEAR)
+
+      image = read_image
+      image_data = image.to_rgba_stream
+      image_width = image.width
+      image_height = image.height
+
+      Engine::GL.TexImage2D(Engine::GL::TEXTURE_2D, 0, Engine::GL::RGBA32F, image_width, image_height, 0, Engine::GL::RGBA, Engine::GL::UNSIGNED_BYTE, image_data)
+      Engine::GL.GenerateMipmap(Engine::GL::TEXTURE_2D)
+    end
+
+    def read_image
+      if @flip
+        ChunkyPNG::Image.from_file(@file_path).flip_horizontally
+      else
+        ChunkyPNG::Image.from_file(@file_path)
+      end
+    end
+  end
+end

data/lib/engine/ui/rect.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Engine
+  module UI
+    Rect = Struct.new(:left, :bottom, :right, :top, keyword_init: true) do
+      def width
+        right - left
+      end
+
+      def height
+        # Y-down: bottom > top
+        bottom - top
+      end
+    end
+  end
+end

data/lib/engine/video_mode.rb

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-module Engine
-  # https://www.glfw.org/docs/latest/struct_g_l_f_wvidmode.html
-  # https://www.glfw.org/docs/latest/monitor_guide.html#monitor_modes
-  class VideoMode
-    class << self
-      def current_video_mode(monitor: Window.primary_monitor)
-        video_mode_helper(GLFW.GetVideoMode(monitor), 0)
-      end
-
-      # Returns an array of video modes
-      def get_video_modes(monitor: Window.primary_monitor)
-        count_pointer = ' ' * Fiddle::SIZEOF_INT
-        modes_pointer = GLFW.GetVideoModes(monitor, count_pointer)
-        count = count_pointer.unpack1('L')
-
-        supported_video_modes = []
-        count.times do |i|
-          supported_video_modes << video_mode_helper(modes_pointer, i)
-        end
-        supported_video_modes
-      end
-
-      def print_video_mode(mode)
-        GLFW::GLFWvidmode.members.map(&:to_sym).map do |attr|
-          puts "#{attr}: #{mode.send(attr)}"
-        end
-        puts
-      end
-
-      def video_mode_helper(mode_pointer, index)
-        GLFW::GLFWvidmode.new(mode_pointer + index * GLFW::GLFWvidmode.size)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  # https://www.glfw.org/docs/latest/struct_g_l_f_wvidmode.html
+  # https://www.glfw.org/docs/latest/monitor_guide.html#monitor_modes
+  class VideoMode
+    class << self
+      def current_video_mode(monitor: Window.primary_monitor)
+        video_mode_helper(GLFW.GetVideoMode(monitor), 0)
+      end
+
+      # Returns an array of video modes
+      def get_video_modes(monitor: Window.primary_monitor)
+        count_pointer = ' ' * Fiddle::SIZEOF_INT
+        modes_pointer = GLFW.GetVideoModes(monitor, count_pointer)
+        count = count_pointer.unpack1('L')
+
+        supported_video_modes = []
+        count.times do |i|
+          supported_video_modes << video_mode_helper(modes_pointer, i)
+        end
+        supported_video_modes
+      end
+
+      def print_video_mode(mode)
+        GLFW::GLFWvidmode.members.map(&:to_sym).map do |attr|
+          puts "#{attr}: #{mode.send(attr)}"
+        end
+        puts
+      end
+
+      def video_mode_helper(mode_pointer, index)
+        GLFW::GLFWvidmode.new(mode_pointer + index * GLFW::GLFWvidmode.size)
+      end
+    end
+  end
+end