ruby_rpg 0.0.1 → 0.0.3

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,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

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

data/lib/engine/window.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Engine
+  class Window
+
+    DEFAULT_TITLE = File.basename($PROGRAM_NAME).gsub(/\.rb$/,'')
+
+    class << self
+      attr_accessor :full_screen, :window, :window_title
+      attr_reader :framebuffer_height, :framebuffer_width
+
+      def create_window
+        set_opengl_version
+        decorations :disable
+        auto_iconify :disable
+        @full_screen = true
+        initial_video_mode = VideoMode.current_video_mode
+        @window = GLFW.CreateWindow(
+          initial_video_mode.width, initial_video_mode.height, DEFAULT_TITLE, primary_monitor, nil
+        )
+      end
+
+      alias full_screen? full_screen
+
+      def width
+        max_width = VideoMode.current_video_mode.width
+        @width = full_screen? ? max_width : max_width * 0.8
+      end
+
+      def height
+        max_height = VideoMode.current_video_mode.height
+        @height = full_screen? ? max_height : max_height * 0.8
+      end
+
+      def monitor
+        full_screen? ? primary_monitor : nil
+      end
+
+      def set_title(title)
+        GLFW::SetWindowTitle(window, title)
+      end
+
+      def primary_monitor
+        # The primary monitor is returned by glfwGetPrimaryMonitor.
+        # It is the user's preferred monitor and is usually the one with global UI elements like task bar or menu bar.
+        # https://www.glfw.org/docs/latest/monitor_guide.html#monitor_monitors
+        GLFW.GetPrimaryMonitor
+      end
+
+      def refresh_rate
+        # GLFW_REFRESH_RATE specifies the desired refresh rate for full screen windows.
+        # A value of GLFW_DONT_CARE means the highest available refresh rate will be used.
+        # This hint is ignored for windowed mode windows.
+        # https://www.glfw.org/docs/latest/window_guide.html#GLFW_REFRESH_RATE
+        GLFW::DONT_CARE
+      end
+
+      def decorations(state)
+        # GLFW_DECORATED specifies whether the windowed mode window will have window decorations such as a border,
+        # a close widget, etc.
+        # An undecorated window will not be resizable by the user but will still allow the user to generate close events
+        # on some platforms.
+        # Possible values are GLFW_TRUE and GLFW_FALSE.
+        # This hint is ignored for full screen windows.
+        # https://www.glfw.org/docs/latest/window_guide.html#GLFW_DECORATED_attrib
+        glfw_setting = translate_state[state]
+
+        GLFW.WindowHint(GLFW::DECORATED, glfw_setting)
+        GLFW.SetWindowAttrib(window, GLFW::DECORATED, glfw_setting) if window
+      end
+
+      def auto_iconify(state)
+        # GLFW_AUTO_ICONIFY specifies whether the full screen window will automatically iconify and restore the previous
+        # video mode on input focus loss.
+        # Possible values are GLFW_TRUE and GLFW_FALSE.
+        # This hint is ignored for windowed mode windows.
+        # https://www.glfw.org/docs/latest/window_guide.html#GLFW_AUTO_ICONIFY_hint
+        glfw_setting = translate_state[state]
+
+        GLFW.WindowHint(GLFW::AUTO_ICONIFY, glfw_setting)
+        GLFW.SetWindowAttrib(window, GLFW::AUTO_ICONIFY, glfw_setting) if window
+      end
+
+      def set_to_windowed
+        @full_screen = false
+        GLFW.SetWindowMonitor(window, nil, 0, 0, width, height, refresh_rate)
+      end
+
+      def set_to_full_screen
+        @full_screen = true
+        GLFW.SetWindowMonitor(window, primary_monitor, 0, 0, width, height, refresh_rate)
+      end
+
+      def toggle_full_screen
+        full_screen? ? set_to_windowed : set_to_full_screen
+      end
+
+      def focus_window
+        GLFW.FocusWindow(window)
+      end
+
+      def get_framebuffer_size
+        width_buf = ' ' * 8
+        height_buf = ' ' * 8
+
+        GLFW.GetFramebufferSize(window, width_buf, height_buf)
+        @framebuffer_width = width_buf.unpack1('L')
+        @framebuffer_height = height_buf.unpack1('L')
+      end
+
+      def set_opengl_version
+        GLFW.WindowHint(GLFW::CONTEXT_VERSION_MAJOR, 3)
+        GLFW.WindowHint(GLFW::CONTEXT_VERSION_MINOR, 3)
+        GLFW.WindowHint(GLFW::OPENGL_PROFILE, GLFW::OPENGL_CORE_PROFILE)
+        GLFW.WindowHint(GLFW::OPENGL_FORWARD_COMPAT, GLFW::TRUE)
+      end
+
+      def translate_state
+        {
+          :enable   => GLFW::TRUE,
+          :disable  => GLFW::FALSE
+        }
+      end
+    end
+  end
+end

data/lib/ruby_rpg.rb

@@ -1,3 +1,56 @@
 # frozen_string_literal: true
 
+require 'opengl'
+require 'glfw'
+require 'concurrent'
+require 'os'
+require 'native_audio'
+
+require_relative 'engine/autoloader'
+require_relative "engine/debugging"
+require_relative 'engine/rendering/render_pipeline'
+require_relative 'engine/rendering/instance_renderer'
+require_relative 'engine/screenshoter'
+require_relative 'engine/input'
+require_relative "engine/quaternion"
+require_relative 'engine/game_object'
+require_relative 'engine/texture'
+require_relative 'engine/material'
+require_relative 'engine/mesh'
+require_relative "engine/font"
+require_relative 'engine/path'
+require_relative 'engine/polygon_mesh'
+require_relative 'engine/importers/obj_file'
+require_relative 'engine/tangent_calculator'
+require_relative 'engine/shader'
+require_relative 'engine/component'
+require_relative "engine/camera"
+require_relative "engine/window"
+require_relative "engine/video_mode"
+require_relative "engine/cursor"
+
+require_relative "engine/components/orthographic_camera"
+require_relative "engine/components/perspective_camera"
+require_relative "engine/components/sprite_renderer"
+require_relative "engine/components/ui_sprite_renderer"
+require_relative "engine/components/mesh_renderer"
+require_relative "engine/components/font_renderer"
+require_relative "engine/components/ui_font_renderer"
+require_relative "engine/components/point_light"
+require_relative "engine/components/direction_light"
+require_relative "engine/components/audio_source"
+
+require_relative "engine/physics/physics_resolver"
+require_relative 'engine/physics/collision'
+require_relative "engine/physics/components/sphere_collider"
+require_relative "engine/physics/components/cube_collider"
+require_relative "engine/physics/components/rigidbody"
+
+if OS.windows?
+  GLFW.load_lib(File.expand_path(File.join(__dir__, "..", "glfw-3.4.bin.WIN64", "lib-static-ucrt", "glfw3.dll")))
+elsif OS.mac?
+  GLFW.load_lib(File.expand_path(File.join(__dir__, "..", "glfw-3.3.9.bin.MACOS", "lib-arm64", "libglfw.3.dylib")))
+end
+GLFW.Init
+
 require_relative 'engine/engine'