mittsu 0.1.0

data/lib/mittsu.rb

@@ -0,0 +1,15 @@
+require "pry"
+
+require "mittsu/version"
+require "mittsu/math"
+require "mittsu/core"
+require "mittsu/cameras"
+require "mittsu/extras"
+require "mittsu/lights"
+require "mittsu/loaders"
+require "mittsu/materials"
+require "mittsu/objects"
+require "mittsu/renderers"
+require "mittsu/scenes"
+require "mittsu/textures"
+require "mittsu/constants"

data/lib/mittsu/cameras.rb

@@ -0,0 +1,4 @@
+require 'mittsu/cameras/camera'
+require 'mittsu/cameras/cube_camera'
+require 'mittsu/cameras/orthographic_camera'
+require 'mittsu/cameras/perspective_camera'

data/lib/mittsu/cameras/camera.rb

@@ -0,0 +1,34 @@
+require 'mittsu'
+
+module Mittsu
+  class Camera < Object3D
+    attr_accessor :projection_matrix, :matrix_world_inverse
+
+    def initialize
+      super
+
+      @type = 'Camera'
+      @matrix_world_inverse = Matrix4.new
+      @projection_matrix = Matrix4.new
+    end
+
+    def get_world_direction(target = Vector3.new)
+      @_quaternion ||= Quaternion.new
+      self.get_world_quaternion(@_quaternion)
+      target.set(0.0, 0.0, -1.0).qpply_quaternion(@_quaternion)
+    end
+
+    def look_at(vector)
+      @_m1 ||= Matrix4.new
+      @_m1.look_at(@position, vector, @up)
+      @quaternion.set_from_rotation_matrix(@_m1)
+    end
+
+    def clone(camera = Camera.new)
+      super
+      camera.matrix_world_inverse.copy(@matrix_world_inverse)
+      camera.projection_matrix.copy(@projection_matrix)
+      camera
+    end
+  end
+end

data/lib/mittsu/cameras/cube_camera.rb

@@ -0,0 +1,74 @@
+require 'mittsu'
+
+module Mittsu
+  class CubeCamera < Object3D
+    attr_accessor :render_target
+
+    def initialize(near, far, cube_resolution)
+      super()
+
+      @type = 'CubeCamera'
+
+      fov = 90.0
+      aspect = 1.0
+
+      @camera_px = Mittsu::PerspectiveCamera.new(fov, aspect, near, far)
+      @camera_px.up.set(0.0, -1.0, 0.0)
+      @camera_px.look_at(Mittsu::Vector3.new(1.0, 0.0, 0.0))
+      self.add(@camera_px)
+
+      @camera_nx = Mittsu::PerspectiveCamera.new(fov, aspect, near, far)
+      @camera_nx.up.set(0.0, -1.0, 0.0)
+      @camera_nx.look_at(Mittsu::Vector3.new(-1.0, 0.0, 0.0))
+      self.add(@camera_nx)
+
+      @camera_py = Mittsu::PerspectiveCamera.new(fov, aspect, near, far)
+      @camera_py.up.set(0.0, 0.0, 1.0)
+      @camera_py.look_at(Mittsu::Vector3.new(0.0, 1.0, 0.0))
+      self.add(@camera_py)
+
+      @camera_ny = Mittsu::PerspectiveCamera.new(fov, aspect, near, far)
+      @camera_ny.up.set(0.0, 0.0, 1.0)
+      @camera_ny.look_at(Mittsu::Vector3.new(0.0, -1.0, 0.0))
+      self.add(@camera_ny)
+
+      @camera_pz = Mittsu::PerspectiveCamera.new(fov, aspect, near, far)
+      @camera_pz.up.set(0.0, -1.0, 0.0)
+      @camera_pz.look_at(Mittsu::Vector3.new(0.0, 0.0, 1.0))
+      self.add(@camera_pz)
+
+      @camera_nz = Mittsu::PerspectiveCamera.new(fov, aspect, near, far)
+      @camera_nz.up.set(0.0, -1.0, 0.0)
+      @camera_nz.look_at(Mittsu::Vector3.new(0.0, 0.0, -1.0))
+      self.add(@camera_nz)
+
+      @render_target = Mittsu::OpenGLRenderTargetCube(cube_resolution, cube_resolution, format: Mittsu::RGBFormat, mag_filter: Mittsu::LinearFilter, min_filter: Mittsu::LinearFilter)
+    end
+
+    def update_cube_map(renderer, scene)
+      generate_mipmaps = render_target.generate_mipmaps
+
+      render_target.generate_mipmaps = false
+
+      render_target.active_cube_face = 0
+      renderer.render(scene, @camera_px, render_target)
+
+      render_target.active_cube_face = 1
+      renderer.render(scene, @camera_nx, render_target)
+
+      render_target.active_cube_face = 2
+      renderer.render(scene, @camera_py, render_target)
+
+      render_target.active_cube_face = 3
+      renderer.render(scene, @camera_ny, render_target)
+
+      render_target.active_cube_face = 4
+      renderer.render(scene, @camera_pz, render_target)
+
+      render_target.generate_mipmaps = generate_mipmaps
+
+      render_target.active_cube_face = 5
+      renderer.render(scene, @camera_nz, render_target)
+    end
+  end
+end

data/lib/mittsu/cameras/orthographic_camera.rb

@@ -0,0 +1,53 @@
+require 'mittsu'
+
+module Mittsu
+  class OrthographicCamera < Camera
+    attr_accessor :zoom, :left, :right, :top, :bottom, :near, :far
+
+    def initialize(left, right, top, bottom, near = 0.1, far = 2000.0)
+      super()
+
+      @type = 'OrthographicCamera'
+
+      @zoom = 1.0
+
+      @left = left.to_f
+      @right = right.to_f
+      @top = top.to_f
+      @bottom = bottom.to_f
+
+      @near = near.to_f
+      @far = far.to_f
+
+      update_projection_matrix
+    end
+
+    def update_projection_matrix
+      dx = (right - left) / (2.0 * zoom)
+      dy = (top - bottom) / (2.0 * zoom)
+      cx = (right - left) / 2.0
+      cy = (top - bottom) / 2.0
+
+      projection_matrix.make_orthographic(cx - dx, cx + dx, cy + dy, cy - dy, near, far)
+    end
+
+    def clone
+      camera = Mittsu::OrthographicCamera.new
+      super(camera)
+
+      camera.zoom = zoom
+
+      camera.left = left
+      camera.right = right
+      camera.top = top
+      camera.bottom = bottom
+
+      camera.near = near
+      camera.far = far
+
+      camera.projection_matrix.copy()
+
+      camera
+    end
+  end
+end

data/lib/mittsu/cameras/perspective_camera.rb

@@ -0,0 +1,115 @@
+require 'mittsu'
+
+module Mittsu
+  class PerspectiveCamera < Camera
+    attr_accessor :zoom, :fov, :aspect, :near, :far
+
+    def initialize(fov = 50.0, aspect = 1.0, near = 0.1, far = 2000.0)
+      super()
+
+      @type = 'PerspectiveCamera'
+
+      @zoom = 1.0
+
+      @fov = fov.to_f
+      @aspect = aspect.to_f
+      @near = near.to_f
+      @far = far.to_f
+
+      update_projection_matrix
+    end
+
+    # Uses Focal Length (in mm) to estimate and set FOV
+    # 35mm (fullframe) camera is used if frame size is not specified;
+    # Formula based on http://www.bobatkins.com/photography/technical/field_of_view.html
+    def set_lens(focal_length, frame_height = 24.0)
+      @fov = 2.0 * Math.rad_to_deg(Math.atan(frame_height / (focal_length * 2.0)))
+      update_projection_matrix
+    end
+
+    # Sets an offset in a larger frustum. This is useful for multi-window or
+    # multi-monitor/multi-machine setups.
+    #
+    # For example, if you have 3x2 monitors and each monitor is 1920x1080 and
+    # the monitors are in grid like this
+    #
+    # +---+---+---+
+    # | A | B | C |
+    # +---+---+---+
+    # | D | E | F |
+    # +---+---+---+
+    #
+    # then for each monitor you would call it like this
+    #
+    # var w = 1920;
+    # var h = 1080;
+    # var fullWidth = w * 3;
+    # var fullHeight = h * 2;
+    #
+    # --A--
+    # camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
+    # --B--
+    # camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
+    # --C--
+    # camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
+    # --D--
+    # camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
+    # --E--
+    # camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
+    # --F--
+    # camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
+    #
+    # Note there is no reason monitors have to be the same size or in a grid.
+
+    def set_view_offset(full_width, full_height, x, y, width, height)
+      @full_width = full_width
+      @full_height = full_height
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+
+      update_projection_matrix
+    end
+
+    def update_projection_matrix
+      new_fov = Math.rad_to_deg(2.0 * Math.atan(Math.tan(Math.deg_to_rad(@fov) * 0.5) / @zoom))
+
+      if @full_width
+        aspect = @full_width / @full_height
+        top = Math.tan(Math.deg_to_rad(new_fov * 0.5)) * @near
+        bottom = -top
+        left = aspect * bottom
+        right = aspect * top
+        width = (right - left).abs
+        height = (top - bottom).abs
+
+        projection_matrix.make_frustum(
+          left + @x * width / @full_width,
+          left + (@x + @width) * width / @full_width,
+          top - (@y + @height) * height / @full_height,
+          top - @y * height / @full_height,
+          @near,
+          @far
+        )
+      else
+        projection_matrix.make_perspective(new_fov, @aspect, @near, @far)
+      end
+    end
+
+    def clone
+      camera = Mittsu::PerspectiveCamera.new
+      super(camera)
+
+      camera.zoom = zoom
+      camera.fov = fov
+      camera.aspect = aspect
+      camera.near = near
+      camera.far = far
+
+      camera.projection_matrix.copy(projection_matrix)
+
+      camera
+    end
+  end
+end

data/lib/mittsu/constants.rb

@@ -0,0 +1,160 @@
+module Mittsu
+  MOUSE_LEFT = 0
+  MOUSE_MIDDLE = 1
+  MOUSE_RIGHT = 2
+
+  # GL STATE CONSTANTS
+
+  CullFaceNone = 0
+  CullFaceBack = 1
+  CullFaceFront = 2
+  CullFaceFrontBack = 3
+
+  FrontFaceDirectionCW = 0
+  FrontFaceDirectionCCW = 1
+
+  # SHADOWING TYPES
+
+  BasicShadowMap = 0
+  PCFShadowMap = 1
+  PCFSoftShadowMap = 2
+
+  # MATERIAL CONSTANTS
+
+  # side
+
+  FrontSide = 0
+  BackSide = 1
+  DoubleSide = 2
+
+  # shading
+
+  NoShading = false
+  FlatShading = 1
+  SmoothShading = 2
+
+  # colors
+
+  NoColors = false
+  FaceColors = 1
+  VertexColors = 2
+
+  # blending modes
+
+  NoBlending = false
+  NormalBlending = 1
+  AdditiveBlending = 2
+  SubtractiveBlending = 3
+  MultiplyBlending = 4
+  CustomBlending = 5
+
+  # custom blending equations
+  # (numbers start from 100 not to clash with other
+  #  mappings to OpenGL constants defined in texture.rb)
+
+  AddEquation = 100
+  SubtractEquation = 101
+  ReverseSubtractEquation = 102
+  MinEquation = 103
+  MaxEquation = 104
+
+  # custom blending destination factors
+  ZeroFactor = 200
+  OneFactor = 201
+  SrcColorFactor = 202
+  OneMinusSrcColorFactor = 203
+  SrcAlphaFactor = 204
+  OneMinusSrcAlphaFactor = 205
+  DstAlphaFactor = 206
+  OneMinusDstAlphaFactor = 207
+
+  # custom blending source factors
+
+  #ZeroFactor = 200
+  #OneFactor = 201
+  #SrcAlphaFactor = 204
+  #OneMinusSrcAlphaFactor = 205
+  #DstAlphaFactor = 206
+  #OneMinusDstAlphaFactor = 207
+  DstColorFactor = 208
+  OneMinusDstColorFactor = 209
+  SrcAlphaSaturateFactor = 210
+
+  # TEXTURE CONSTANTS
+
+  MultiplyOperation = 0
+  MixOperation = 1
+  AddOperation = 2
+
+  # Mapping modes
+
+  UVMapping = 300
+
+  CubeReflectionMapping = 301
+  CubeRefractionMapping = 302
+
+  EquirectangularReflectionMapping = 303
+  EquirectangularRefractionMapping = 304
+
+  SphericalReflectionMapping = 305
+
+  # Wrapping modes
+
+  RepeatWrapping = 1000
+  ClampToEdgeWrapping = 1001
+  MirroredRepeatWrapping = 1002
+
+  # Filters
+
+  NearestFilter = 1003
+  NearestMipMapNearestFilter = 1004
+  NearestMipMapLinearFilter = 1005
+  LinearFilter = 1006
+  LinearMipMapNearestFilter = 1007
+  LinearMipMapLinearFilter = 1008
+
+  # Data types
+
+  UnsignedByteType = 1009
+  ByteType = 1010
+  ShortType = 1011
+  UnsignedShortType = 1012
+  IntType = 1013
+  UnsignedIntType = 1014
+  FloatType = 1015
+  HalfFloatType = 1025
+
+  # Pixel types
+
+  #UnsignedByteType = 1009
+  UnsignedShort4444Type = 1016
+  UnsignedShort5551Type = 1017
+  UnsignedShort565Type = 1018
+
+  # Pixel formats
+
+  AlphaFormat = 1019
+  RGBFormat = 1020
+  RGBAFormat = 1021
+  LuminanceFormat = 1022
+  LuminanceAlphaFormat = 1023
+  # RGBEFormat handled as RGBAFormat in shaders
+  RGBEFormat = RGBAFormat #1024
+
+  # DDS / ST3C Compressed texture formats
+
+  RGB_S3TC_DXT1_Format = 2001
+  RGBA_S3TC_DXT1_Format = 2002
+  RGBA_S3TC_DXT3_Format = 2003
+  RGBA_S3TC_DXT5_Format = 2004
+
+  # PVRTC compressed texture formats
+
+  RGB_PVRTC_4BPPV1_Format = 2100
+  RGB_PVRTC_2BPPV1_Format = 2101
+  RGBA_PVRTC_4BPPV1_Format = 2102
+  RGBA_PVRTC_2BPPV1_Format = 2103
+
+  LineStrip = 0
+  LinePieces = 1
+end