blender-3d 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14b1b6b25b75bc3144579623d6ebaf1eb20ed295
+  data.tar.gz: 94d505a329ebe729c2970ad9cf563829b365bcf4
+SHA512:
+  metadata.gz: b10f4977194b4c18d5790b7bcb2aaf2674404751bf0aa63843eaafbd6df47626ad5db875099e6a5f090f2e4e49a2b76258ed97ce84db43eb9fb5afa4ac1a491f
+  data.tar.gz: 4eea3fb816ffb01d0fcf08e1a77a7ba7cad124a813dcc953b837bb7b7c2e64feba455f62635053fc3c033b0c7aec11f97a7014bcd1cd728c3885481ec2610e00

data/lib/blender-3d.rb

@@ -0,0 +1,31 @@
+require 'stringio'
+
+require_relative 'blender-3d/version'
+require_relative 'blender-3d/object_reader'
+
+require_relative 'blender-3d/pointer'
+require_relative 'blender-3d/types'
+require_relative 'blender-3d/field'
+require_relative 'blender-3d/char_field_parser'
+require_relative 'blender-3d/generic_field_parser'
+require_relative 'blender-3d/field_parser_factory'
+
+require_relative 'blender-3d/structure'
+require_relative 'blender-3d/structure_definition'
+
+require_relative 'blender-3d/file_header'
+require_relative 'blender-3d/file_block'
+require_relative 'blender-3d/dna_block'
+require_relative 'blender-3d/model'
+
+
+=begin
+
+Usage:
+
+require 'blender-3d'
+# require_relative 'blender-3d'
+
+model = Blender3d::Model.from_file('cube.blend');
+
+=end

data/lib/blender-3d/char_field_parser.rb

@@ -0,0 +1,39 @@
+module Blender3d
+  class CharFieldParser
+    def initialize(name)
+      @name = name
+    end
+
+    def parse
+      type = case @name
+        when GenericFieldParser::FUNCTION_POINTER
+          FunctionPointerType.new(SimpleType.new(FieldParserFactory::CHAR_TYPE))
+
+        when GenericFieldParser::POINTER_ARRAY
+          array_size = $2.to_i
+          ArrayType.new(NullTerminatedStringType.new, array_size)
+
+        when GenericFieldParser::MULTI_POINTER
+          PointerType.new(NullTerminatedStringType.new)
+
+        when GenericFieldParser::POINTER
+          NullTerminatedStringType.new
+
+        when GenericFieldParser::MULTI_ARRAY
+          array_size, string_size = $2.to_i, $3.to_i
+          ArrayType.new(FixedLengthStringType.new(string_size), array_size)
+
+        when GenericFieldParser::ARRAY
+          array_size = $2.to_i
+          FixedLengthStringType.new(array_size)
+
+        else
+          SimpleType.new(FieldParserFactory::CHAR_TYPE)
+
+      end
+
+      name = $1 || @name
+      Field.new(type, name)
+    end
+  end
+end

data/lib/blender-3d/dna_block.rb

@@ -0,0 +1,74 @@
+module Blender3d
+  class DnaBlock
+    attr_accessor :code, :types, :structures
+
+    def initialize(reader = nil)
+      deserialize(reader) if reader
+    end
+
+    def deserialize(reader)
+      Reader.new(reader, self).read
+    end
+
+    class Reader
+      def initialize(reader, dna_block = DnaBlock.new)
+        @reader, @dna_block = reader, dna_block
+      end
+
+      def read
+        @dna_block.code = @reader.read(4)
+        @names = read_names
+        read_types
+        read_structures
+        @dna_block
+      end
+
+      private
+
+        def read_names
+          @reader.read(4) # identifier 'NAME'
+          count = @reader.read_int32
+          count.times.map { @reader.read_string.chop.freeze }
+        end
+
+        def read_types
+          read_aligned # identifier 'TYPE' 4 byte aligned
+
+          count = @reader.read_int32
+          types = count.times.map { @reader.read_string.chop.freeze }
+
+          read_aligned # identifier 'TLEN' 4 byte aligned
+          lengths = count.times.map { @reader.read_int16 }
+
+          @dna_block.types = types.zip(lengths)
+        end
+
+        def read_aligned
+          offset = 4 + (( 4 - (@reader.tell % 4) ) % 4)
+          @reader.read(offset)
+        end
+
+        def read_structures
+          read_aligned # identifier 'STRC' 4 byte aligned
+          count = @reader.read_int32
+          @dna_block.structures = count.times.map { read_structure }
+        end
+
+        def read_structure
+          type_index = @reader.read_int16
+          num_fields = @reader.read_int16
+
+          fields = num_fields.times.map { read_field }
+
+          StructureDefinition.new(*@dna_block.types[type_index], fields)
+        end
+
+        def read_field
+          field_type = @dna_block.types[@reader.read_int16][0]
+          field_name = @names[@reader.read_int16]
+          factory = FieldParserFactory.create_for(field_type, field_name)
+          factory.parse
+        end
+    end
+  end
+end

data/lib/blender-3d/field.rb

@@ -0,0 +1,17 @@
+module Blender3d
+  class Field
+    attr_reader :type, :name
+
+    def initialize(type, name)
+      @type, @name = type, name.to_sym
+    end
+
+    def to_s
+      "Field[#@name](#@type)"
+    end
+
+    def inspect
+      "#{@type.inspect} #@name"
+    end
+  end
+end

data/lib/blender-3d/field_parser_factory.rb

@@ -0,0 +1,10 @@
+module Blender3d
+  module FieldParserFactory
+    CHAR_TYPE = 'char'.freeze
+
+    def self.create_for(type, name)
+      return CharFieldParser.new(name) if type == CHAR_TYPE
+      GenericFieldParser.new(type, name)
+    end
+  end
+end

data/lib/blender-3d/file_block.rb

@@ -0,0 +1,44 @@
+module Blender3d
+  class FileBlock
+    attr_accessor :code, :size, :pointer, :type_index, :count, :data, :type
+
+    def initialize(reader = nil)
+      deserialize(reader) if reader
+    end
+
+    def deserialize(reader)
+      Reader.new(reader, self).read
+    end
+
+    def parse_data(model)
+      file = StringIO.new(self.data)
+      reader = model.create_reader(file)
+      self.data = self.count.times.map { self.type.read(reader) }
+    end
+
+    class Reader
+      def initialize(reader, file_block = FileBlock.new)
+        @reader, @file_block = reader, file_block
+      end
+
+      def read
+        @file_block.code = @reader.read(4).gsub(/\0.*$/, '')
+        @file_block.size = @reader.read_uint32
+        @file_block.pointer = Pointer.new(@reader.read_pointer)
+        @file_block.type_index = @reader.read_uint32
+        @file_block.count = @reader.read_uint32
+        @file_block.data = @reader.read(@file_block.size)
+        read_dna if @file_block.code == 'DNA1'
+        @file_block
+      end
+
+      private def read_dna
+        file = StringIO.new(@file_block.data)
+        @reader = @reader.model.create_reader(file)
+        @file_block.data = DnaBlock.new(@reader)
+      end
+    end
+  end
+end
+
+

data/lib/blender-3d/file_header.rb

@@ -0,0 +1,41 @@
+module Blender3d
+  class FileHeader
+    attr_accessor :identifier,
+                  :version
+
+    attr_reader :pointer_size, :size_code,
+                :endianness, :endian_code
+
+    def initialize(file = nil)
+      deserialize(file) if file
+    end
+
+    def deserialize(file)
+      self.identifier = file.read(7)
+      self.pointer_size = file.read(1) == '-'.freeze ? 8 : 4
+      self.endianness = file.read(1) == 'v'.freeze ? :little : :big
+      self.version = file.read(1) + '.'.freeze + file.read(2)
+      self
+    end
+
+    def pointer_size=(value)
+      @pointer_size = value
+      @size_code = @pointer_size == 8 ? 'Q'.freeze : 'L'.freeze
+    end
+
+    def endianness=(value)
+      @endianness = value
+      @endian_code = little_endian? ? '<'.freeze : '>'.freeze
+    end
+
+    def little_endian?
+      @endianness == :little
+    end
+
+    def big_endian?
+      !little_endian?
+    end
+  end
+end
+
+

data/lib/blender-3d/generic_field_parser.rb

@@ -0,0 +1,54 @@
+module Blender3d
+  class GenericFieldParser
+    FUNCTION_POINTER = /^\(\*([^\)]+)\)\(\)$/
+    POINTER_ARRAY    = /^\*([^\[]+)\[(\d+)\]$/
+    MULTI_POINTER    = /^\*{2}(.+)$/
+    POINTER          = /^\*(.+)$/
+    MULTI_ARRAY      = /^([^\[]+)\[(\d+)\]\[(\d+)\]$/
+    ARRAY            = /^([^\[]+)\[(\d+)\]$/
+
+    def initialize(type, name)
+      @type, @name = type, name
+    end
+
+    def parse
+      type = case @name
+        when FUNCTION_POINTER
+          FunctionPointerType.new(@type)
+
+        when POINTER_ARRAY
+          array_size = $2.to_i
+          ArrayType.new(build_pointer_type, array_size)
+
+        when MULTI_POINTER
+          PointerType.new(build_pointer_type)
+
+        when POINTER
+          build_pointer_type
+
+        when MULTI_ARRAY
+          array1_size, array2_size = $2.to_i, $3.to_i
+          ArrayType.new(ArrayType.new(build_simple_type, array2_size), array1_size)
+
+        when ARRAY
+          array_size = $2.to_i
+          ArrayType.new(build_simple_type, array_size)
+
+        else
+          build_simple_type
+
+      end
+
+      name = $1 || @name
+      Field.new(type, name)
+    end
+
+    private def build_pointer_type
+      PointerType.new(build_simple_type)
+    end
+
+    private def build_simple_type
+      SimpleType.new(@type)
+    end
+  end
+end

data/lib/blender-3d/model.rb

@@ -0,0 +1,56 @@
+module Blender3d
+  class Model
+    attr_reader :header, :blocks, :pointers
+    
+    def self.from_file(path)
+      File.open(path, 'rb') { |file| new(file) }
+    end
+
+    def initialize(file = nil)
+      @blocks = []
+      deserialize(file) if file
+    end
+
+    def deserialize(file)
+      @header = FileHeader.new(file)
+      reader = create_reader(file)
+      @blocks.clear
+
+      loop do
+        @blocks << FileBlock.new(reader)
+        break if reader.tell == reader.file.size
+      end
+
+      dna_block = self.dna_block
+      return self unless dna_block
+
+      @blocks.select { |block| block.type_index != 0 }.each do |block|
+        block.type = dna_block.data.structures[block.type_index]
+        block.parse_data(self)
+      end
+
+      @pointers = {}
+      @blocks.each do |block|
+        if block.data.is_a?(Array)
+          pointer = block.pointer.location
+          block.data.each do |data|
+            @pointers[Pointer.new(pointer)] = data
+            pointer += data.class.definition.size
+          end
+        else
+          @pointers[block.pointer] = block.data
+        end
+      end
+
+      self
+    end
+
+    def dna_block
+      @blocks.find { |block| block.code == 'DNA1' }
+    end
+
+    def create_reader(file)
+      ObjectReader.new(file, self)
+    end
+  end
+end

data/lib/blender-3d/object_reader.rb

@@ -0,0 +1,47 @@
+module Blender3d
+  class ObjectReader
+    attr_reader :file
+    attr_accessor :model
+
+    def initialize(file, model = nil)
+      @file, @model = file, model
+      endian = @model.header.endian_code
+
+      %w'c s l q'.each.with_index do |code, i|
+        bytes = 1 << i
+        bits = 8 * bytes
+        name = 'int' + bits.to_s
+        define_reader name, bytes, code + endian
+        define_reader 'u' + name, bytes, code.upcase + endian
+      end
+
+      code = @model.header.little_endian? ? 'e' : 'g'
+      define_reader 'float', 4, code
+      define_reader 'double', 8, code.upcase
+
+      define_reader 'pointer', @model.header.pointer_size, @model.header.size_code + endian
+    end
+
+    private def define_reader(name, num_bytes, unpack_type)
+      instance_eval "def read_#{name}; @file.read(#{num_bytes}).unpack('#{unpack_type}').first end"
+    end
+
+    def read(length)
+      @file.read(length)
+    end
+
+    def read_string
+      @file.gets("\0")
+    end
+
+    def seek(position)
+      @file.seek(position)
+    end
+
+    def tell
+      @file.tell
+    end
+  end
+end
+
+

data/lib/blender-3d/pointer.rb

@@ -0,0 +1,27 @@
+module Blender3d
+  class Pointer
+    attr_reader :location
+
+    def initialize(location)
+      @location = location
+    end
+
+    def to_s
+      "Pointer(#{inspect})"
+    end
+
+    def inspect
+      return '0x0' if @location == 0
+      return '0x%08x' % @location if @location < (1 << 32)
+      '0x%016x' % @location
+    end
+
+    def <=>(other)
+      other.is_a?(Pointer) ? location <=> other.location : 1
+    end
+
+    def ==(other)
+      (self <=> other) == 0
+    end
+  end
+end

data/lib/blender-3d/structure.rb

@@ -0,0 +1,19 @@
+module Blender3d
+  class Structure
+    class << self
+      attr_reader :definition
+    end
+
+    def initialize(reader = nil)
+      deserialize(reader) if reader
+    end
+
+    def deserialize(reader)
+      self.class.definition.fields.each do |field|
+        value = field.type.read(reader)
+        instance_variable_set "@#{field.name}", value
+      end
+      self
+    end
+  end
+end

data/lib/blender-3d/structure_definition.rb

@@ -0,0 +1,27 @@
+module Blender3d
+  class StructureDefinition
+    attr_reader :name, :size, :fields
+
+    def initialize(name, size, fields = [])
+      name = name[0].upcase + name[1..-1]
+      @name, @size, @fields = name, size, fields
+    end
+
+    def read(reader)
+      structure_class.new(reader)
+    end
+
+    def structure_class
+      Blender3d.const_defined?(name, false) ? Blender3d.const_get(name, false) : define_structure_class
+    end
+
+    private
+
+      def define_structure_class
+        fields = self.fields
+        struct_class = Class.new(Structure) { attr_accessor(*fields.map(&:name)) }
+        struct_class.instance_variable_set :@definition, self
+        Blender3d.const_set(name, struct_class)
+      end
+  end
+end

data/lib/blender-3d/types.rb

@@ -0,0 +1,140 @@
+module Blender3d
+  class SimpleType
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      @name
+    end
+
+    def inspect
+      @name
+    end
+
+    def read(reader)
+      case @name
+        when 'char'     then reader.read(1)
+        when 'double'   then reader.read_double
+        when 'float'    then reader.read_float
+        when 'int'      then reader.read_int32
+        when 'int64_t'  then reader.read_int64
+        when 'long'     then reader.read_int32
+        when 'short'    then reader.read_int16
+        when 'uchar'    then reader.read_uint8
+        when 'uint64_t' then reader.read_uint64
+        when 'ulong'    then reader.read_uint32
+        when 'ushort'   then reader.read_uint16
+        else
+          dna = reader.model.dna_block.data
+          struct = dna.structures.find { |struct| struct.name == @name }
+          return struct.read(reader) if struct
+          length = dna.types.find { |name, size| name == @name }&.last
+          return reader.read(length) if length
+          raise 'type not found'
+      end
+    end
+  end
+
+  class PointerType
+    attr_reader :type
+
+    def initialize(type)
+      @type = type
+    end
+
+    def to_s
+      "Pointer(#@type)"
+    end
+
+    def inspect
+      "#{@type.inspect}*"
+    end
+
+    def read(reader)
+      Pointer.new(reader.read_pointer)
+    end
+  end
+
+  class FunctionPointerType
+    attr_reader :return_type
+
+    def initialize(return_type)
+      @return_type = return_type
+    end
+
+    def to_s
+      "Function(#@return_type)"
+    end
+
+    def inspect
+      "#{@return_type.inspect} (*)()"
+    end
+
+    def read(reader)
+      Pointer.new(reader.read_pointer)
+    end
+  end
+
+  # equivalent to PointerType<SimpleType<char>> (char*)
+  class NullTerminatedStringType
+    def to_s
+      "NullTerminatedString"
+    end
+
+    def inspect
+      'char*'
+    end
+
+    def read(reader)
+      reader.read_string.chop
+    end
+  end
+
+  # equivalent to ArrayType<SimpleType<char>, length> (char[length])
+  class FixedLengthStringType
+    attr_reader :length
+
+    def initialize(length)
+      @length = length
+    end
+
+    def to_s
+      "FixedLengthString(#@length)"
+    end
+
+    def inspect
+      "char[#@length]"
+    end
+
+    def read(reader)
+      reader.read(@length).gsub(/\0.*$/, '')
+    end
+  end
+
+  class ArrayType
+    attr_reader :type, :size
+
+    def initialize(type, size)
+      @type, @size = type, size
+    end
+
+    def dimensions
+      @sizes.size
+    end
+
+    def to_s
+      "Array[#@size](#@type)"
+    end
+
+    def inspect
+      "#{@type.inspect}[#@size]"
+    end
+
+    def read(reader)
+      @size.times.map { @type.read(reader) }
+    end
+  end
+end

data/lib/blender-3d/version.rb

@@ -0,0 +1,3 @@
+module Blender3d
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: blender-3d
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- SilverPhoenix99
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-03 00:00:00.000000000 Z
+dependencies: []
+description: Blender 3d file parser.
+email:
+- silver.phoenix99@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/blender-3d.rb
+- lib/blender-3d/char_field_parser.rb
+- lib/blender-3d/dna_block.rb
+- lib/blender-3d/field.rb
+- lib/blender-3d/field_parser_factory.rb
+- lib/blender-3d/file_block.rb
+- lib/blender-3d/file_header.rb
+- lib/blender-3d/generic_field_parser.rb
+- lib/blender-3d/model.rb
+- lib/blender-3d/object_reader.rb
+- lib/blender-3d/pointer.rb
+- lib/blender-3d/structure.rb
+- lib/blender-3d/structure_definition.rb
+- lib/blender-3d/types.rb
+- lib/blender-3d/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Blender 3d file parser.
+test_files: []