ruby_rpg 0.0.4 → 0.0.5

data/lib/engine/shaders/vertex_lit_frag.glsl

@@ -1,89 +1,89 @@
-#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 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);
+}

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 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;
+}

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,53 @@
-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::RGBA, 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
+    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

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