blackbook3d 0.5.0

data/lib/BlackBook/anim.rb

@@ -0,0 +1,184 @@
+##############################################################################
+#    BlackBook 3D Engine
+#    Copyright (C) 2015, 2021  Sinan ISLEKDEMIR / DarkSpy
+#
+#    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
+# anim.rb: DarkSpy
+# Simulation Engine Ruby Sources
+################################################################
+
+require 'opengl'
+require 'BlackBook/base'
+require 'BlackBook/constants'
+require 'BlackBook/stime'
+require 'BlackBook/b3dobject'
+require 'pp'
+require 'zipfile'
+
+
+module BlackBook
+    class Anim < B3DObject
+        attr_accessor :num_frames, :_loop, :_time, :fps, :_frame, :_path
+        attr_accessor :_from_frame, :_to_frame, :_active_framecount, :_frame_period, :animate, :animations, :frames
+        attr_accessor :texture_name
+
+        def initialize(fps=30)
+              @frames = []
+              @_frame = 0
+              @num_frames = 0
+              @_time = 0
+              @_path = ""
+              @_loop = false
+              @_from_frame = 0
+              @_to_frame = 0
+              @_active_framecount = 0
+              @fps = fps
+              @_frame_period = 1.0 / fps
+              @animate = true
+              @animations = {} #: Dict[str, Tuple[int, int]] = {}
+              @objects = []
+              @texture_name=''
+        end
+
+        def start()
+            @animate = true
+        end
+        def pause()
+            @animate = false
+        end
+        def stop()
+            @animate = false
+            @_time = 0.0
+        end
+
+        def set_range(from_frame, to_frame)
+            if from_frame >= @num_frames
+                return "Frame range error - from_frame out of bounds"
+            end
+            if to_frame >= @num_frames
+                return "Frame range error - to_frame out of bounds"
+            end
+            if from_frame < 0 or to_frame < 0
+                return "Frame range error - Negative value defined"
+            end
+            @_from_frame = from_frame
+            @_to_frame = to_frame
+            @_active_framecount = to_frame - from_frame
+            @_frame_period = 1.0 / @fps
+        end
+
+        def set_animation(name, from_frame, to_frame)
+            @animations[name] = [from_frame, to_frame]
+        end
+
+        def run_animation(name)
+            if not @animations.has_key?(name)
+                return "Animation not defined"
+            end
+            self.set_range(@animations[name][0], @animations[name][1])
+        end
+
+        def load_texture(texture) #added
+            @texture_name = texture # for lazy load. just save it
+        end
+
+        def load_file(filename)
+            if not FileTest::exist?(filename)
+                return "File not found: {filename}"
+            end
+            @_path = File.dirname(filename)
+            archive = ZipFile.new(filename)
+            files = archive.namelist()
+
+            a=0
+            n=[]
+            loop {
+                f = files[a]; a += 1; n<<f.to_s.split('.')[0].to_i;
+                break if a>=files.length
+              }
+            max_frame, min_frame = n.max, n.min
+            f = min_frame
+            ret, dname = dir_make(folder_gen())
+            puts "dirmake #{ret}, #{dname}"
+            if ret == 0
+              return "temp folder makes fail"
+            else
+              $FOLDER << dname
+            end
+            while f < max_frame
+                #progress(f, max_frame - 1)
+                #wobj = B3DObject.new()
+                #wobj.path = @_path
+                #data = archive.read("#{f.to_s}.obj")
+                #material = archive.read("#{f.to_s}.mtl")
+
+                #wobj.material.load_texture(material)
+                #wobj.load_obj_from_mem(data)
+                objs = archive.write(dname, "#{f.to_s}.obj")
+                archive.write(dname, "#{f.to_s}.mtl")
+                #puts "objs #{objs}"
+                @frames << objs
+                f += 1
+              end
+            @_active_framecount = max_frame - min_frame
+            @num_frames = max_frame - min_frame
+            #archive.close()
+        end
+      end
+=begin
+        def render(self, lit: bool, shader: Shader, parent_matrix: Optional[np.ndarray] = None, _primitive: int = None):
+            if not self._visible:
+                return
+            self.update_matrix(parent_matrix=parent_matrix)
+            self.track()
+
+            if not self.animate:
+                self.frames[0].render(lit, shader, self._model_matrix)
+                return
+
+            if self._time == 0:
+                self._time = time.time()
+
+            if time.time() - self._time >= self._frame_period:
+                self._frame = (self._frame + 1) % self._active_framecount
+                self._time = time.time()
+            render_frame = self._frame + self._from_frame
+            self.frames[render_frame].render(lit, shader, self._model_matrix)
+        end
+
+        def toggle_wireframe(self) -> None:
+            d = (self.material.display + 1) % 3
+
+            for mat in self.materials.values():
+                mat.display = d
+                mat.particle_size = 0.01
+
+            if d == POINTS:
+                self.shader = PARTICLE_SHADER
+                self.refresh()
+            else:
+                self.shader = DEFAULT_SHADER
+                self.refresh()
+
+            for frame in self.frames:
+                frame.toggle_wireframe()
+        end
+=end
+end

data/lib/BlackBook/b3dobject.rb

@@ -0,0 +1,475 @@
+ ##############################################################################
+#    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 'BlackBook/base'
+require 'BlackBook/constants'
+require 'BlackBook/stime'
+require 'pp'
+
+module BlackBook
+  #
+  # 3D Object - Base Class
+  #
+  # @author [sinan islekdemir]
+  #
+  # @attr faces [Array] holds the array of faces inside the object
+  # @attr mass [Float] total mass of the object
+  # @attr roll [Float] Roll angle in degrees
+  # @attr pitch [Float] Pitch angle in degrees
+  # @attr yaw [Float] Yaw angle in degrees
+  # @attr position [CVector] Position vector of the object
+  # @attr time [Float] Time frame of the object
+  # @attr name [String] Name of the object
+  # @attr scale [CVector] Scale of the object for rendering
+  # @attr index [Integer] GlGenList OpenGL List Index
+  # @attr min [CVector] Minimum coordinates
+  # @attr max [CVector] Maximum coordinates
+  #
+  class B3DObject < Base
+    attr_accessor :faces, :roll, :pitch, :yaw, :time, :name, :scale, :index,
+                  :min, :max, :data_size, :normal_index, :elasticity,
+                  :type, :material, :matrix, :radius
+    PARTICLE      = 0
+    SOLID_CUBE    = 1
+    SOLID_SPHERE  = 2
+    SOLID_MESH    = 3
+    SOFT_CUBE     = 4
+    SOFT_SPHERE   = 5
+    SOFT_MESH     = 6
+
+    #
+    # Initialize basic variables with default.
+    #
+    # @return [BB3DObject] return self
+    def initialize
+      @vertices     = []
+      @indices      = []
+      @texcoords    = []
+      @mass         = 0.0
+      @roll         = 0.0
+      @pitch        = 0.0
+      @yaw          = 0.0
+      @position     = CVector.new(0, 0, 0, 1)
+      @scale        = CVector.new(1, 1, 1, 1)
+      @min          = nil
+      @max          = nil
+      @index        = -1
+      @time         = STime.new
+      @vertex_data  = []
+      @data_size    = 0
+      @type         = PARTICLE
+      @matrix       = CMatrix.new
+      @radius       = 0.0
+      @min          = CVector.new(9999999, 9999999, 9999999)
+      @max          = CVector.new(-9999999, -9999999, -9999999)
+      @material     = Material.new
+    end
+
+    # Convert local vector to absolute coordinates
+    # @param [CVector] Vector
+    # @param [CMatrix] Absolute Matrix
+    # @return [CVector] Absolute Vector
+    def local_to_absolute(v)
+      v = BlackBook.vector_transform(v, @matrix.to_f)
+      v
+    end
+
+    # rotate object
+    # @param [Float] x axis
+    # @param [Float] y axis
+    # @param [Float] z axis
+    def rotate(x, y, z)
+      @matrix.rotate x, y, z
+    end
+
+    #
+    # Load position data
+    # @param data [Hash] Load Data hash. (Recursive scene loading from json)
+    #
+    # @return [CVector] Position vector
+    def load_position(data)
+      @matrix.pos.x = data['position'][0] if data.key?('position')
+      @matrix.pos.y = data['position'][1] if data.key?('position')
+      @matrix.pos.z = data['position'][2] if data.key?('position')
+    end
+
+    #
+    # Load Rotation Data
+    # @param data [Hash] Load Data hash. (Recursive scene loading from json)
+    #
+    # @return [Float] Returns Yaw Flaot
+    def load_rotation(data)
+      @roll   = data['roll'] if data.key?('roll')
+      @pitch  = data['pitch'] if data.key?('pitch')
+      @yaw    = data['yaw'] if data.key?('yaw')
+    end
+
+    #
+    # Load Time Data
+    # @param data [Hash] Load Data hash. (Recursive scene loading from json)
+    #
+    # @return [Float] Returns Time
+    def load_time(data)
+      @time = data['time'] if data.key?('time')
+    end
+
+    def load_type(data)
+      @type = data['type'] if data.key?('type')
+    end
+
+    #
+    # Create a cube object.
+    # This is simply a raw cube loader.
+    # An alias to load_raw ...
+    #
+    # @return [Boolean] Load cube object
+    def create_cube
+      data_path = BlackBook::Registry.instance.read('data_path')
+      data_path = 'data' if data_path.nil?
+      load_raw data_path + '/cube.raw'
+    end
+
+    #
+    # Create a sphere object.
+    # This is simply a raw sphere loader.
+    # An alias to load_raw ...
+    #
+    # @return [Boolean] Load sphere object.
+    def create_sphere
+      data_path = BlackBook::Registry.instance.read('data_path')
+      data_path = 'data' if data_path.nil?
+      load_raw data_path + '/sphere.raw'
+    end
+
+    #
+    # Add a face to the boejct
+    # @param vertex_array [Array] Array of face data. (Creates a QUAD)
+    #
+    # @return [Boolean]
+    def add_face(v_array)
+      index = @vertices.count
+      v_1 = CVector.new(v_array[0], v_array[1], v_array[2])
+      v_2 = CVector.new(v_array[3], v_array[4], v_array[5])
+      v_3 = CVector.new(v_array[6], v_array[7], v_array[8])
+      @vertices << v_1
+      @vertices << v_2
+      @vertices << v_3
+      indice = CIndice.new
+      indice.vertice_index << index
+      indice.vertice_index << index + 1
+      indice.vertice_index << index + 2
+      indice.vertice_index << index
+      @indices << indice
+    end
+
+    #
+    # Load incoming array data into object.
+    # This function is used inside recursive json scene loader.
+    # @param data [Hash] Load Data hash. (Recursive scene loading from json)
+    #
+    # @return [Boolean] Last operation is load_time and returns its result
+    def load(data)
+      load_position data
+      load_rotation data
+      load_time data
+      load_type data
+      case @type
+      when 1
+        create_cube
+      when 2
+        create_sphere
+      when 3
+        load_raw data['filename']
+      end
+      @scale.from_array(data['scale']) if data.key?('scale')
+    end
+
+    #
+    # Update min and max vectors
+    # @param v [CVector] CVector added to object
+    #
+    # @return [CVector] Max Vector
+    def update_min_max(v)
+      @min.x = v.x if v.x < @min.x
+      @min.y = v.y if v.y < @min.y
+      @min.z = v.z if v.z < @min.z
+      @max.x = v.x if v.x > @max.x
+      @max.y = v.y if v.y > @max.y
+      @max.z = v.z if v.z > @max.z
+      @radius = @min.distance(@max) / 2.0
+    end
+    #
+    # Build OpenGL List from faces
+    #
+    # @return [Float] Bounding radius of the object
+    def build_list
+      n = Time.now.to_f
+      shader = BlackBook::Registry.instance.read('shader')
+      shader = 'displaylist' if shader.nil?
+      v1 = CVector.new(0, 0, 0, 1)
+      v2 = v1.clone
+      v3 = v1.clone
+      x = @vertices.map { |v| v.x }.minmax
+      y = @vertices.map { |v| v.y }.minmax
+      z = @vertices.map { |v| v.z }.minmax
+      @min.x = x[0]
+      @max.x = x[1]
+      @min.y = y[0]
+      @max.y = y[1]
+      @min.z = z[0]
+      @max.z = z[1]
+
+      case shader
+      when 'displaylist'
+        @index = GL.GenLists(1)
+        GL.NewList(@index, GL::COMPILE)
+        GL.LineWidth(2)
+        @indices.each do |indice|
+          v1 = @vertices[indice.vertice_index[0]]
+          v2 = @vertices[indice.vertice_index[1]]
+          v3 = @vertices[indice.vertice_index[2]]
+          normal = BlackBook.calc_plane_normal(v1, v2, v3)
+          GL.Begin(GL::TRIANGLES)
+          0.upto(indice.vertice_index.count - 1) do |i|
+            t = indice.texcoord_index.count > 0
+            vertex = @vertices[indice.vertice_index[i]]
+            texcrd = @texcoords[indice.texcoord_index[i]] if t
+
+            GL.Normal3f(normal.x, normal.y, normal.z)
+            GL.TexCoord2f(texcrd.x, texcrd.y) if t
+            GL.Vertex3f(vertex.x, vertex.y, vertex.z)
+          end
+          GL.End
+        end
+        GL.EndList
+      when 'vbo'
+        @index = GL.GenBuffers(3)
+        data = []
+        normals = []
+        textures = []
+        @indices.each do |indice|
+          v1 = @vertices[indice.vertice_index[0]]
+          v2 = @vertices[indice.vertice_index[1]]
+          v3 = @vertices[indice.vertice_index[2]]
+          normal = BlackBook.calc_plane_normal(v1, v2, v3)
+          0.upto(indice.vertice_index.count - 1) do |i|
+            @t = indice.texcoord_index.count > 0
+            vertex = @vertices[indice.vertice_index[i]]
+            texcrd = @texcoords[indice.texcoord_index[i]] if @t
+            data << vertex.x
+            data << vertex.y
+            data << vertex.z
+            normals << normal.x
+            normals << normal.y
+            normals << normal.z
+            textures << texcrd.x if @t
+            textures << texcrd.y if @t
+          end
+          update_min_max(v1)
+          update_min_max(v2)
+          update_min_max(v3)
+        end
+        @data_size = data.length
+        GL.BindBuffer(GL::GL_ARRAY_BUFFER, @index[0])
+        GL.BufferData(
+          GL::GL_ARRAY_BUFFER,
+          data.length * 4,
+          data.pack('f*'),
+          GL::GL_STATIC_DRAW)
+        GL.BindBuffer(GL::GL_ARRAY_BUFFER, @index[1])
+        GL.BufferData(
+          GL::GL_ARRAY_BUFFER,
+          normals.length * 4,
+          normals.pack('f*'),
+          GL::GL_STATIC_DRAW
+        )
+        GL.BindBuffer(GL::GL_ARRAY_BUFFER, @index[2])
+        GL.BufferData(
+          GL::GL_ARRAY_BUFFER,
+          textures.length * 4,
+          textures.pack('f*'),
+          GL::GL_STATIC_DRAW)
+        data.clear
+        normals.clear
+        textures.clear
+        @indices.clear
+        @texcoords.clear
+        @vertices.clear
+      end
+      d = Time.now.to_f - n
+      puts "Build: #{d}\n"
+       
+    end
+
+    #
+    # General rendering method.
+    #
+    # @return [Boolean] GL.PopMatrix is the last method called inside.
+    def render
+      build_list if @index == -1
+      # GL.Disable(GL::LIGHTING)
+      @material.start_render
+
+      GL.PushMatrix
+      GL.MultMatrixf(@matrix.to_array)
+
+      shader = BlackBook::Registry.instance.read('shader')
+      shader = 'displaylist' if shader.nil?
+      case shader
+      when 'displaylist'
+        GL.CallList(@index)
+      when 'vbo'
+        GL.EnableClientState(GL::GL_VERTEX_ARRAY)
+        GL.EnableClientState(GL::GL_NORMAL_ARRAY)
+        GL.EnableClientState(GL::GL_TEXTURE_COORD_ARRAY)
+        GL.BindBuffer(GL::GL_ARRAY_BUFFER, @index[0])
+        GL.VertexPointer(3, GL::GL_FLOAT, 0, 0)
+        GL.BindBuffer(GL::GL_ARRAY_BUFFER, @index[1])
+        GL.NormalPointer(GL::GL_FLOAT, 0, 0)
+        GL.BindBuffer(GL::GL_ARRAY_BUFFER, @index[2])
+        GL.TexCoordPointer(2, GL::GL_FLOAT, 0, 0)
+        GL.DrawArrays(GL::GL_QUADS, 0, @data_size / 3)
+        # GL.DrawElements(GL::TRIANGLES, @data_size / 3, GL::UNSIGNED_SHORT, 0)
+        GL.DisableClientState(GL::GL_VERTEX_ARRAY)
+        GL.DisableClientState(GL::GL_NORMAL_ARRAY)
+        GL.DisableClientState(GL::GL_TEXTURE_COORD_ARRAY)
+        GL.Flush
+      end
+
+      GL.PopMatrix
+      @material.end_render
+      # GL.Enable(GL::LIGHTING)
+    end
+
+    #
+    # Load Raw data object.
+    # This is the RAW File Type of Blender software (http://www.blender.org/)
+    # @param filename [String] File to be loaded.
+    #
+    # @return [Boolean] Return true on success
+    def load_raw(filename)
+      buffer = File.read filename
+      buffer.split("\n").each do |line|
+        f_items = line.split(' ').map { |x| x.to_f }
+        add_face f_items
+      end
+      calculate_radius
+      true
+    end
+
+    #
+    # Load Text based Wavefront Object
+    # This is the obj file type of Blender software (http://www.blender.org/)
+    # @param [String] filename
+    #
+    # @return [Boolean] Return true on success
+    def load_obj(filename)
+      @vertices = []
+      @texcoords = []
+      @indices = []
+      buffer = File.read filename
+      buffer = buffer.split("\n")
+      buffer.each do |line|
+        items = line.split(' ')
+        case items[0]
+        when 'v'
+          @vertices << CVector.new(items[1].to_f, items[2].to_f, items[3].to_f)
+        when 'vt'
+          @texcoords << CVector.new(items[1].to_f, items[2].to_f, 0)
+        when 'f'
+          indice = CIndice.new
+          items.each do |item|
+            next if item == 'f'
+            p = item.split '/'
+            indice.vertice_index << p[0].to_i - 1
+            indice.texcoord_index << p[1].to_i - 1 unless p[1].nil?
+          end
+          @indices << indice
+        end
+      end
+      calculate_radius
+    end
+
+    #
+    # Load Text based Wavefront Object
+    # This is the obj file type of Blender software (http://www.blender.org/)
+    # @param [String] buffer
+    #
+    # @return [Boolean] Return true on success
+    def load_obj_from_mem(buffer)
+      @vertices = []
+      @texcoords = []
+      @indices = []
+      #buffer = File.read filename
+      buffer = buffer.split("\n")
+      buffer.each do |line|
+        items = line.split(' ')
+        case items[0]
+        when 'v'
+          @vertices << CVector.new(items[1].to_f, items[2].to_f, items[3].to_f)
+        when 'vt'
+          @texcoords << CVector.new(items[1].to_f, items[2].to_f, 0)
+        when 'f'
+          indice = CIndice.new
+          items.each do |item|
+            next if item == 'f'
+            p = item.split '/'
+            indice.vertice_index << p[0].to_i - 1
+            indice.texcoord_index << p[1].to_i - 1 unless p[1].nil?
+          end
+          @indices << indice
+        end
+      end
+      calculate_radius
+    end
+
+    #
+    # Calculate bounding sphere radius from vertices
+    # Finds the maximum distance from origin to any vertex
+    #
+    # @return [Float] Calculated radius
+    def calculate_radius
+      return 0.0 if @vertices.empty?
+      
+      # Calculate center of mass (centroid)
+      center_x = @vertices.map(&:x).sum / @vertices.size
+      center_y = @vertices.map(&:y).sum / @vertices.size
+      center_z = @vertices.map(&:z).sum / @vertices.size
+      
+      # Find maximum distance from center
+      @radius = @vertices.map do |v|
+        dx = v.x - center_x
+        dy = v.y - center_y
+        dz = v.z - center_z
+        Math.sqrt(dx * dx + dy * dy + dz * dz)
+      end.max
+      
+      @radius
+    end
+
+
+  end
+end