rgss 0.0.1

data/lib/rgss.rb

@@ -0,0 +1,140 @@
+
+module RGSS
+
+  require 'logger'
+
+  Log = Logger.new(STDOUT)
+
+  Log.formatter = proc do |severity, datetime, progname, msg|
+
+    time = datetime.strftime('%H:%M:%S')
+    prefix = case severity
+    when 'DEBUG' then "\33[1;35mDEBUG\33[0m"
+    when 'INFO' then "\33[1;32mINFO\33[0m"
+    when 'WARN' then "\33[1;33mWARN\33[0m"
+    when 'ERROR' then "\33[1;31mERROR\33[0m"
+    when 'FATAL' then "\33[1;31mFATAL\33[0m"
+    else "LOG"
+    end
+    "#{time} [#{prefix}] #{msg}\n"
+  end
+end
+
+require_relative 'rgss/version'
+require_relative 'rgss/rgss'
+
+require_relative 'rgss/game_object'
+require_relative 'rgss/shader'
+require_relative 'rgss/texture'
+
+require_relative 'rgss/blend'
+require_relative 'rgss/batch'
+require_relative 'rgss/renderable'
+require_relative 'rgss/sprite'
+require_relative 'rgss/viewport'
+require_relative 'rgss/plane'
+
+
+module RGSS
+
+
+  module Game
+
+    SPEED = 8
+
+    def self.update(delta)
+
+      $sprite.cy += 1 if Game.ticks % 8 == 0
+
+      $v.y -= SPEED if Input.press?(:UP)
+      $v.y += SPEED if Input.press?(:DOWN)
+      $v.x -= SPEED if Input.press?(:LEFT)
+      $v.x += SPEED if Input.press?(:RIGHT)
+      $fog.zoom += vec2(0.05) if Input.press?(:RAISE)
+      $fog.zoom -= vec2(0.05) if Input.press?(:LOWER)
+
+      $sprite.update(delta)
+      $v.update(delta)
+      $fog.update(delta)
+    
+      if Input.trigger?(:FULLSCREEN)
+        p Graphics.fps
+        p $v.position
+      end
+
+      if Input.press?(:QUIT)
+        Game.close(true)
+      end
+    end
+  end
+
+  module Graphics
+
+    def self.render(state)
+      @batch.each { |obj| obj.render(state) }
+    end
+  end
+
+
+  Game.create(256, 256, "RGSS", resizable: true, vsync: true)
+  Graphics.back_color = Color::CORNFLOWER_BLUE
+
+
+  Game.icon = '/storage/images/anvil.png'
+
+  Input.bind(:UP, [Input::KEY_W, Input::KEY_UP])
+  Input.bind(:LEFT, [Input::KEY_A, Input::KEY_LEFT])
+  Input.bind(:DOWN, [Input::KEY_S, Input::KEY_DOWN])
+  Input.bind(:RIGHT, [Input::KEY_D, Input::KEY_RIGHT])
+
+  Input.bind(:RAISE, Input::KEY_Q)
+  Input.bind(:LOWER, Input::KEY_E)
+
+  Input.bind(:CONFIRM, Input::KEY_SPACE)
+  Input.bind(:FULLSCREEN, Input::KEY_F)
+  Input.bind(:QUIT, Input::KEY_ESCAPE)
+
+  Input.cursor_image('/home/eric/Desktop/cursor.png')
+  $v = Viewport.new(1, 1, 128, 128)
+  $v.back_color = Color::BLACK
+
+  $v.angle = 23
+  
+  $fog = Plane.new
+  $fog.texture = Texture.new('/storage/images/RTP/XP/Graphics/Fogs/001-Fog01.png')
+  $fog.size = Size.new(400, 400)
+  $fog.scroll = vec2(24.0, 32.0)
+  $fog.opacity = 0.5
+
+  tex = Texture.new('/home/eric/Desktop/TimeFantasy_PCK/Characters/!$fireplace.png')
+  
+  w = tex.width / 3
+  h = tex.height
+  region = Rect.new(w, 0, w, h)
+
+
+  $sprite = SpriteAtlas.new(region: region, rows: 4, columns: 1)
+  $sprite.texture = tex
+
+  font = TrueType.new('/home/eric/Desktop/dev/NotoSansMono-Regular.ttf')
+  p font.scale(12, mode: :em)
+
+  # tex.fill_rect(Rect.new(32, 32, 32, 32), Color::RED)
+  # $sprite.scale = vec2(1, 1)
+  # $sprite.velocity = vec2(64, 0)
+  # $sprite.angle = 45
+  # $sprite.pivot = vec3(16, 16, 0)
+  # $sprite.scale = vec2(2, 2)
+
+
+  # $v.angle = 45
+
+  Game.speed = 1.0
+
+  
+
+
+  Game.main(30)
+  Game.terminate
+
+end

data/lib/rgss/batch.rb

@@ -0,0 +1,57 @@
+module RGSS
+
+  class Batch
+
+    include Enumerable
+
+    def initialize
+      @invalid = false
+      @items = Array.new
+    end
+
+    def each
+      return enum_for(__method__) unless block_given?
+      if @invalid
+        @items.sort! { |a, b| a.z <=> b.z }
+        @invalid = false
+      end
+      @items.each { |item| yield item }
+    end
+
+    def add(object)
+      unless object.respond_to?(:z) && object.respond_to?(:render)
+        raise(TypeError, "#{object} is not a #{Renderable} instance")
+      end
+      return false if @items.include?(object)
+      @items.push(object)
+      @invalid = true
+      true
+    end
+
+    def remove(object)
+      @items.delete(object)
+    end
+
+    def contains?(object)
+      object.is_a?(Renderable) ? @items.include?(object) : false
+    end
+
+    def invalidate
+      @invalid = true
+    end
+
+    alias_method :push, :add
+    alias_method :<<, :add
+    alias_method :delete, :remove
+    alias_method :include?, :contains?
+  end
+
+  module Graphics
+
+    class << self
+      attr_reader :batch
+    end
+  
+    @batch = Batch.new
+  end
+end

data/lib/rgss/blend.rb

@@ -0,0 +1,47 @@
+
+module RGSS
+
+  class Blend
+
+    ZERO                     = 0x0000
+    ONE                      = 0x0001
+    SRC_COLOR                = 0x0300
+    ONE_MINUS_SRC_COLOR      = 0x0301
+    DST_COLOR                = 0x0306
+    ONE_MINUS_DST_COLOR      = 0x0307
+    SRC_ALPHA                = 0x0302
+    ONE_MINUS_SRC_ALPHA      = 0x0303
+    DST_ALPHA                = 0x0304
+    ONE_MINUS_DST_ALPHA      = 0x0305
+    CONSTANT_COLOR           = 0x8001
+    ONE_MINUS_CONSTANT_COLOR = 0x8002
+    CONSTANT_ALPHA           = 0x8003
+    ONE_MINUS_CONSTANT_ALPHA = 0x8004
+    SRC_ALPHA_SATURATE       = 0x0308
+    SRC1_COLOR               = 0x88F9
+    ONE_MINUS_SRC1_COLOR     = 0x88FA
+    SRC1_ALPHA               = 0x8589
+    ONE_MINUS_SRC1_ALPHA     = 0x88FB
+
+    OP_ADD              = 0x8006
+    OP_SUBTRACT         = 0x800A
+    OP_REVERSE_SUBTRACT = 0x800B
+    OP_MIN              = 0x8007
+    OP_MAX              = 0x8008
+
+    attr_accessor :op
+    attr_accessor :src
+    attr_accessor :dst
+
+    def initialize(op, src, dst)
+      @op = op
+      @src = src
+      @dst = dst
+    end
+
+    def self.default
+      new(OP_ADD, SRC_ALPHA, ONE_MINUS_SRC_ALPHA)
+    end
+
+  end
+end

data/lib/rgss/game_object.rb

@@ -0,0 +1,28 @@
+
+module RGSS
+
+  ##
+  # @abstract 
+  # Abstract base class for game objects that represent a native type.
+  class GameObject
+
+    attr_accessor :id
+
+    def initialize(id)
+      @id = id
+    end
+
+    def ==(other)
+      self.class == other.class && @id == other.id
+    end
+
+    def valid?
+      raise(NotImplementedError, "#{__method__} must be overriden in derived classes")
+    end
+
+    def dispose
+      @id = 0
+      nil
+    end
+  end
+end

data/lib/rgss/plane.rb

@@ -0,0 +1,95 @@
+
+
+module RGSS
+
+  class Plane < Renderable
+
+    attr_reader :zoom
+    attr_reader :scroll
+    attr_reader :texture
+
+    def initialize(viewport = nil)
+      super(viewport&.batch || Graphics.batch)
+
+      vertex_setup
+
+      @sampler = glGenSampler
+      glSamplerParameteri(@sampler, GL_TEXTURE_WRAP_S, GL_REPEAT)
+      glSamplerParameteri(@sampler, GL_TEXTURE_WRAP_T, GL_REPEAT)
+      glSamplerParameteri(@sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST) # TODO: Linear
+      glSamplerParameteri(@sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+
+      @scroll = Vec2.zero
+      @zoom = Vec2.one
+      @origin = Vec2.zero
+      @texture = nil
+      self.size = Size.empty
+    end
+
+    def scroll=(value)
+      @scroll = value || Vec2.zero
+      value
+    end
+
+    def texture=(value)
+      @texture = value
+      update_vertices
+      value
+    end
+
+    def size=(value)
+      super
+      update_vertices
+      value
+    end
+
+    def zoom=(value)
+      @zoom = value || Vec2.one
+      # update_vertices
+      value
+    end
+
+    def update(delta)
+      super(delta)
+      @origin += @scroll * delta
+      update_vertices
+    end
+
+    def render(alpha)
+      return unless @texture && @visible && @opacity > 0.0
+      super(alpha)
+
+      glBindSampler(0, @sampler)
+      @texture.bind
+
+      glBindVertexArray(@vao)
+      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, nil)
+      
+      glBindVertexArray(GL_NONE)
+      glBindSampler(0, GL_NONE)
+    end
+
+    protected
+
+    def update_vertices
+      return unless @texture
+
+      l = (@origin.x / self.width) *  @zoom.x;
+      t = (@origin.y / self.height) * @zoom.y;
+      r = l + ((self.width /  @texture.width.to_f) * @zoom.x);
+      b = t + ((self.height / @texture.height.to_f) * @zoom.y);
+
+      vertices = 
+      [
+        0.0, 1.0, l, b, # Bottom-Left
+        1.0, 0.0, r, t, # Top-Right
+        0.0, 0.0, l, t, # Top-Left
+        1.0, 1.0, r, b, # Bottom-Right
+      ].pack('f*')
+      glBindBuffer(GL_ARRAY_BUFFER, @vbo)
+      glBufferSubData(GL_ARRAY_BUFFER, 0, vertices.size, vertices)
+      glBindBuffer(GL_ARRAY_BUFFER, 0)
+    end
+
+  end
+end

data/lib/rgss/renderable.rb

@@ -0,0 +1,158 @@
+
+module RGSS
+
+  class Renderable < Entity
+
+    include GL
+
+    VERTICES_COUNT = 16
+    VERTICES_SIZE = SIZEOF_FLOAT * VERTICES_COUNT
+    VERTICES_STRIDE = SIZEOF_FLOAT * 4
+
+    class << self
+
+      attr_reader :projection_id
+      attr_reader :model_id
+      attr_reader :color_id
+      attr_reader :tone_id
+      attr_reader :hue_id
+      attr_reader :opacity_id
+      attr_reader :flash_id
+
+      def shader
+        return @shader if @shader
+
+        v = File.read(File.join(__dir__, 'shaders', 'sprite-vert.glsl'))
+        f = File.read(File.join(__dir__, 'shaders', 'sprite-frag.glsl'))
+
+        @shader = Shader.new(v, f)
+        @projection_id = @shader.locate('projection')
+        @model_id = @shader.locate('model')
+        @hue_id = @shader.locate('hue')
+        @color_id = @shader.locate('color')
+        @tone_id = @shader.locate('tone')
+        @flash_id = @shader.locate('flash')
+        @opacity_id = @shader.locate('opacity')
+        @shader
+      end
+
+    end
+
+    ##
+    # @return [Color]
+    attr_accessor :color
+
+    ##
+    # @return [Tone]
+    attr_accessor :tone
+
+    ##
+    # @return [Float]
+    attr_accessor :hue
+
+    ##
+    # @return [Float]
+    attr_reader :opacity
+
+    ##
+    # @return [Color]
+    attr_reader :flash_color
+
+    ##
+    # @return [Boolean]
+    attr_accessor :visible
+
+    ##
+    # @return [Blend]
+    attr_accessor :blend
+
+    def initialize(parent)
+      super()
+      @parent = parent.is_a?(RGSS::Batch) ? parent : Graphics.batch
+      @parent.add(self)
+
+      @visible = true
+      @color = Color::NONE
+      @tone = Tone.new(0, 0, 0, 0)
+      @flash_color = Color::NONE
+      @flash_duration = -1
+      @hue = 0.0
+      @opacity = 1.0
+      @blend = Blend.default
+    end
+
+    def dispose
+      @parent&.remove(self)
+      glDeleteVertexArray(@vao) if @vao
+      glDeleteBuffer(@vbo) if @vbo
+      glDeleteBuffer(@ebo) if @ebo
+    end
+
+    def flashing?
+      @flash_duration > -1
+    end
+
+    def opacity=(value)
+      @opacity = [0.0, [1.0, value.to_f].min].max
+    end
+
+    def update(delta)
+      super
+      if @flash_duration > -1
+        @flash_duration -= 1
+        @flash_color = Color::NONE if @flash_duration < 0
+      end
+    end
+
+    def flash(color, duration)
+      @flash_color = color
+      @flash_duration = duration
+    end
+
+    def render(delta)
+
+      if @blend
+        glBlendEquation(@blend.op)
+        glBlendFunc(@blend.src, @blend.dst)
+      end
+
+      Renderable.shader.use
+      glUniformMatrix4fv(Renderable.model_id, 1, false, self.model)
+      glUniform4fv(Renderable.color_id, 1, self.color)
+      glUniform4fv(Renderable.tone_id, 1, self.tone)
+      glUniform4fv(Renderable.flash_id, 1, self.flash_color)
+      glUniform1f(Renderable.hue_id, self.hue)
+      glUniform1f(Renderable.opacity_id, self.opacity)
+    end
+
+    def z=(value)
+      @parent.invalidate
+      super(value)
+    end
+
+    protected
+
+    def parent
+      @parent
+    end
+
+    def vertex_setup(vertices = nil, indices = nil, vbo_usage = GL_DYNAMIC_DRAW, ebo_usage = GL_STATIC_DRAW)
+
+      @vao = glGenVertexArray
+      @vbo = glGenBuffer
+      @ebo = glGenBuffer
+
+      glBindVertexArray(@vao)
+      glBindBuffer(GL_ARRAY_BUFFER, @vbo)
+      glBufferData(GL_ARRAY_BUFFER, vertices&.bytesize || VERTICES_SIZE, vertices, vbo_usage)
+
+      indices ||= [0, 1, 2, 0, 3, 1].pack('C*')
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, @ebo)
+      glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.bytesize, indices, ebo_usage)
+
+      glEnableVertexAttribArray(0)
+      glVertexAttribPointer(0, 4, GL_FLOAT, false, SIZEOF_FLOAT * 4, nil)
+      glBindVertexArray(GL_NONE)
+    end
+  end
+end