mittsu 0.1.0

data/lib/mittsu/materials/mesh_face_material.rb

@@ -0,0 +1,30 @@
+require 'securerandom'
+
+module Mittsu
+  class MeshFaceMaterial
+    def initialize(materials = [])
+      @uuid = SecureRandom.uuid
+      @type = 'MeshFaceMaterial'
+      @materials = materials
+    end
+
+    def to_json
+      {
+        metadata: {
+          version: 4.2,
+          type: 'material',
+          generator: 'MaterialExporter'
+        },
+        uuid: @uuid,
+        type: @type,
+        materials: @materials.map(&:to_json)
+      }
+    end
+
+    def clone
+      MeshFaceMaterial.new.tap do |mateiral|
+        material.materials = @materials.map(&:clone)
+      end
+    end
+  end
+end

data/lib/mittsu/materials/mesh_lambert_material.rb

@@ -0,0 +1,126 @@
+require 'mittsu/materials/material'
+
+module Mittsu
+  # parameters: {
+  #   color: <hex>,
+  #   emissive: <hex>,
+  #   opacity: <float>,
+  #
+  #   map: Texture.new( <Image> ),
+  #
+  #   light_map: Texture.( <Image> ),
+  #
+  #   specular_map: Texture.new( <Image> ),
+  #
+  #   alpha_map: Texture.new( <Image> ),
+  #
+  #   env_map: TextureCube.new( [posx, negx, posy, negy, posz, negz]),
+  #   combine: Multiply,
+  #   reflectivity: <float>,
+  #   refraction_ratio: <float>,
+  #
+  #   shading: SmoothShading,
+  #   blending: NormalBlending,
+  #   depth_test: <bool>,
+  #   depth_write: <bool>,
+  #
+  #   wireframe: <boolean>,
+  #   wireframe_linewidth: <float>,
+  #
+  #   vertex_colors: NoColors / VertexColors / FaceColors,
+  #
+  #   skinning: <bool>,
+  #   morph_targets: <bool>,
+  #   morph_normals: <bool>,
+  #
+  #   fog: <bool>
+  # }
+
+  class MeshLambertMaterial < Material
+    attr_accessor :emissive, :shading, :wireframe_linewidth, :wireframe_linecap, :wireframe_linejoin
+
+    def initialize(parameters = {})
+      super()
+
+      @type = 'MeshLambertMaterial'
+
+      @color = Color.new(0xffffff) # diffuse
+      @emissive = Color.new(0x000000)
+
+      @wrap_around = false
+      @wrap_rbg = Vector3.new(1.0, 1.0, 1.0)
+
+      @map = nil
+
+      @light_map = nil
+
+      @specular_map = nil
+
+      @alpha_map = nil
+
+      @env_map = nil
+      @combine = MultiplyOperation
+      @reflectivity = 1.0
+      @refraction_ratio = 0.98
+
+      @fog = true
+
+      @shading = SmoothShading
+
+      @wireframe = false
+      @wireframe_linewidth = 1.0
+      @wireframe_linecap = :round
+      @wireframe_linejoin = :round
+
+      @vertex_colors = NoColors
+
+      @skinning = false
+      @morph_targets = false
+      @morph_normals = false
+
+      self.set_values(parameters)
+    end
+
+    def clone
+      material = MeshLambertMaterial.new
+
+      super(material)
+
+      material.color.copy(@color)
+      material.emissive.copy(@color)
+
+      material.wrap_around = @wrap_around
+      material.wrap_rgb.copy(@wrap_rbg)
+
+      material.map = @map
+
+      material.light_map = @light_map
+
+      material.specular_map = @specular_map
+
+      material.alpha_map = @alpha_map
+
+      material.env_map = @env_map
+      material.combine = @combine
+      material.reflectivity = @reflectivity
+      material.refraction_ratio = @refraction_ratio
+
+      material.fog = @fog
+
+      material.shading = @shading
+
+      material.wireframe = @wireframe
+      material.wireframe_linewidth = @wireframe_linewidth
+      material.wireframe_linecap = @wireframe_linecap
+      material.wireframe_linejoin = @wireframe_linejoin
+
+      material.vertex_colors = @vertex_colors
+
+      material.skinning = @skinning
+      material.morph_targets = @morph_targets
+      material.morph_normals = @morph_normals
+
+      material
+    end
+  end
+end

data/lib/mittsu/materials/mesh_phong_material.rb

@@ -0,0 +1,152 @@
+#  parameters = {
+#   color: <hex>,
+#   emissive: <hex>,
+#   specular: <hex>,
+#   shininess: <float>,
+#   opacity: <float>,
+#
+#   map: Texture.new(<Image>),
+#
+#   lightMap: Texture.new(<Image>),
+#
+#   bumpMap: Texture.new(<Image>),
+#   bumpScale: <float>,
+#
+#   normalMap: Texture.new(<Image>),
+#   normalScale: <Vector2>,
+#
+#   specularMap: Texture.new(<Image>),
+#
+#   alphaMap: Texture.new(<Image>),
+#
+#   envMap: TextureCube.new([posx, negx, posy, negy, posz, negz]),
+#   combine: Multiply,
+#   reflectivity: <float>,
+#   refractionRatio: <float>,
+#
+#   shading: SmoothShading,
+#   blending: NormalBlending,
+#   depthTest: <bool>,
+#   depthWrite: <bool>,
+#
+#   wireframe: <boolean>,
+#   wireframeLinewidth: <float>,
+#
+#   vertexColors: NoColors / VertexColors / FaceColors,
+#
+#   skinning: <bool>,
+#   morphTargets: <bool>,
+#   morphNormals: <bool>,
+#
+# 	fog: <bool>
+#  }
+
+module Mittsu
+  class MeshPhongMaterial < Material
+    attr_accessor :normal_scale, :shininess, :emissive, :specular
+
+    def initialize(parameters = {})
+      super()
+
+    	@type = 'MeshPhongMaterial'
+
+    	@color = Color.new(0xffffff) # diffuse
+    	@emissive = Color.new(0x000000)
+    	@specular = Color.new(0x111111)
+    	@shininess = 30.0
+
+    	@metal = false
+
+    	@wrap_around = false
+    	@wrap_rgb = Vector3.new(1.0, 1.0, 1.0)
+
+    	@map = nil
+
+    	@light_map = nil
+
+    	@bump_map = nil
+    	@bump_scale = 1.0
+
+    	@normal_map = nil
+    	@normal_scale = Vector2.new(1.0, 1.0)
+
+    	@specular_map = nil
+
+    	@alpha_map = nil
+
+    	@env_map = nil
+    	@combine = MultiplyOperation
+    	@reflectivity = 1.0
+    	@refraction_ratio = 0.98
+
+    	@fog = true
+
+    	@shading = SmoothShading
+
+    	@wireframe = false
+    	@wireframe_linewidth = 1.0
+    	@wireframe_linecap = 'round'
+    	@wireframe_linejoin = 'round'
+
+    	@vertex_colors = NoColors
+
+    	@skinning = false
+    	@morph_targets = false
+    	@morph_normals = false
+
+    	self.set_values(parameters)
+    end
+
+    def clone
+      material = MeshPhongMaterial.new
+
+      super(material)
+
+    	material.color.copy(@color)
+    	material.emissive.copy(@emissive)
+    	material.specular.copy(@specular)
+    	material.shininess = @shininess
+
+    	material.metal = @metal
+
+    	material.wrap_around = @wrap_around
+    	material.wrap_rgb.copy(@wrap_rgb)
+
+    	material.map = @map
+
+    	material.light_map = @light_map
+
+    	material.bump_map = @bump_map
+    	material.bump_scale = @bump_scale
+
+    	material.normal_map = @normal_map
+    	material.normal_scale.copy(@normal_scale)
+
+    	material.specular_map = @specular_map
+
+    	material.alpha_map = @alpha_map
+
+    	material.env_map = @env_map
+    	material.combine = @combine
+    	material.reflectivity = @reflectivity
+    	material.refraction_ratio = @refraction_ratio
+
+    	material.fog = @fog
+
+    	material.shading = @shading
+
+    	material.wireframe = @wireframe
+    	material.wireframe_linewidth = @wireframe_linewidth
+    	material.wireframe_linecap = @wireframe_linecap
+    	material.wireframe_linejoin = @wireframe_linejoin
+
+    	material.vertex_colors = @vertex_colors
+
+    	material.skinning = @skinning
+    	material.morph_targets = @morph_targets
+    	material.morph_normals = @morph_normals
+
+    	material
+    end
+  end
+end

data/lib/mittsu/materials/shader_material.rb

@@ -0,0 +1,108 @@
+# @author alteredq / http://alteredqualia.com/
+#
+#  parameters = {
+#    defines: { "label" : "value" },
+#    uniforms: { "parameter1": { type: "f", value: 1.0 }, "parameter2": { type: "i" value2: 2 } },
+#
+#    fragmentShader: <string>,
+#    vertexShader: <string>,
+#
+#    shading: THREE.SmoothShading,
+#    blending: THREE.NormalBlending,
+#    depthTest: <bool>,
+#    depthWrite: <bool>,
+#
+#    wireframe: <boolean>,
+#    wireframeLinewidth: <float>,
+#
+#    lights: <bool>,
+#
+#    vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
+#
+#    skinning: <bool>,
+#    morphTargets: <bool>,
+#    morphNormals: <bool>,
+#
+#  	 fog: <bool>
+#  }
+
+module Mittsu
+  class ShaderMaterial < Material
+    attr_accessor :fragment_shader, :vertex_shader, :attributes, :defines, :shading, :wireframe, :wireframe_linewidth, :fog, :lights, :vertex_colors, :skinning, :morph_targets, :morph_normals
+
+    def initialize(parameters = {})
+      super()
+
+      @type = 'ShaderMaterial'
+      @defines = {}
+      @uniforms = {}
+      @attributes = nil
+
+      @vertex_shader = 'void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}'
+      @fragment_shader = 'void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}'
+
+      @shading = SmoothShading
+
+      @line_width = 1
+
+      @wireframe = false
+      @wireframe_linewidth = 1
+
+      @fog = false # set to use scene fog
+
+      @lights = false # set to use scene lights
+
+      @vertex_colors = NoColors # set to use "color" attribute stream
+
+      @skinning = false # set to use skinning attribute streams
+
+      @morph_targets = false # set to use morph targets
+      @morph_normals = false # set to use morph normals
+
+	    # When rendered geometry doesn't include these attributes but the material does,
+	    # use these default values in WebGL. This avoids errors when buffer data is missing.
+      @default_attributes_values = {
+        'color' => [1.0, 1.0, 1.0],
+        'uv' => [0, 0],
+        'uv2' => [0, 0]
+      }
+
+      # TODO: necessary?
+    	# this.index0AttributeName = undefined;
+
+      self.set_values(parameters)
+    end
+
+    def clone
+      material = ShaderMaterial.new
+
+      super.clone(material)
+
+    	material.fragment_shader = @fragment_shader
+    	material.vertex_shader = @vertex_shader
+
+    	material.uniforms = UniformsUtils.clone(@uniforms)
+
+    	material.attributes = @attributes
+    	material.defines = @defines
+
+    	material.shading = @shading
+
+    	material.wireframe = @wireframe
+    	material.wireframe_linewidth = @wireframe_linewidth
+
+    	material.fog = @fog
+
+    	material.lights = @lights
+
+    	material.vertex_colors = @vertex_colors
+
+    	material.skinning = @skinning
+
+    	material.morph_targets = @morph_targets
+    	material.morph_normals = @morph_normals
+
+	    material
+    end
+  end
+end

data/lib/mittsu/math.rb

@@ -0,0 +1,105 @@
+require 'mittsu/math/box2'
+require 'mittsu/math/box3'
+require 'mittsu/math/color'
+require 'mittsu/math/color_keywords'
+require 'mittsu/math/euler'
+require 'mittsu/math/frustum'
+require 'mittsu/math/line3'
+require 'mittsu/math/matrix3'
+require 'mittsu/math/matrix4'
+require 'mittsu/math/plane'
+require 'mittsu/math/quaternion'
+require 'mittsu/math/ray'
+require 'mittsu/math/sphere'
+require 'mittsu/math/spline'
+require 'mittsu/math/triangle'
+require 'mittsu/math/vector2'
+require 'mittsu/math/vector3'
+require 'mittsu/math/vector4'
+
+BuiltInMath = Math
+
+module Mittsu
+  module Math
+    extend BuiltInMath
+    include BuiltInMath
+    BuiltInMath.methods.each { |m| public_class_method m }
+
+    def self.sign(x)
+      return Float::NAN unless x.is_a? Numeric
+      return Float::NAN if x.to_f.nan?
+      return x.to_f if x.zero?
+      return (x < 0) ? -1.0 : (x > 0) ? 1.0 : +x
+    end
+
+    def self.clamp(x, a, b)
+      ( x < a ) ? a : ( ( x > b ) ? b : x )
+    end
+
+    def self.clamp_bottom(x, a)
+      x < a ? a : x
+    end
+
+    def self.map_linear(x, a1, a2, b1, b2)
+      b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 )
+    end
+
+    def self.smooth_step(x, min, max)
+  		return 0.0 if x <= min
+  		return 1.0 if x >= max
+
+  		x = ( x - min ) / ( max - min )
+
+  	   x * x * ( 3.0 - 2.0 * x )
+    end
+
+    def self.smoother_step(x, min, max)
+  		return 0.0 if x <= min
+  		return 1.0 if x >= max
+
+  		x = ( x - min ) / ( max - min )
+
+  		x * x * x * ( x * ( x * 6.0 - 15.0 ) + 10.0 )
+    end
+
+    def self.random16
+      ( 65280 * rand + 255 * rand ) / 65535
+    end
+
+    def self.rand_int(low, high)
+      self.rand_float( low, high ).floor
+    end
+
+    def self.rand_float(low, high)
+      low + rand * ( high - low )
+    end
+
+    def self.rand_float_spread(range)
+      range * ( 0.5 - rand )
+    end
+
+    DEGREE_TO_RADIANS_FACTOR = ::Math::PI / 180
+    def self.deg_to_rad(degrees)
+      degrees * DEGREE_TO_RADIANS_FACTOR
+    end
+
+    RADIANS_TO_DEGREES_FACTOR = 180 / ::Math::PI
+    def self.rad_to_deg(radians)
+      radians * RADIANS_TO_DEGREES_FACTOR
+    end
+
+    def self.power_of_two?(value)
+      ( value & ( value - 1 ) ) == 0 && value != 0
+    end
+
+    def self.next_power_of_two(value)
+  		value -= 1
+  		value |= value >> 1
+  		value |= value >> 2
+  		value |= value >> 4
+  		value |= value >> 8
+  		value |= value >> 16
+  		value += 1
+    end
+  end
+end