ruby_rpg 0.0.1 → 0.0.3

data/lib/engine/rendering/instance_renderer.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Rendering
+  class InstanceRenderer
+    attr_reader :mesh, :material
+
+    def initialize(mesh, material)
+      @mesh = mesh
+      @material = material
+      @mesh_renderers = []
+      @mesh_matrix_data = []
+
+      setup_vertex_attribute_buffer
+      setup_vertex_buffer
+      setup_index_buffer
+      generate_instance_vbo_buf
+    end
+
+    def add_instance(mesh_renderer)
+      @mesh_renderers << mesh_renderer
+      @mesh_matrix_data += mesh_renderer.game_object.model_matrix.to_a.flatten
+    end
+
+    def remove_instance(mesh_renderer)
+      index = @mesh_renderers.index(mesh_renderer)
+      @mesh_renderers.delete_at(index)
+      @mesh_matrix_data[index * 16, 16] = []
+    end
+
+    def update_instance(mesh_renderer)
+      index = @mesh_renderers.index(mesh_renderer)
+      @mesh_matrix_data[index * 16, 16] = mesh_renderer.game_object.model_matrix.to_a.flatten
+    end
+
+    def draw_all
+      set_material_per_frame_data
+
+      GL.BindVertexArray(@vao)
+      update_vbo_buf
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      GL.BindBuffer(GL::ARRAY_BUFFER, @instance_vbo)
+
+      GL.DrawElementsInstanced(GL::TRIANGLES, mesh.index_data.length, GL::UNSIGNED_INT, 0, @mesh_renderers.count)
+      GL.BindVertexArray(0)
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, 0)
+    end
+
+    private
+
+    def set_material_per_frame_data
+      material.set_mat4("camera", Engine::Camera.instance.matrix)
+      material.set_vec3("cameraPos", Engine::Camera.instance.game_object.pos)
+
+      update_light_data
+      material.update_shader
+    end
+
+    def update_light_data
+      Engine::Components::PointLight.point_lights.each_with_index do |light, i|
+        material.set_float("pointLights[#{i}].sqrRange", light.range * light.range)
+        material.set_vec3("pointLights[#{i}].position", light.game_object.pos)
+        material.set_vec3("pointLights[#{i}].colour", light.colour)
+      end
+      Engine::Components::DirectionLight.direction_lights.each_with_index do |light, i|
+        material.set_vec3("directionalLights[#{i}].direction", light.game_object.forward)
+        material.set_vec3("directionalLights[#{i}].colour", light.colour)
+      end
+    end
+
+    def setup_index_buffer
+      indices = mesh.index_data
+
+      ebo_buf = ' ' * 4
+      GL.GenBuffers(1, ebo_buf)
+      @ebo = ebo_buf.unpack('L')[0]
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      GL.BufferData(
+        GL::ELEMENT_ARRAY_BUFFER, indices.length * Fiddle::SIZEOF_INT,
+        indices.pack('I*'), GL::STATIC_DRAW
+      )
+    end
+
+    def setup_vertex_attribute_buffer
+      vao_buf = ' ' * 4
+      GL.GenVertexArrays(1, vao_buf)
+      @vao = vao_buf.unpack('L')[0]
+      GL.BindVertexArray(@vao)
+    end
+
+    def setup_vertex_buffer
+      vbo_buf = ' ' * 4
+      GL.GenBuffers(1, vbo_buf)
+      vbo = vbo_buf.unpack('L')[0]
+      points = mesh.vertex_data
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, vbo)
+      GL.BufferData(
+        GL::ARRAY_BUFFER, @mesh.vertex_data.length * Fiddle::SIZEOF_FLOAT,
+        points.pack('F*'), GL::STATIC_DRAW
+      )
+      vertex_data_size = 20 * Fiddle::SIZEOF_FLOAT
+
+      GL.VertexAttribPointer(0, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 0)
+      GL.VertexAttribPointer(1, 2, GL::FLOAT, GL::FALSE, vertex_data_size, 3 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(2, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 5 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(3, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 8 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(4, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 11 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(5, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 14 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(6, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 17 * Fiddle::SIZEOF_FLOAT)
+      GL.EnableVertexAttribArray(0)
+      GL.EnableVertexAttribArray(1)
+      GL.EnableVertexAttribArray(2)
+      GL.EnableVertexAttribArray(3)
+      GL.EnableVertexAttribArray(4)
+      GL.EnableVertexAttribArray(5)
+      GL.EnableVertexAttribArray(6)
+    end
+
+    def generate_instance_vbo_buf
+      instance_vbo_buf = ' ' * 4
+      GL.GenBuffers(1, instance_vbo_buf)
+      @instance_vbo = instance_vbo_buf.unpack('L')[0]
+      update_vbo_buf
+    end
+
+    def update_vbo_buf
+      vertex_data = @mesh_matrix_data
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, @instance_vbo)
+      GL.BufferData(
+        GL::ARRAY_BUFFER, vertex_data.length * Fiddle::SIZEOF_FLOAT,
+        vertex_data.pack('F*'), GL::STATIC_DRAW
+      )
+
+      vec4_size = Fiddle::SIZEOF_FLOAT * 4
+
+      GL.EnableVertexAttribArray(7)
+      GL.EnableVertexAttribArray(8)
+      GL.EnableVertexAttribArray(9)
+      GL.EnableVertexAttribArray(10)
+
+      GL.VertexAttribPointer(7, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 0)
+      GL.VertexAttribPointer(8, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 1 * vec4_size)
+      GL.VertexAttribPointer(9, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 2 * vec4_size)
+      GL.VertexAttribPointer(10, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 3 * vec4_size)
+
+      GL.VertexAttribDivisor(7, 1)
+      GL.VertexAttribDivisor(8, 1)
+      GL.VertexAttribDivisor(9, 1)
+      GL.VertexAttribDivisor(10, 1)
+    end
+  end
+end

data/lib/engine/rendering/render_pipeline.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rendering
+  module RenderPipeline
+    def self.draw
+      Engine::GameObject.mesh_renderers.each do |mesh_renderer|
+        mesh_renderer.update(0)
+      end
+
+      instance_renderers.values.each do |renderer|
+        renderer.draw_all
+      end
+    end
+
+    def self.add_instance(mesh_renderer)
+      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].add_instance(mesh_renderer)
+    end
+
+    def self.remove_instance(mesh_renderer)
+      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].remove_instance(mesh_renderer)
+    end
+
+    def self.update_instance(mesh_renderer)
+      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].update_instance(mesh_renderer)
+    end
+
+    private
+
+    def self.instance_renderers
+      @instance_renderers ||= Hash.new do |hash, key|
+        hash[key] = InstanceRenderer.new(key[0], key[1])
+      end
+    end
+  end
+end

data/lib/engine/screenshoter.rb

@@ -0,0 +1,34 @@
+module Engine
+  class Screenshoter
+    def self.screenshot(&block)
+      @after_screenshot = block
+    end
+
+    def self.scheduled_screenshot
+      @after_screenshot != nil
+    end
+
+    def self.take_screenshot
+      @scheduled_screenshot = nil
+      width = Engine::Window.framebuffer_width
+      height = Engine::Window.framebuffer_height
+      pixels = ' ' * (width * height * 3)
+      GL.ReadPixels(0, 0, width, height, GL::RGB, GL::UNSIGNED_BYTE, pixels)
+      png = ChunkyPNG::Image.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+      pixels = pixels.bytes.map { |b| b.to_i }
+      x = 0
+      y = 0
+      pixels.each_slice(3) do |r, g, b|
+        png[x, height - y - 1] = ChunkyPNG::Color.rgb(r, g, b)
+        x += 1
+        if x >= width
+          x = 0
+          y += 1
+        end
+      end
+      block = @after_screenshot
+      @after_screenshot = nil
+      block.call(png)
+    end
+  end
+end

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