ruby_rpg 0.0.4 → 0.0.5

data/lib/engine/rendering/instance_renderer.rb

@@ -1,153 +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
+# 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

@@ -1,35 +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
+# 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

@@ -1,34 +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
+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

@@ -1,91 +1,119 @@
-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
+module Engine
+  class Shader
+    def self.default
+      @default ||= Shader.new('./shaders/mesh_vertex.glsl', './shaders/mesh_frag.glsl')
+    end
+
+    def self.vertex_lit
+      @vertex_lit ||= Engine::Shader.new('./shaders/vertex_lit_vertex.glsl', './shaders/vertex_lit_frag.glsl')
+    end
+
+    def self.skybox
+      @skybox ||= Shader.new('./shaders/skybox_vert.glsl', './shaders/skybox_frag.glsl')
+    end
+
+    def self.sprite
+      @sprite ||= Engine::Shader.new('./shaders/sprite_vertex.glsl', './shaders/sprite_frag.glsl')
+    end
+
+    def self.text
+      @text ||= Engine::Shader.new('./shaders/text_vertex.glsl', './shaders/text_frag.glsl')
+    end
+
+    def self.ui_text
+      @ui_text ||= Engine::Shader.new('./shaders/text_vertex.glsl', './shaders/text_frag.glsl')
+    end
+
+    def self.ui_sprite
+      @ui_sprite ||= Engine::Shader.new('./shaders/ui_sprite_vertex.glsl', './shaders/ui_sprite_frag.glsl')
+    end
+
+    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