ruby_rpg 0.0.1 → 0.0.2

data/lib/engine/shader.rb

@@ -0,0 +1,91 @@
+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)
+
+      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

data/lib/engine/shaders/colour_frag.glsl

@@ -0,0 +1,9 @@
+#version 330 core
+
+out vec4 FragColour;
+in vec4 ourColour;
+
+void main()
+{
+    FragColour = ourColour;
+}

data/lib/engine/shaders/colour_vertex.glsl

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

data/lib/engine/shaders/mesh_frag.glsl

@@ -0,0 +1,102 @@
+#version 330 core
+
+in vec2 TexCoord;
+in vec3 Normal;
+in vec3 Tangent;
+in vec3 FragPos;
+
+out vec4 color;
+
+uniform sampler2D image;
+uniform sampler2D normalMap;
+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 sampledNormal = texture(normalMap, TexCoord).rgb * 2.0 - 1.0;
+    if ( sampledNormal.r + sampledNormal.g + sampledNormal.b <= 0)
+    {
+        sampledNormal = vec3(0.0, 0.0, 1.0);
+    }
+    vec3 n = normalize(Normal);
+    vec3 t = normalize(Tangent);
+    vec3 norm = n;
+    if ( length(t) > 0.0 )
+    {
+        vec3 b = cross(t, n);
+        mat3 TBN = mat3(t, b, n);
+        norm = normalize(TBN * normalize(sampledNormal));
+    }
+    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 tex = texture(image, TexCoord);
+    color = tex * vec4(result, 1.0);
+}

data/lib/engine/shaders/mesh_vertex.glsl

@@ -0,0 +1,25 @@
+#version 330 core
+
+// <vec2 position, vec2 texCoords, vec3 normal, vec3 tangent>
+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;
+
+out vec2 TexCoord;
+out vec3 Normal;
+out vec3 Tangent;
+out vec3 FragPos;
+
+uniform mat4 camera;
+
+void main()
+{
+    TexCoord = texCoord;
+    mat3 normalMatrix = mat3(transpose(inverse(model)));
+    Normal = normalMatrix * normal;
+    Tangent = normalMatrix * tangent;
+    FragPos = vec3(model * vec4(vertex, 1.0));
+    gl_Position = camera * model * vec4(vertex, 1.0);
+}

data/lib/engine/shaders/skybox_frag.glsl

@@ -0,0 +1,12 @@
+#version 330 core
+
+in vec3 FragPos;
+out vec4 color;
+
+void main()
+{
+    vec4 ground = vec4(0.541176, 0.709804, 0.286275, 1);
+    vec4 sky = vec4(0.2, 0.6, 0.8, 1);
+    float mixFactor = clamp(FragPos.y / 2.0, 0.0, 1.0);
+    color = mix(ground, sky, mixFactor);
+}

data/lib/engine/shaders/skybox_vert.glsl

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

data/lib/engine/shaders/sprite_frag.glsl

@@ -0,0 +1,17 @@
+#version 330 core
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D image;
+uniform vec3 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 = vec4(spriteColor, 1.0) * texColor;
+}

data/lib/engine/shaders/sprite_vertex.glsl

@@ -0,0 +1,16 @@
+#version 330 core
+
+// <vec3 position, vec2 texCoords>
+layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoord;
+
+out vec2 TexCoords;
+
+uniform mat4 camera;
+uniform mat4 model;
+
+void main()
+{
+    TexCoords = texCoord;
+    gl_Position = camera * model * vec4(vertex, 1.0);
+}

data/lib/engine/shaders/text_frag.glsl

@@ -0,0 +1,15 @@
+#version 330 core
+
+out vec4 color;
+
+in vec2 TexCoords;
+
+uniform sampler2D fontTexture;
+
+void main()
+{
+    vec4 textureColor = texture(fontTexture, TexCoords);
+    if(textureColor.a < 0.1)
+        discard;
+    color = vec4(1.0, 1.0, 1.0, textureColor.a);
+}

data/lib/engine/shaders/text_vertex.glsl

@@ -0,0 +1,31 @@
+#version 330 core
+
+// <vec3 position, vec2 texCoords>
+layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoords;
+layout (location = 2) in int textIndex;
+layout (location = 3) in vec2 offset;
+
+uniform mat4 camera;
+uniform mat4 model;
+
+out vec2 TexCoords;
+
+vec2 getTexCoords()
+{
+    int x = textIndex / 16;
+    int y = textIndex % 16;
+    return (vec2(x, y) + texCoords) / 16.0;
+}
+
+vec3 quadPosition()
+{
+    return vertex + vec3(offset.x, offset.y, 0);
+}
+
+
+void main()
+{
+    gl_Position = camera * model * vec4(quadPosition(), 1.0);
+    TexCoords = getTexCoords();
+}

data/lib/engine/shaders/ui_sprite_frag.glsl

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

data/lib/engine/shaders/ui_sprite_vertex.glsl

@@ -0,0 +1,16 @@
+#version 330 core
+
+// <vec3 position, vec2 texCoords>
+layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoord;
+
+out vec2 TexCoords;
+
+uniform mat4 camera;
+uniform mat4 model;
+
+void main()
+{
+    TexCoords = texCoord;
+    gl_Position = camera * model * vec4(vertex, 1.0);
+}

data/lib/engine/shaders/vertex_lit_frag.glsl

@@ -0,0 +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);
+}

data/lib/engine/shaders/vertex_lit_vertex.glsl

@@ -0,0 +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;
+}

data/lib/engine/tangent_calculator.rb

@@ -0,0 +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

data/lib/engine/texture.rb

@@ -0,0 +1,52 @@
+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(file_path, flip: false)
+      texture_cache[[file_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

data/lib/engine/video_mode.rb

@@ -0,0 +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