mittsu 0.1.7 → 0.2.0

data/lib/mittsu/renderers/opengl/opengl_implementations.rb

@@ -1,5 +1,6 @@
 require 'mittsu/core/geometry'
 require 'mittsu/core/object_3d'
+require 'mittsu/core/buffer_geometry'
 require 'mittsu/objects'
 require 'mittsu/materials'
 require 'mittsu/textures'
@@ -7,9 +8,12 @@ require 'mittsu/scenes'
 
 require 'mittsu/renderers/opengl/core/geometry'
 require 'mittsu/renderers/opengl/core/object_3d'
+require 'mittsu/renderers/opengl/core/buffer_geometry'
 require 'mittsu/renderers/opengl/objects/mesh'
 require 'mittsu/renderers/opengl/objects/line'
 require 'mittsu/renderers/opengl/objects/group'
+require 'mittsu/renderers/opengl/objects/sprite'
+require 'mittsu/renderers/opengl/objects/point_cloud'
 require 'mittsu/renderers/opengl/scenes/scene'
 
 require 'mittsu/renderers/opengl/lights/light'
@@ -25,6 +29,7 @@ require 'mittsu/renderers/opengl/materials/mesh_lambert_material'
 require 'mittsu/renderers/opengl/materials/mesh_phong_material'
 require 'mittsu/renderers/opengl/materials/line_basic_material'
 require 'mittsu/renderers/opengl/materials/shader_material'
+require 'mittsu/renderers/opengl/materials/point_cloud_material'
 
 require 'mittsu/renderers/opengl/textures/texture'
 require 'mittsu/renderers/opengl/textures/cube_texture'

data/lib/mittsu/renderers/opengl/plugins/sprite_fragment.glsl

@@ -0,0 +1,38 @@
+#version 330
+
+uniform vec3 color;
+uniform sampler2D map;
+uniform float opacity;
+
+uniform int fogType;
+uniform vec3 fogColor;
+uniform float fogDensity;
+uniform float fogNear;
+uniform float fogFar;
+uniform float alphaTest;
+
+in vec2 vUV;
+layout(location = 0) out vec4 fragColor;
+
+void main() {
+	vec4 texture = texture( map, vUV );
+
+	if ( texture.a < alphaTest ) discard;
+
+	fragColor = vec4( color * texture.xyz, texture.a * opacity );
+
+	if ( fogType > 0 ) {
+		float depth = gl_FragCoord.z / gl_FragCoord.w;
+		float fogFactor = 0.0;
+
+		if ( fogType == 1 ) {
+			fogFactor = smoothstep( fogNear, fogFar, depth );
+		} else {
+			const float LOG2 = 1.442695;
+			float fogFactor = exp2( - fogDensity * fogDensity * depth * depth * LOG2 );
+			fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );
+		}
+
+		fragColor = mix( fragColor, vec4( fogColor, fragColor.w ), fogFactor );
+	}
+}

data/lib/mittsu/renderers/opengl/plugins/sprite_plugin.rb

@@ -0,0 +1,250 @@
+module Mittsu
+  class SpritePlugin
+    include OpenGLHelper
+
+    VERTICES = [
+      -0.5, -0.5, 0.0, 0.0,
+       0.5, -0.5, 1.0, 0.0,
+       0.5,  0.5, 1.0, 1.0,
+      -0.5,  0.5, 0.0, 1.0
+    ] # Float32Array
+
+    FACES = [
+      0, 1, 2,
+      0, 2, 3
+    ] # Uint16Array
+
+    def initialize(renderer, sprites)
+      @renderer = renderer
+      @sprites = sprites
+      @program = nil
+
+      # for decomposing matrixWorld
+      @sprite_position = Vector3.new
+      @sprite_rotation = Quaternion.new
+      @sprite_scale = Vector3.new
+    end
+
+    def render(scene, camera)
+      return if @sprites.empty?
+
+      init if @program.nil?
+      setup_gl_for_render(camera)
+      setup_fog(scene)
+
+      update_positions_and_sort(camera)
+
+      render_all_sprites(scene)
+
+      glEnable(GL_CULL_FACE)
+      @renderer.reset_gl_state
+    end
+
+    private
+
+    def init
+      create_vertex_array_object
+      create_program
+
+      init_attributes
+      init_uniforms
+
+      # TODO: canvas texture??
+    end
+
+    def create_vertex_array_object
+      @vertex_array_object = glCreateVertexArray
+      glBindVertexArray(@vertex_array_object)
+
+      @vertex_buffer = glCreateBuffer
+      @element_buffer = glCreateBuffer
+
+      glBindBuffer(GL_ARRAY_BUFFER, @vertex_buffer)
+      glBufferData_easy(GL_ARRAY_BUFFER, VERTICES, GL_STATIC_DRAW)
+
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, @element_buffer)
+      glBufferData_easy(GL_ELEMENT_ARRAY_BUFFER, FACES, GL_STATIC_DRAW)
+    end
+
+    def create_program
+      @program = glCreateProgram
+
+      vertex_shader = OpenGLShader.new(GL_VERTEX_SHADER, File.read(File.join(__dir__, 'sprite_vertex.glsl')))
+      fragment_shader = OpenGLShader.new(GL_FRAGMENT_SHADER, File.read(File.join(__dir__, 'sprite_fragment.glsl')))
+
+      glAttachShader(@program, vertex_shader.shader)
+      glAttachShader(@program, fragment_shader.shader)
+
+      glLinkProgram(@program)
+    end
+
+    def init_attributes
+      @attributes = {
+        position: glGetAttribLocation(@program, 'position'),
+        uv: glGetAttribLocation(@program, 'uv')
+      }
+    end
+
+    def init_uniforms
+      @uniforms = {
+        uvOffset: glGetUniformLocation(@program, 'uvOffset'),
+        uvScale: glGetUniformLocation(@program, 'uvScale'),
+
+        rotation: glGetUniformLocation(@program, 'rotation'),
+        scale: glGetUniformLocation(@program, 'scale'),
+
+        color: glGetUniformLocation(@program, 'color'),
+        map: glGetUniformLocation(@program, 'map'),
+        opacity: glGetUniformLocation(@program, 'opacity'),
+
+        modelViewMatrix: glGetUniformLocation(@program, 'modelViewMatrix'),
+        projectionMatrix: glGetUniformLocation(@program, 'projectionMatrix'),
+
+        fogType: glGetUniformLocation(@program, 'fogType'),
+        fogDensity: glGetUniformLocation(@program, 'fogDensity'),
+        fogNear: glGetUniformLocation(@program, 'fogNear'),
+        fogFar: glGetUniformLocation(@program, 'fogFar'),
+        fogColor: glGetUniformLocation(@program, 'fogColor'),
+
+        alphaTest: glGetUniformLocation(@program, 'alphaTest')
+      }
+    end
+
+    def painter_sort_stable(a, b)
+      if a.z != b.z
+        b.z - a.z
+      else
+        b.id - a.id
+      end
+    end
+
+    def setup_gl_for_render(camera)
+      glUseProgram(@program)
+
+      glDisable(GL_CULL_FACE)
+      glEnable(GL_BLEND)
+
+      glBindVertexArray(@vertex_array_object)
+
+      glEnableVertexAttribArray(@attributes[:position])
+      glEnableVertexAttribArray(@attributes[:uv])
+
+      glBindBuffer(GL_ARRAY_BUFFER, @vertex_buffer)
+
+      glVertexAttribPointer(@attributes[:position], 2, GL_FLOAT, GL_FALSE, 2 * 8, 0)
+      glVertexAttribPointer(@attributes[:uv], 2, GL_FLOAT, GL_FALSE, 2 * 8, 8)
+
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, @element_buffer)
+
+      glUniformMatrix4fv(@uniforms[:projectionMatrix], 1, GL_FALSE, array_to_ptr_easy(camera.projection_matrix.elements))
+
+      glActiveTexture(GL_TEXTURE0)
+      glUniform1i(@uniforms[:map], 0)
+    end
+
+    def setup_fog(scene)
+      @old_fog_type = 0
+      @scene_fog_type = 0
+      fog = scene.fog
+
+      if fog
+        glUniform3f(@uniforms[:fogColor], fog.color.r, fog.color.g, fog.color.b)
+
+        if fog.is_a?(Fog)
+          glUniform1f(@uniforms[:fogNear], fog.near)
+          glUniform1f(@uniforms[:fogFar], fog.far)
+
+          glUniform1i(@uniforms[:fogType], 1)
+          @old_fog_type = 1
+          @scene_fog_type = 1
+        elsif fog.is_a?(FogExp2)
+          glUniform1f(@uniforms[:fogDensity], fog.density)
+
+          glUniform1i(@uniforms[:fogType], 2)
+          @old_fog_type = 2
+          @scene_fog_type = 2
+        end
+      else
+        glUniform1i(@uniforms[:fogType], 0)
+        @old_fog_type = 0
+        @scene_fog_type = 0
+      end
+    end
+
+    def update_positions_and_sort(camera)
+      @sprites.each do |sprite|
+        sprite.model_view_matrix.multiply_matrices(camera.matrix_world_inverse, sprite.matrix_world)
+        sprite.z = -sprite.model_view_matrix.elements[14]
+      end
+
+      @sprites.sort!(&self.method(:painter_sort_stable))
+    end
+
+    def render_all_sprites(scene)
+      @sprites.each do |sprite|
+        material = sprite.material
+
+        set_fog_uniforms(material, scene)
+        set_uv_uniforms(material)
+        set_color_uniforms(material)
+        set_transform_uniforms(sprite)
+        set_blend_mode(material)
+
+        # set texture
+        if material.map && material.map.image && material.map.image.width
+          material.map.set(0, @renderer)
+        else
+          # TODO: canvas texture?
+          # texture.set(0, @renderer)
+        end
+
+        # draw elements
+        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0) # GL_UNSIGNED_SHORT
+      end
+    end
+
+    def set_fog_uniforms(material, scene)
+      fog_type = 0
+
+      if scene.fog && material.fog
+        fog_type = @scene_fog_type
+      end
+
+      if @old_fog_type != fog_type
+        glUniform1(@uniforms[:fogType], fog_type)
+        @old_fog_type = fog_type
+      end
+    end
+
+    def set_uv_uniforms(material)
+      if !material.map.nil?
+        glUniform2f(@uniforms[:uvOffset], material.map.offset.x, material.map.offset.y)
+        glUniform2f(@uniforms[:uvScale], material.map.repeat.x, material.map.repeat.y)
+      else
+        glUniform2f(@uniforms[:uvOffset], 0.0, 0.0)
+        glUniform2f(@uniforms[:uvScale], 1.0, 1.0)
+      end
+    end
+
+    def set_color_uniforms(material)
+      glUniform1f(@uniforms[:opacity], material.opacity)
+      glUniform3f(@uniforms[:color], material.color.r, material.color.g, material.color.b)
+      glUniform1f(@uniforms[:alphaTest], material.alpha_test)
+    end
+
+    def set_transform_uniforms(sprite)
+      glUniformMatrix4fv(@uniforms[:modelViewMatrix], 1, GL_FALSE, array_to_ptr_easy(sprite.model_view_matrix.elements))
+
+      sprite.matrix_world.decompose(@sprite_position, @sprite_rotation, @sprite_scale)
+
+      glUniform1f(@uniforms[:rotation], sprite.material.rotation)
+      glUniform2fv(@uniforms[:scale], 1, array_to_ptr_easy([@sprite_scale.x, @sprite_scale.y]))
+    end
+
+    def set_blend_mode(material)
+      @renderer.state.set_blending(material.blending, material.blend_equation, material.blend_src, material.blend_dst)
+      @renderer.state.set_depth_test(material.depth_test)
+      @renderer.state.set_depth_write(material.depth_write)
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/plugins/sprite_vertex.glsl

@@ -0,0 +1,31 @@
+#version 330
+
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform float rotation;
+uniform vec2 scale;
+uniform vec2 uvOffset;
+uniform vec2 uvScale;
+
+in vec2 position;
+in vec2 uv;
+
+out vec2 vUV;
+
+void main() {
+  vUV = uvOffset + uv * uvScale;
+
+  vec2 alignedPosition = position * scale;
+
+  vec2 rotatedPosition;
+  rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
+  rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
+
+  vec4 finalPosition;
+
+  finalPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
+  finalPosition.xy += rotatedPosition;
+  finalPosition = projectionMatrix * finalPosition;
+
+  gl_Position = finalPosition;
+}

data/lib/mittsu/renderers/opengl_renderer.rb

@@ -19,6 +19,7 @@ require 'mittsu/renderers/opengl/opengl_light_renderer'
 require 'mittsu/renderers/opengl/opengl_default_target'
 require 'mittsu/renderers/opengl/opengl_buffer'
 require 'mittsu/renderers/opengl/plugins/shadow_map_plugin'
+require 'mittsu/renderers/opengl/plugins/sprite_plugin'
 require 'mittsu/renderers/shaders/shader_lib'
 require 'mittsu/renderers/shaders/uniforms_utils'
 
@@ -260,13 +261,6 @@ module Mittsu
       @state.disable_unused_attributes
 
       object.render_buffer(camera, lights, fog, material, geometry_group, buffers_need_update)
-
-      # TODO: render particles
-      # when PointCloud
-      #   glDrawArrays(GL_POINTS, 0, geometry_group.particle_count)
-      #
-      #   @info[:render][:calls] += 1
-      #   @info[:render][:points] += geometry_group.particle_count
     end
 
     def compressed_texture_formats
@@ -488,21 +482,6 @@ module Mittsu
       else
         object.update
       end
-      # TODO: when PointCloud exists
-      # elsif object.is_A? PointCloud
-      #   # TODO: glBindVertexArray ???
-      #   material = object.buffer_material(geometry)
-      #   custom_attributes_dirty = material.attributes && are_custom_attributes_dirty(material)
-      #
-      #   if geometry.vertices_need_update || geometry.colors_need_update || custom_attributes_dirty
-      #     set_particle_buffers(geometry, GL_DYNAMIC_DRAW, object)
-      #   end
-      #
-      #   geometry.vertices_need_update = false
-      #   geometry.colors_need_update = false
-      #
-      #   material.attributes && clear_custom_attributes(material)
-      # end
     end
 
     # FIXME: refactor
@@ -605,8 +584,6 @@ module Mittsu
         # when LineDashedMaterial
         #   refresh_uniforms_line(material_uniforms, material)
         #   refresh_uniforms_dash(material_uniforms, material)
-        # when PointCloudMaterial
-        #   refresh_uniforms_particle(material_uniforms, material)
         # when MeshDepthMaterial
         #   material_uniforms.m_near.value = camera.near
         #   material_uniforms.m_far.value = camera.far
@@ -806,8 +783,8 @@ module Mittsu
     end
 
     def sort_objects_for_render
-      @opaque_objects.sort { |a,b| OpenGLHelper.painter_sort_stable(a,b) }
-      @transparent_objects.sort { |a,b| OpenGLHelper.reverse_painter_sort_stable(a,b) }
+      @opaque_objects.sort! { |a,b| OpenGLHelper.painter_sort_stable(a,b) }
+      @transparent_objects.sort! { |a,b| OpenGLHelper.reverse_painter_sort_stable(a,b) }
     end
 
     def set_matrices_for_immediate_objects(camera)
@@ -863,8 +840,9 @@ module Mittsu
     end
 
     def render_custom_plugins_post_pass(scene, camera)
+      @sprite_plugin.render(scene, camera)
+
       # TODO: when these custom plugins are implemented
-      # @sprite_plugin.render(scene, camera)
       # lens_flare_plugin.render(scene, camera, @_current_render_target.width, @_current_render_target.height)
     end
 
@@ -912,6 +890,7 @@ module Mittsu
 
     def init_collections
       @lights = []
+      @sprites = []
 
       @_opengl_objects = {}
       @_opengl_objects_immediate = []
@@ -984,8 +963,9 @@ module Mittsu
     def init_plugins
       @shadow_map_plugin = ShadowMapPlugin.new(self, @lights, @_opengl_objects, @_opengl_objects_immediate)
 
+      @sprite_plugin = SpritePlugin.new(self, @sprites)
+
       # TODO: when these custom plugins are implemented
-      # @sprite_plugin = SpritePlugin.new(self, @sprites)
       # @lens_flare_plugin = LensFlarePlugin.new(self, @lens_flares)
     end
 

data/lib/mittsu/renderers/shaders/shader_lib/particle_basic/particle_basic_fragment.rbsl

@@ -0,0 +1,27 @@
+uniform vec3 psColor;
+uniform float opacity;
+
+#include common
+#include color_pars_fragment
+#include map_particle_pars_fragment
+#include fog_pars_fragment
+#include shadowmap_pars_fragment
+#include logdepthbuf_pars_fragment
+
+void main() {
+  vec3 outgoingLight = vec3( 0.0 );  // outgoing light does not have an alpha, the surface does
+  vec4 diffuseColor = vec4( psColor, opacity );
+
+  #include logdepthbuf_fragment
+  #include map_particle_fragment
+  #include color_fragment
+  #include alphatest_fragment
+
+  outgoingLight = diffuseColor.rgb; // simple shader
+
+  #include shadowmap_fragment
+  #include fog_fragment
+
+
+  fragColor = vec4( outgoingLight, diffuseColor.a );  // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+}