mittsu 0.1.0 → 0.1.1

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p353

data/Gemfile

@@ -1,4 +1,5 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in mittsu.gemspec
 gemspec
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Daniel Smith
+Copyright (c) 2015-2016 Daniel Smith
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,11 +1,27 @@
 # Mittsu
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mittsu`. To experiment with that code, run `bin/console` for an interactive prompt.
+[![Gem Version](https://badge.fury.io/rb/mittsu.svg)](https://badge.fury.io/rb/mittsu) [![Dependency Status](https://gemnasium.com/jellymann/mittsu.svg)](https://gemnasium.com/jellymann/mittsu) [![Circle CI](https://circleci.com/gh/jellymann/mittsu/tree/master.svg?style=shield)](https://circleci.com/gh/jellymann/mittsu/tree/master) [![Test Coverage](https://codeclimate.com/github/jellymann/mittsu/badges/coverage.svg)](https://codeclimate.com/github/jellymann/mittsu/coverage) [![Code Climate](https://codeclimate.com/github/jellymann/mittsu/badges/gpa.svg)](https://codeclimate.com/github/jellymann/mittsu)
 
-TODO: Delete this and the text above, and describe your gem
+3D Graphics Library for Ruby
+
+Mittsu makes 3D graphics easier by providing an abstraction over OpenGL, and is based heavily off of [THREE.js](http://threejs.org). No more weird pointers and wondering about the difference between a VAO and a VBO (besides the letter). Simply think of something awesome and make it!
 
 ## Installation
 
+Install the prerequisites:
+
+Mittsu depends on Ruby 2.x, OpenGL 3.3+, GLFW 3.1.x and ImageMagick 6.4.9+
+
+```bash
+# OSX
+$ brew intall glfw3 imagemagick
+
+# Ubuntu
+$ sudo apt-get install libglfw3-dev libmagickwand-dev
+```
+
+**NOTE**: On Ubuntu, you may need to install `libgl1-mesa-dev` for the OpenGL dependency.
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -22,18 +38,168 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### tl;dr
+
+Copy-Paste and Run:
+
+```ruby
+require 'mittsu'
+
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+ASPECT = SCREEN_WIDTH.to_f / SCREEN_HEIGHT.to_f
 
-## Development
+renderer = Mittsu::OpenGLRenderer.new width: SCREEN_WIDTH, height: SCREEN_HEIGHT, title: 'Hello, World!'
+
+scene = Mittsu::Scene.new
+
+camera = Mittsu::PerspectiveCamera.new(75.0, ASPECT, 0.1, 1000.0)
+camera.position.z = 5.0
+
+box = Mittsu::Mesh.new(
+  Mittsu::BoxGeometry.new(1.0, 1.0, 1.0),
+  Mittsu::MeshBasicMaterial.new(color: 0x00ff00)
+)
+
+scene.add(box)
+
+renderer.window.run do
+  box.rotation.x += 0.1
+  box.rotation.y += 0.1
+
+  renderer.render(scene, camera)
+end
+```
+
+### Step by Step
+
+First, we need to require Mittsu in order to use it:
+```ruby
+require 'mittsu'
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+Then, we'll define some constants to help us with setting up our 3D environment:
+```ruby
+SCREEN_WIDTH = 800
+SCREEN_HEIGHT = 600
+ASPECT = SCREEN_WIDTH.to_f / SCREEN_HEIGHT.to_f
+```
+
+The aspect ratio will be used for setting up the camera later.
+
+Once we have all that we can create the canvas we will use to draw our graphics onto. In Mittsu this is called a renderer. It provides a window and an OpenGL context:
+
+```ruby
+renderer = Mittsu::OpenGLRenderer.new width: SCREEN_WIDTH, height: SCREEN_HEIGHT, title: 'Hello, World!'
+```
+This will give us an 800x600 window with the title `Hello, World!`.
+
+Now that we have our canvas, let's start setting up the scene we wish to draw onto it:
+
+```ruby
+scene = Mittsu::Scene.new
+```
+
+A scene is like a stage where all our 3D objects live and animate.
+
+We can't draw a 3D scene without knowing where we're looking:
+
+```ruby
+camera = Mittsu::PerspectiveCamera.new(75.0, ASPECT, 0.1, 1000.0)
+```
+
+This camera has a 75° field-of-view (FOV), the aspect ratio of the window (which we defined earlier), and shows everything between a distance of 0.1 to 1000.0 away from the camera.
+
+The camera starts off at the origin `[0,0,0]` and faces the negative Z-axis. We'll position it somewhere along the positive Z-axis so that it is looking at the center of the scene from a short distance:
+
+```ruby
+camera.position.z = 5.0
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Our scene isn't going to be very exciting if there is nothing in it, so we'll create a box:
+
+```ruby
+box = Mittsu::Mesh.new(
+  Mittsu::BoxGeometry.new(1.0, 1.0, 1.0),
+  Mittsu::MeshBasicMaterial.new(color: 0x00ff00)
+)
+```
+
+A `Mesh` in Mittsu is the combination of a `Geometry` (the shape of the object) and a `Material` (the "look" of the object). Here we've created a 1x1x1 box that is colored green.
+
+Box in hand, we make it part of our scene:
+
+```ruby
+scene.add(box)
+```
+
+Here comes the fun part... the render loop!
+
+```ruby
+renderer.window.run do
+```
+
+The given block is called every frame. This is where you can tell the renderer what scene to draw, and do any updates to the objects in your scene.
+
+Just to make things a bit more interesting, we'll make the box rotate around its X and Y axes, so that it spins like crazy.
+
+```ruby
+box.rotation.x += 0.1
+box.rotation.y += 0.1
+```
+
+Last but not least, we tell the renderer to draw our scene this frame, which will tell the graphics processor to draw our green box with its updated rotation.
+
+```ruby
+renderer.render(scene, camera)
+```
+
+Easy peasy! :)
+
+```ruby
+end
+```
+
+
+### More Resources
+
+Mittsu follows a similar structure to THREE.js, so you can generally use [the same documentation](http://threejs.org/docs/) for a description of the various classes and how they work.
+
+If you just want to see what Mittsu can do and how to do it, take a peek inside the `examples` folder.
+
+## Where you can help
+
+1. Testing!
+
+    Currently the only unit tests are for most of the maths library, otherwise the library is tested by running the examples and checking that they look correct.
+
+2. Refactoring!
+
+    The code is unfortunately still a mess. Mittsu started out as a direct port of THREE.js, and JavaScript to Ruby is not an exact science.
+
+3. Find Bugs!
+
+    Mittsu is still very young, and there are plenty of small bugs and glitches that need to be ironed out. If you find a bug, create an issue so we can track it and squash it.
+
+4. Add all the features!
+
+    Some of the things I'd like to see ported from THREE.js include:
+
+    * Picking (clicking on 3D objects in a scene)
+    * Bone structure/animation (e.g. for character movements)
+    * Lens Flares! (for JJ Abrams)
+    * All the Extras and Helpers (who doesn't need extra help?)
+
+5. Write documentation!
+
+    You can use the same docs as THREE.js for now, but I would like to provide Mittsu-specific documentation so devs don't have to keep replacing `new THREE.Thing()` with `Mittsu::Thing.new`.
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/mittsu/fork )
+1. Fork it ( https://github.com/jellymann/mittsu/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+Thank you for helping me help you help us all. ;)

data/circle.yml

@@ -0,0 +1,20 @@
+## Customize the test machine
+machine:
+
+  # Version of ruby to use
+  ruby:
+    version:
+      2.0.0
+
+## Customize dependencies
+dependencies:
+  cache_directories:
+    - glfw-3.1.2
+  pre:
+    - sudo apt-get update; sudo apt-get install cmake xorg-dev libgl1-mesa-dev
+    - bash ./install-glfw-3.1.2.sh
+
+test:
+  post:
+    - mkdir -p $CIRCLE_TEST_REPORTS/minitest/
+    - cp -r test/reports/*.xml $CIRCLE_TEST_REPORTS/minitest/

data/install-glfw-3.1.2.sh

@@ -0,0 +1,14 @@
+set -x
+set -e
+if [ ! -e glfw-3.1.2/include/GLFW/glfw3.h ]; then
+  wget https://github.com/glfw/glfw/releases/download/3.1.2/glfw-3.1.2.zip
+  unzip glfw-3.1.2.zip;
+fi
+cd glfw-3.1.2
+if [ ! -e src/libglfw3.so ]; then
+  cmake -D BUILD_SHARED_LIBS=ON .
+  make;
+fi
+if [ ! -e /usr/local/lib/libglfw.so ]; then
+  sudo make install;
+fi

data/lib/mittsu.rb

@@ -1,5 +1,3 @@
-require "pry"
-
 require "mittsu/version"
 require "mittsu/math"
 require "mittsu/core"

data/lib/mittsu/extras/image_utils.rb

@@ -1,80 +1,84 @@
 module Mittsu
   module ImageUtils
-    def self.load_texture(url, mapping = Texture::DEFAULT_MAPPING)
-      loader = ImageLoader.new
+    class << self
+      def load_texture(url, mapping = Texture::DEFAULT_MAPPING)
+        loader = ImageLoader.new
 
-      Texture.new(nil, mapping).tap do |texture|
-        image = loader.load(url, flip: true)
-        texture.image = image
-        texture.needs_update = true
+        Texture.new(nil, mapping).tap do |texture|
+          image = loader.load(url, flip: true)
+          texture.image = image
+          texture.needs_update = true
 
-        texture.source_file = url
+          texture.source_file = url
+        end
       end
-    end
 
-    def self.load_texture_cube(array, mapping = Texture::DEFAULT_MAPPING)
-      images = HashArray.new
+      def load_texture_cube(array, mapping = Texture::DEFAULT_MAPPING)
+        images = HashArray.new
 
-      loader = ImageLoader.new
-      CubeTexture.new(images, mapping).tap do |texture|
-        loaded = 0
+        loader = ImageLoader.new
+        CubeTexture.new(images, mapping).tap do |texture|
+          loaded = 0
 
-        array.length.times do |i|
-          texture.images[i] = loader.load(array[i])
-          loaded += 1
-          if loaded == 6
-            texture.needs_update = true
+          array.length.times do |i|
+            texture.images[i] = loader.load(array[i])
+            loaded += 1
+            if loaded == 6
+              texture.needs_update = true
+            end
           end
         end
       end
-    end
 
-    def self.get_normal_map(image, depth)
-      # adapted from http://www.paulbrunt.co.uk/lab/heightnormal/
+      def get_normal_map(image, depth)
+        # adapted from http://www.paulbrunt.co.uk/lab/heightnormal/
 
-      # depth |= 1
-      #
-      # width = image.width
-      # height = image.height
+        # depth |= 1
+        #
+        # width = image.width
+        # height = image.height
 
-      # TODO: original version uses browser features ...
-    end
+        # TODO: original version uses browser features ...
+      end
 
-    def self.generate_data_texture(width, height, color)
-      size = width * height
-      data = Array.new(3 * size) # Uint8Array
+      def generate_data_texture(width, height, color)
+        size = width * height
+        data = Array.new(3 * size) # Uint8Array
 
-      r = (color.r * 255).floor
-      g = (color.g * 255).floor
-      b = (color.b * 255).floor
+        r = (color.r * 255).floor
+        g = (color.g * 255).floor
+        b = (color.b * 255).floor
 
-      size.times do |i|
-        data[i * 3]     = r
-        data[i * 3 + 1] = g
-        data[i * 3 + 2] = b
-      end
+        size.times do |i|
+          data[i * 3]     = r
+          data[i * 3 + 1] = g
+          data[i * 3 + 2] = b
+        end
 
-      texture = DataTexture.new(data, width, height, RGBFormat)
-      texture.needs_update = true
+        texture = DataTexture.new(data, width, height, RGBFormat)
+        texture.needs_update = true
 
-      texture
-    end
+        texture
+      end
 
-    private_class_method def self.cross(a, b)
-      [
-        a[1] * b[2] - a[2] * b[1],
-        a[2] * b[0] - a[0] * b[2],
-        a[0] * b[1] - a[1] * b[0]
-      ]
-    end
+      private
 
-    private_class_method def self.subtract(a, b)
-      [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
-    end
+      def cross(a, b)
+        [
+          a[1] * b[2] - a[2] * b[1],
+          a[2] * b[0] - a[0] * b[2],
+          a[0] * b[1] - a[1] * b[0]
+        ]
+      end
+
+      def subtract(a, b)
+        [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
+      end
 
-    private_class_method def self.normalize(a)
-      l = Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2])
-      [a[0] / l, a[1] / l, a[2] / l]
+      def normalize(a)
+        l = Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2])
+        [a[0] / l, a[1] / l, a[2] / l]
+      end
     end
   end
 end

data/lib/mittsu/renderers/glfw_window.rb

@@ -1,8 +1,20 @@
 require 'opengl'
 require 'glfw'
 
-path = `pkg-config glfw3 --libs-only-L`.chomp.strip[2..-1]
-GLFW.load_lib('libglfw3.dylib', path)
+GLFW_LIB_EXT = OpenGL.get_platform == :OPENGL_PLATFORM_MACOSX ? 'dylib' : 'so'
+GLFW_LIB = begin
+  "lib#{`pkg-config --libs-only-l glfw3`.gsub(/^-l/, '').chomp.strip}.#{GLFW_LIB_EXT}"
+rescue
+  "libglfw.#{GLFW_LIB_EXT}"
+end
+GLFW_LIB_PATH = begin
+  s = `pkg-config glfw3 --libs-only-L`.gsub(/^-L/, '').chomp.strip
+  s.empty? ? nil : s
+rescue
+  nil
+end
+
+GLFW.load_lib GLFW_LIB, GLFW_LIB_PATH
 
 include GLFW
 
@@ -22,6 +34,9 @@ module Mittsu
 
         @width, @height, @title = width, height, title
         @handle = glfwCreateWindow(@width, @height, @title, nil, nil)
+        if @handle.null?
+          raise "Unable to create window."
+        end
         glfwMakeContextCurrent @handle
         glfwSwapInterval 1
 

data/lib/mittsu/renderers/opengl_renderer.rb

@@ -21,7 +21,7 @@ module Mittsu
     attr_accessor :auto_clear, :auto_clear_color, :auto_clear_depth, :auto_clear_stencil, :sort_objects, :gamma_factor, :gamma_input, :gamma_output, :shadow_map_enabled, :shadow_map_type, :shadow_map_cull_face, :shadow_map_debug, :shadow_map_cascade, :max_morph_targets, :max_morph_normals, :info, :pixel_ratio, :window, :width, :height, :state
 
     def initialize(parameters = {})
-      puts "OpenGLRenderer #{REVISION}"
+      puts "OpenGLRenderer (Revision #{REVISION})"
 
       @pixel_ratio = 1.0