blackbook3d 0.5.0

data/lib/BlackBook/base.rb

@@ -0,0 +1,79 @@
+##############################################################################
+#    BlackBook 3D Engine
+#    Copyright (C) 2015  Sinan ISLEKDEMIR
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+##############################################################################
+
+################################################################
+# Project BlackBook
+# Lead Engineer: Sinan ISLEKDEMIR
+# Simulation Engine Ruby Sources
+################################################################
+
+require 'BlackBook/logger'
+require 'BlackBook/registry'
+
+$FOLDER = []
+
+def dir_make(name)
+  unless File.directory?(name)
+    Dir.mkdir(name)
+    return 1, name # create ok
+  else
+    return 2, name #already exists
+  end
+  rescue Exception=>e
+    return 0, name
+end
+
+def dir_del(dir_path)
+  if File.directory?(dir_path)
+    Dir.foreach(dir_path) do |sub_file|
+      dir_del(File.join(dir_path, sub_file)) unless ['.', '..'].include? sub_file
+    end
+    Dir.rmdir(dir_path)
+  else
+    File.delete(dir_path)
+  end
+  return 1
+  rescue Exception => e
+  return 0
+end
+
+def folder_gen() # year-mon-day-min-sec-nsec
+  t = Time.now
+  tmp = ENV["temp"]
+  ss = t.year.to_s
+  [t.month, t.day, t.hour, t.min, t.sec, t.nsec].map do |opt| ss += '-' + opt.to_s end
+  return tmp + "/#{ss}"
+end
+
+def clear_temp() 
+  $FOLDER.each { |f| dir_del f }
+end
+
+module BlackBook
+  # BlackBook Base Class
+  class Base
+    attr_accessor :logger, :registry
+
+    def initialize(*_args)
+      logging_params = { filename: 'debug.log', stdout: true }
+      Logger.instance.define logging_params
+      @registry = Registry.instance
+    end
+  end
+end

data/lib/BlackBook/camera.rb

@@ -0,0 +1,202 @@
+##############################################################################
+#    BlackBook 3D Engine
+#    Copyright (C) 2015  Sinan ISLEKDEMIR
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+##############################################################################
+
+################################################################
+# Project BlackBook
+# Lead Engineer: Sinan ISLEKDEMIR
+# Simulation Engine Ruby Sources
+################################################################
+
+require 'opengl'
+require 'pp'
+
+# Local Libs
+require 'BlackBook/base'
+require 'BlackBook/functions'
+
+module BlackBook
+  #
+  # Camera Class
+  # @attr eye_position [CVector] Eye - Camera position
+  # @attr target [CVector] Camera target
+  # @attr up_vector [CVector] Camera Up Vector
+  # @attr frame_x [Integer] Camera Frame X Location
+  # @attr frame_y [Integer] Camera Frame Y Location
+  # @attr frame_width [Integer] Camera Frame Width
+  # @attr frame_height [Integer] Camera Frame Height
+  # @attr fov [Float] Camera Field Of View
+  # @attr znear [Float] Near Plane Distance
+  # @attr zfar [Float] Far Plane Distance
+  # @attr on_update [Array] [0] -> Lambda | [1] -> Variable Array
+  #   Your Lambda function MUST include 4 arguements like;
+  #   on_update = -> (camera, x, y, extra_array_to_pass) { ... }
+  #
+  # @author [sinan islekdemir]
+  #
+  class Camera < Base
+    attr_accessor :eye_position, :target, :up_vector, :frame_x, :frame_y,
+                  :frame_width, :frame_height, :fov, :znear, :zfar, :on_update
+
+    # options -> :eye_position, :target_position, :up, :fov, :znear, :zfar
+    #            :frame_x, :frame_y, :frame_width, :frame_height
+
+    #
+    # Initialize Camera
+    # @param options [Hash]
+    #                :eye_position
+    #                :target
+    #                :up_vector
+    #                :frame_x
+    #                :frame_y
+    #                :frame_width
+    #                :frame_height
+    #                :fov
+    #                :znear
+    #                :zfar
+    #                :on_update
+    #
+    # @return [type] [description]
+    def initialize( opts = {} )
+      super
+      @eye_position = CVector.new(
+        opts[:eye_position].x,
+        opts[:eye_position].y,
+        opts[:eye_position].z
+      )
+      @target = CVector.new(
+        opts[:target_position].x,
+        opts[:target_position].y,
+        opts[:target_position].z
+      )
+      @up_vector = CVector.new(
+        opts[:up].x,
+        opts[:up].y,
+        opts[:up].z
+      )
+      @on_update = nil
+      @frame_x   = opts[:frame_x] || 0
+      @frame_y   = opts[:frame_y] || 0
+      @frame_width  = opts[:frame_width]  || 0
+      @frame_height = opts[:frame_height] || 0
+      @fov   = opts[:fov]   || 30.0
+      @znear = opts[:znear] || 1.0
+      @zfar  = opts[:zfar]  || 1000.0
+      @modified = false
+    end
+
+    #
+    # Turn screen coordinates to world coordinates
+    # @param x [Integer] Cursor X
+    # @param y [Integer] Cursor Y
+    #
+    # @return [CVector] World position
+    def screen_to_world(x, y)
+      mv = GL.GetFloatv GL::MODELVIEW_MATRIX
+      pm = GL.GetFloatv GL::PROJECTION_MATRIX
+      vp = GL.GetFloatv GL::VIEWPORT
+      y = vp[3] - y
+      z = GL.ReadPixels(x, y, 1, 1, GL::DEPTH_COMPONENT, GL::FLOAT)
+      z = z.unpack('f')[0]
+      glh_unprojectf(x, y, z, mv, pm, vp)
+    end
+
+    #
+    # World to screen coordinates
+    # @param v [CVector] World coordinates
+    #
+    # @return [Array] Array of screen coordinates
+    def world_to_screen(v)
+      mv = GL.GetFloatv GL::MODELVIEW_MATRIX
+      pm = GL.GetFloatv GL::PROJECTION_MATRIX
+      vp = GL.GetFloatv GL::VIEWPORT
+      BlackBook.glh_project_f(v, mv, pm, vp)
+    end
+
+    #
+    # Is camera framed?
+    #
+    # @return [Boolean] Is camera framed?
+    def framed
+      (@frame_width > 0 && @frame_height > 0)
+    end
+
+    #
+    # Begin rendering
+    #
+    # @return [Boolean] Success
+    def begin_render
+      if @frame_width > 0 && @frame_height > 0
+        GL.PushAttrib(GL::SCISSOR_BIT)
+        GL.Enable(GL::SCISSOR_TEST)
+        GL.Scissor(@frame_x, @frame_y, @frame_width, @frame_height)
+        GL.Viewport(@frame_x, @frame_y, @frame_width, @frame_height)
+        BlackBook.perspective(
+          30.0, @frame_width.to_f / @frame_height.to_f, 1.0, 1000.0
+        )
+      end
+      GL.LoadIdentity
+      BlackBook.look_at(
+        @eye_position,
+        @target,
+        @up_vector)
+      true
+    end
+
+    #
+    # End Rendering
+    #
+    # @return [Boolean] Success
+    def end_render
+      if @modified && !@on_update.nil?
+        lambda = @on_update[0]
+        variable = @on_update[1]
+        lambda.call(self, @pos_x, @pos_y, variable)
+        @modified = false
+      end
+      return false until framed
+      GL.Disable(GL::SCISSOR_TEST)
+      GL.PopAttrib
+      return true
+    end
+
+    #
+    # Mouse event handler
+    # @param x [Integer] Cursor X Position
+    # @param y [Integer] Cursor Y Position
+    # @param right_b [Integer] Right Mouse Button
+    # @param left_b [Integer] Left Mouse Button
+    # @param middle_b [Integer] Middle Mouse Button
+    #
+    def mouse_move(x, y, _right_b, left_b, _middle_b)
+      @pos_x, @pos_y = x, y if @pos_x.nil?
+      if left_b == 1
+        diff = @eye_position.sub(@target)
+        diff.update_spherical
+        diff.phi = diff.phi - BlackBook.deg_to_rad((x.to_f - @pos_x.to_f).to_f)
+        diff.theta = diff.theta - BlackBook.deg_to_rad(
+          (y.to_f - @pos_y.to_f).to_f
+        )
+        diff.update_cartesian
+        @eye_position = @target.add(diff)
+        @modified = true
+      end
+      @pos_x, @pos_y = x, y
+    end
+  end
+end

data/lib/BlackBook/color.rb

@@ -0,0 +1,29 @@
+##############################################################################
+#    BlackBook 3D Engine
+#    Copyright (C) 2015  Sinan ISLEKDEMIR
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+##############################################################################
+
+require 'BlackBook/constants'
+
+# Some standard colors
+module BlackBook
+  BLACK = CVector.new(0.0, 0.0, 0.0, 1.0)
+  WHITE = CVector.new(1.0, 1.0, 1.0, 1.0)
+  RED   = CVector.new(1.0, 0.0, 0.0, 1.0)
+  GREEN = CVector.new(0.0, 1.0, 0.0, 1.0)
+  BLUE  = CVector.new(0.0, 0.0, 1.0, 1.0)
+end

data/lib/BlackBook/constants.rb

@@ -0,0 +1,327 @@
+##############################################################################
+#    BlackBook 3D Engine
+#    Copyright (C) 2015  Sinan ISLEKDEMIR
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License along
+#    with this program; if not, write to the Free Software Foundation, Inc.,
+#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+##############################################################################
+
+################################################################
+# Project BlackBook
+# Lead Engineer: Sinan ISLEKDEMIR
+# Simulation Engine Ruby Sources
+################################################################
+
+require 'BlackBook/base'
+require 'BlackBook/functions'
+
+module BlackBook
+  #
+  # CVector Class (From Dust Engine by Sinan ISLEKDEMIR)
+  #
+  # @author [sinan islekdemir]
+  #
+  # @attr x [Float] Vector - X magnitude
+  # @attr y [Float] Vector - Y magnitude
+  # @attr z [Float] Vector - Z magnitude
+  # @attr w [Float] Vector - W
+  # @attr phi [Float] Phi - Spherical Coordinates
+  # @attr theta [Float] Theta - Spherical Coordinates
+  # @attr r [Float] Radius - Spherical Coordinates
+  class CVector < Base
+    # phi dikey, theta yatay aci| r orijine mesafe - yaricap
+    attr_accessor :x, :y, :z, :w, :phi, :theta, :r
+
+    #
+    # Initialize Vector
+    # @param x [Float] X
+    # @param y [Float] Y
+    # @param z [Float] Z
+    # @param w = 1 [Float] W
+    #
+    # @return [Boolean] Success
+    def initialize(x, y, z, w = 1)
+      super
+      @x, @y, @z, @w = x, y, z, w
+      update_spherical
+      return true
+    end
+
+    #
+    # Scalar Multiply Vector with a factor float
+    # @param factor [Float] Multiplication Float
+    def multiply(factor)
+      @x *= factor
+      @y *= factor
+      @z *= factor
+    end
+
+    #
+    # Scalar Division Vector with a factor float
+    # @param [Float] Division Float
+    def div(factor)
+      @x /= factor
+      @y /= factor
+      @z /= factor
+    end
+
+    #
+    # Set Vector
+    # @param x [Float] X Magnitude
+    # @param y [Float] Y Magnitude
+    # @param z [Float] Z Magnitude
+    # @param w = 1 [Float] W Magnitude
+    #
+    # @return [CVector] Self
+    def set(x, y, z, w = 1)
+      @x, @y, @z, @w = x, y, z, w
+    end
+
+    # Set vector from array
+    # @param arr [Array] set of elements
+    def from_array(arr = [])
+      @x = arr[0] if arr[0]
+      @y = arr[1] if arr[1]
+      @z = arr[2] if arr[2]
+      @w = arr[3] if arr[3]
+    end
+
+    #
+    # Update Spherical Coordinates
+    #
+    # @return [Boolean] Success
+    def update_spherical
+      @r = length
+      @theta = Math.acos(@z / r)
+      @phi = Math.atan2(@y, @x)
+      return true
+    end
+
+    #
+    # Update Cartesian Coordinates
+    #
+    # @return [Boolean] Success
+    def update_cartesian
+      @x = @r * Math.sin(@theta) * Math.cos(@phi)
+      @y = @r * Math.sin(@theta) * Math.sin(@phi)
+      @z = @r * Math.cos(@theta)
+      return true
+    end
+
+    #
+    # Normalize Vector
+    #
+    # @return [Boolean] Success
+    def normalize
+      d = length
+      d *= -1 if d.negative?
+      @x /= d
+      @y /= d
+      @z /= d
+      return self
+    end
+
+    #
+    # Calculate Vector Length
+    #
+    # @return [Float] Length of vector
+    def length
+      Math.sqrt((@x * @x) + (@y * @y) + (@z * @z))
+    end
+
+    #
+    # Vector Cross Product
+    # @param vector [CVector] Multiplication Vector
+    #
+    # @return [CVector] Product Vector
+    def cross(vector)
+      CVector.new(
+        @y * vector.z - @z * vector.y,
+        @z * vector.x - @x * vector.z,
+        @x * vector.y - @y * vector.x,
+        0
+      )
+    end
+
+    #
+    # Vector Dot Product
+    # @param vector [CVector] Multiplication Vector
+    #
+    # @return [Float] Dot Product
+    def dot(vector)
+      @x * vector.x + @y * vector.y + @z * vector.z + @w * vector.w
+    end
+
+    #
+    # Distance between two vectors
+    # @param vector [CVector] Target Vector
+    #
+    # @return [Float] Distance
+    def distance(vector)
+      sub(vector).length
+    end
+
+    #
+    # Rotate Vector around X Axis
+    # @param angle [Float] Angle in Degrees
+    #
+    # @return [Boolean] Success
+    def rotate_around_x(angle)
+      angle = angle * Math::PI / 180
+      s = Math.sin(angle)
+      c = Math.cos(angle)
+      @y = c * @y + s * @z
+      @z = c * @z - s * @y
+      return true
+    end
+
+    #
+    # Rotate Vector around Y Axis
+    # @param angle [Float] Angle in Degrees
+    #
+    # @return [Float] Success
+    def rotate_around_y(angle)
+      angle = angle * Math::PI / 180
+      s = Math.sin(angle)
+      c = Math.cos(angle)
+      @x = c * @x + s * @z
+      @z = c * @z - s * @x
+      return true
+    end
+
+    #
+    # Rotate Vector around Z Axis
+    # @param angle [Float] Angle in Degrees
+    #
+    # @return [Float] Success
+    def rotate_around_z(angle)
+      angle *= Math::PI / 180
+      s = Math.sin(angle)
+      c = Math.cos(angle)
+      @x = c * @x + s * @y
+      @y = c * @y - s * @x
+      return true
+    end
+
+    #
+    # Vector Subtraction
+    # @param v [CVector] Target Vector
+    #
+    # @return [CVector] Result
+    def sub(v)
+      CVector.new(@x - v.x, @y - v.y, @z - v.z, @w)
+    end
+
+    #
+    # Vector Addition
+    # @param v [CVector] Addition Vector
+    #
+    # @return [CVector] Result
+    def add(v)
+      CVector.new(@x + v.x, @y + v.y, @z + v.z, @w)
+    end
+
+    #
+    # Convert CVector into one dimensional array
+    #
+    # @return [type] [description]
+    def to_array
+      [@x, @y, @z, @w]
+    end
+
+    #
+    # Convert CVector into string
+    # @return [String] Array
+    def to_s
+      to_array.to_s
+    end
+  end
+
+  # CMatrix Class
+  class CMatrix
+    attr_accessor :left, :dir, :up, :pos
+
+    # initialize
+    def initialize
+      @left = CVector.new(1.0, 0.0, 0.0, 0.0)
+      @dir  = CVector.new(0.0, 1.0, 0.0, 0.0)
+      @up   = CVector.new(0.0, 0.0, 1.0, 0.0)
+      @pos  = CVector.new(0.0, 0.0, 0.0, 1.0)
+    end
+
+    def to_array
+      m = [@left.to_array, @dir.to_array, @up.to_array, @pos.to_array]
+      m.flatten
+    end
+
+    def to_f
+      [@left.to_array, @dir.to_array, @up.to_array, @pos.to_array]
+    end
+
+    def rotate(x, y, z)
+      m = to_array
+      x = BlackBook.deg_to_rad x
+      y = BlackBook.deg_to_rad y
+      z = BlackBook.deg_to_rad z
+      m[12] = 0.0
+      m[13] = 0.0
+      m[14] = 0.0
+      unified = [
+        1.0, 0.0, 0.0, 0.0,
+        0.0, 1.0, 0.0, 0.0,
+        0.0, 0.0, 1.0, 0.0,
+        0.0, 0.0, 0.0, 1.0
+      ]
+      x_matrix = unified.clone
+      x_matrix[5] = Math.cos y
+      x_matrix[6] = -1 * Math.sin(y)
+      x_matrix[9] = Math.sin y
+      x_matrix[10] = Math.cos y
+      y_matrix = unified.clone
+      y_matrix[0] = Math.cos x
+      y_matrix[2] = Math.sin x
+      y_matrix[8] = -1 * Math.sin(x)
+      y_matrix[10] = Math.cos x
+      z_matrix = unified.clone
+      z_matrix[0] = Math.cos z
+      z_matrix[1] = -1 * Math.sin(z)
+      z_matrix[4] = Math.sin z
+      z_matrix[5] = Math.cos z
+      m_1 = BlackBook.multiply_matrices_4by4 m, x_matrix
+      m_2 = BlackBook.multiply_matrices_4by4 m_1, y_matrix
+      m_3 = BlackBook.multiply_matrices_4by4 m_2, z_matrix
+      m_3[12] = @pos.x
+      m_3[13] = @pos.y
+      m_3[14] = @pos_z
+      @left.set m_3[0], m_3[1], m_3[2], m_3[3]
+      @dir.set m_3[4], m_3[5], m_3[6], m_3[7]
+      @up.set m_3[8], m_3[9], m_3[10], m_3[11]
+      m_3
+    end
+  end
+
+  # Keep vertices and texcoords together at indices
+  class CIndice
+    attr_accessor :texcoord_index, :vertice_index
+
+    def initialize
+      @vertice_index = []
+      @texcoord_index = []
+    end
+
+    def to_s
+      @vertice_index.to_s + '-' + @texcoord_index.to_s
+    end
+  end
+end