mittsu 0.4.0 → 0.5.0

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

@@ -1,132 +0,0 @@
-module Mittsu
-  module OpenGLGeometryLike
-    CONST_BUFFER_NAMES = [
-      :vertex,
-      :color,
-      :normal,
-      :tangent,
-      :uv,
-      :uv2,
-      :skin_indices,
-      :skin_weight,
-      :line_distance,
-      :face,
-      :line
-    ]
-    attr_accessor(*CONST_BUFFER_NAMES.map(&:to_s).map { |name| "#{name}_buffer" }.map(&:to_sym))
-    attr_accessor(*CONST_BUFFER_NAMES.map(&:to_s).map { |name| "#{name}_array" }.map(&:to_sym))
-
-    attr_accessor :vertex_array_object,
-                  :num_morph_targets,
-                  :num_morph_normals,
-                  :morph_targets_buffers,
-                  :morph_normals_buffers,
-                  :morph_targets_arrays,
-                  :morph_normals_arrays,
-                  :faces3,
-                  :type_array,
-                  :face_count,
-                  :line_count,
-                  :particle_count,
-                  :initted_arrays,
-                  :custom_attributes_list,
-                  :num_vertices,
-                  :renderer
-
-    def bind_vertex_array_object
-      glBindVertexArray(@vertex_array_object) if @vertex_array_object
-    end
-
-    def update_vertex_buffer(attribute)
-      glBindBuffer(GL_ARRAY_BUFFER, @vertex_buffer)
-      @renderer.state.enable_attribute(attribute)
-      glVertexAttribPointer(attribute, 3, GL_FLOAT, GL_FALSE, 0, 0)
-    end
-
-    def update_other_buffers(object, material, attributes)
-      update_custom_attributes(attributes)
-
-      update_color_buffer(attributes['color'], object, material)
-      update_normal_buffer(attributes['normal'])
-      update_tangent_buffer(attributes['tangent'])
-      update_uv_buffers(attributes['uv'], attributes['uv2'], object, material)
-
-      if material.skinning
-        update_skin_buffers(attributes['skin_index'], attributes['skin_weight'])
-      end
-
-      update_line_distances_buffer(attributes['line_distances'])
-    end
-
-    private
-
-    def attribute_exists?(attribute)
-      attribute && attribute >= 0
-    end
-
-    def update_color_buffer(attribute, object, material)
-      return unless attribute_exists?(attribute)
-      if object.geometry.colors.length > 0 || object.geometry.faces.length > 0
-        update_attribute(attribute, @color_buffer, 3)
-      elsif material.default_attribute_values
-        glVertexAttrib3fv(attribute, material.default_attribute_values.color)
-      end
-    end
-
-    def update_normal_buffer(attribute)
-      return unless attribute_exists?(attribute)
-      update_attribute(attribute, @normal_buffer, 3)
-    end
-
-    def update_tangent_buffer(attribute)
-      return unless attribute_exists?(attribute)
-      update_attribute(attribute, @tangent_buffer, 4)
-    end
-
-    def update_uv_buffers(uv_attribute, uv2_attribute, object, material)
-      update_uv_buffer(uv_attribute, @uv_buffer, object, 0)
-      update_uv_buffer(uv2_attribute, @uv2_buffer, object, 1)
-    end
-
-    def update_uv_buffer(attribute, buffer, object, index)
-      return unless attribute_exists?(attribute)
-      if object.geometry.face_vertex_uvs[index]
-        update_attribute(attribute, buffer, 2)
-      else
-        # TODO default_attribute_value ???
-        # glVertexAttrib2fv(attribute, default_attribute_value)
-      end
-    end
-
-    def update_skin_buffers(index_attribute, weight_attribute)
-      return unless attribute_exists?(index_attribute) && attribute_exists?(weight_attribute)
-      update_attribute(attribute, @skin_indices_buffer, 4)
-      update_attribute(attribute, @skin_weight_buffer, 4)
-    end
-
-    def update_line_distances_buffer(attribute)
-      return unless attribute_exists?(attribute)
-      update_attribute(attribute, @line_distance_buffer, 1)
-    end
-
-    def update_custom_attributes(attributes)
-      if @custom_attributes_list
-        @custom_attributes_list.each do |custom_attribute|
-          belongs_to_attribute = attributes[custom_attribute.buffer.belongs_to_attribute]
-          update_custom_attribute(custom_attribute, belongs_to_attribute)
-        end
-      end
-    end
-
-    def update_custom_attribute(custom_attribute, belongs_to_attribute)
-      return unless attribute_exists?(belongs_to_attribute)
-      update_attribute(attribute, custom_attribute.buffer, custom_attribute.size)
-    end
-
-    def update_attribute(attribute, buffer, size)
-      glBindBuffer(GL_ARRAY_BUFFER, buffer)
-      @renderer.state.enable_attribute(attribute)
-      glVertexAttribPointer(attribute, size, GL_FLOAT, GL_FALSE, 0, 0)
-    end
-  end
-end

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

@@ -1,161 +0,0 @@
-module Mittsu
-  module OpenGLHelper
-    def glCreateBuffer
-      @_b ||= ' '*8
-      glGenBuffers(1, @_b)
-      @_b.unpack('L')[0]
-    end
-
-    def glCreateTexture
-      @_b ||= ' '*8
-      glGenTextures(1, @_b)
-      @_b.unpack('L')[0]
-    end
-
-    def glCreateVertexArray
-      @_b ||= ' '*8
-      glGenVertexArrays(1, @_b)
-      @_b.unpack('L')[0]
-    end
-
-    def glCreateFramebuffer
-      @_b ||= ' '*8
-      glGenFramebuffers(1, @_b)
-      @_b.unpack('L')[0]
-    end
-
-    def glCreateRenderbuffer
-      @_b ||= ' '*8
-      glGenRenderbuffers(1, @_b)
-      @_b.unpack('L')[0]
-    end
-
-    def array_to_ptr_easy(data)
-      if data.first.is_a?(Float)
-        size_of_element = Fiddle::SIZEOF_FLOAT
-        format_of_element = 'F'
-        # data.map!{ |d| d.nil? ? 0.0 : d }
-      else
-        size_of_element = Fiddle::SIZEOF_INT
-        format_of_element = 'L'
-        # data.map!{ |d| d.nil? ? 0 : d }
-      end
-      size = data.length * size_of_element
-      array_to_ptr(data, size, format_of_element)
-    end
-
-    def array_to_ptr(data, size, format)
-      ptr = Fiddle::Pointer.malloc(size)
-      ptr[0,size] = data.pack(format * data.length)
-      ptr
-    end
-
-    def glBufferData_easy(target, data, usage)
-      ptr = array_to_ptr_easy(data)
-      glBufferData(target, ptr.size, ptr, usage)
-    end
-
-    def glGetParameter(pname)
-      @_b ||= ' '*8
-      glGetIntegerv(pname, @_b)
-      @_b.unpack('L')[0]
-    end
-
-    class << self
-      def mark_uniforms_lights_needs_update(uniforms, value)
-        uniforms['ambientLightColor'].needs_update = value
-
-        uniforms['directionalLightColor'].needs_update = value
-        uniforms['directionalLightDirection'].needs_update = value
-
-        uniforms['pointLightColor'].needs_update = value
-        uniforms['pointLightPosition'].needs_update = value
-        uniforms['pointLightDistance'].needs_update = value
-        uniforms['pointLightDecay'].needs_update = value
-
-        uniforms['spotLightColor'].needs_update = value
-        uniforms['spotLightPosition'].needs_update = value
-        uniforms['spotLightDistance'].needs_update = value
-        uniforms['spotLightDirection'].needs_update = value
-        uniforms['spotLightAngleCos'].needs_update = value
-        uniforms['spotLightExponent'].needs_update = value
-        uniforms['spotLightDecay'].needs_update = value
-
-        uniforms['hemisphereLightSkyColor'].needs_update = value
-        uniforms['hemisphereLightGroundColor'].needs_update = value
-        uniforms['hemisphereLightDirection'].needs_update = value
-      end
-
-      def refresh_uniforms_shadow(uniforms, lights)
-        if uniforms['shadowMatrix']
-          lights.select(&:cast_shadow).select { |light|
-            light.is_a?(SpotLight) || (light.is_a?(DirectionalLight) && !light.shadow_cascade)
-          }.each_with_index { |light, i|
-            uniforms['shadowMap'].value[i] = light.shadow_map
-            uniforms['shadowMapSize'].value[i] = light.shadow_map_size
-
-            uniforms['shadowMatrix'].value[i] = light.shadow_matrix
-
-            uniforms['shadowDarkness'].value[i] = light.shadow_darkness
-            uniforms['shadowBias'].value[i] = light.shadow_bias
-          }
-        end
-      end
-
-      def refresh_uniforms_lights(uniforms, lights)
-        uniforms['ambientLightColor'].value = lights[:ambient].value
-
-        uniforms['directionalLightColor'].value = lights[:directional].colors
-        uniforms['directionalLightDirection'].value = lights[:directional].positions
-
-        uniforms['pointLightColor'].value = lights[:point].colors
-        uniforms['pointLightPosition'].value = lights[:point].positions
-        uniforms['pointLightDistance'].value = lights[:point].distances
-        uniforms['pointLightDecay'].value = lights[:point].decays
-
-        uniforms['spotLightColor'].value = lights[:spot].colors
-        uniforms['spotLightPosition'].value = lights[:spot].positions
-        uniforms['spotLightDistance'].value = lights[:spot].distances
-        uniforms['spotLightDirection'].value = lights[:spot].directions
-        uniforms['spotLightAngleCos'].value = lights[:spot].angles_cos
-        uniforms['spotLightExponent'].value = lights[:spot].exponents
-        uniforms['spotLightDecay'].value = lights[:spot].decays
-
-        uniforms['hemisphereLightSkyColor'].value = lights[:hemi].sky_colors
-        uniforms['hemisphereLightGroundColor'].value = lights[:hemi].ground_colors
-        uniforms['hemisphereLightDirection'].value = lights[:hemi].positions
-      end
-
-      def refresh_uniforms_lambert(uniforms, material)
-      end
-
-      def set_color_linear(array, offset, color, intensity)
-        array[offset]     = color.r * intensity
-        array[offset + 1] = color.g * intensity
-        array[offset + 2] = color.b * intensity
-      end
-
-      def painter_sort_stable(a, b)
-        if a.object.render_order != b.object.render_order
-          a.object.render_order <=> b.object.render_order
-        elsif a.material.id != b.material.id
-          a.material.id <=> b.material.id
-        elsif a.z != b.z
-          a.z <=> b.z
-        else
-          a.object.id <=> b.object.id
-        end
-      end
-
-      def reverse_painter_sort_stable(a, b)
-        if a.object.render_order != b.object.render_order
-          a.object.render_order <=> b.object.render_order
-        elsif a.z != b.z
-          b.z <=> a.z
-        else
-          b.id <=> a.id
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require 'mittsu/core/geometry'
-require 'mittsu/core/object_3d'
-require 'mittsu/core/buffer_geometry'
-require 'mittsu/objects'
-require 'mittsu/materials'
-require 'mittsu/textures'
-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'
-require 'mittsu/renderers/opengl/lights/spot_light'
-require 'mittsu/renderers/opengl/lights/point_light'
-require 'mittsu/renderers/opengl/lights/hemisphere_light'
-require 'mittsu/renderers/opengl/lights/ambient_light'
-require 'mittsu/renderers/opengl/lights/directional_light'
-
-require 'mittsu/renderers/opengl/materials/material'
-require 'mittsu/renderers/opengl/materials/mesh_basic_material'
-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'
-require 'mittsu/renderers/opengl/textures/data_texture'
-require 'mittsu/renderers/opengl/textures/compressed_texture'

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

@@ -1,19 +0,0 @@
-require 'mittsu/renderers/generic_lib'
-
-module Mittsu
-  module OpenGLLib
-    extend GenericLib
-
-    class Linux < GenericLib::Linux
-      def initialize(loader = Linux)
-        @loader = loader
-      end
-    end
-
-    class Windows < GenericLib::Base
-    end
-
-    class MacOS < GenericLib::Base
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-module Mittsu
-  class OpenGLLightRenderer
-    attr_accessor :lights_need_update, :cache
-
-    LIGHT_CLASSES = [
-      AmbientLight,
-      DirectionalLight,
-      PointLight,
-      SpotLight,
-      HemisphereLight
-    ]
-    LIGHT_TYPES = LIGHT_CLASSES.map { |klass| klass::TYPE }
-
-    def initialize(renderer)
-      @renderer = renderer
-      @lights_need_update = true
-      @cache = {}
-      LIGHT_CLASSES.each { |klass|
-        @cache[klass::TYPE] = klass::Cache.new
-      }
-    end
-
-    def setup(lights)
-      @cache.values.each(&:reset)
-
-      lights.each do |light|
-        next if light.only_shadow
-        light.setup(self)
-      end
-
-      LIGHT_CLASSES.each do |klass|
-        cache = @cache[klass::TYPE]
-        klass.null_remaining_lights(cache)
-      end
-
-      @lights_need_update = false
-    end
-
-    def reset
-      @lights_need_update = true
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module Mittsu
-  GL_MITTSU_PARAMS = {
-    RepeatWrapping => GL_REPEAT,
-    ClampToEdgeWrapping => GL_CLAMP_TO_EDGE,
-    MirroredRepeatWrapping => GL_MIRRORED_REPEAT,
-
-    NearestFilter => GL_NEAREST,
-    NearestMipMapNearestFilter => GL_NEAREST_MIPMAP_NEAREST,
-    NearestMipMapLinearFilter => GL_NEAREST_MIPMAP_LINEAR,
-
-    LinearFilter => GL_LINEAR,
-    LinearMipMapNearestFilter => GL_LINEAR_MIPMAP_NEAREST,
-    LinearMipMapLinearFilter => GL_LINEAR_MIPMAP_LINEAR,
-
-    UnsignedByteType => GL_UNSIGNED_BYTE,
-    UnsignedShort4444Type => GL_UNSIGNED_SHORT_4_4_4_4,
-    UnsignedShort5551Type => GL_UNSIGNED_SHORT_5_5_5_1,
-    UnsignedShort565Type => GL_UNSIGNED_SHORT_5_6_5,
-
-    ByteType => GL_BYTE,
-    ShortType => GL_SHORT,
-    UnsignedShortType => GL_UNSIGNED_SHORT,
-    IntType => GL_INT,
-    UnsignedIntType => GL_UNSIGNED_INT,
-    FloatType => GL_FLOAT,
-
-    AlphaFormat => GL_ALPHA,
-    RGBFormat => GL_RGB,
-    RGBAFormat => GL_RGBA,
-    LuminanceFormat => GL_LUMINANCE,
-    LuminanceAlphaFormat => GL_LUMINANCE_ALPHA,
-
-    AddEquation => GL_FUNC_ADD,
-    SubtractEquation => GL_FUNC_SUBTRACT,
-    ReverseSubtractEquation => GL_FUNC_REVERSE_SUBTRACT,
-
-    ZeroFactor => GL_ZERO,
-    OneFactor => GL_ONE,
-    SrcColorFactor => GL_SRC_COLOR,
-    OneMinusSrcColorFactor => GL_ONE_MINUS_SRC_COLOR,
-    SrcAlphaFactor => GL_SRC_ALPHA,
-    OneMinusSrcAlphaFactor => GL_ONE_MINUS_SRC_ALPHA,
-    DstAlphaFactor => GL_DST_ALPHA,
-    OneMinusDstAlphaFactor => GL_ONE_MINUS_DST_ALPHA,
-
-    DstColorFactor => GL_DST_COLOR,
-    OneMinusDstColorFactor => GL_ONE_MINUS_DST_COLOR,
-    SrcAlphaSaturateFactor => GL_SRC_ALPHA_SATURATE
-
-    # TODO: populate with extension parameters?
-  }
-  GL_MITTSU_PARAMS.default = 0
-end

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

@@ -1,250 +0,0 @@
-require 'erb'
-require 'mittsu/renderers/opengl/opengl_shader'
-
-module Mittsu
-  class OpenGLProgram
-    attr_reader :id, :program, :uniforms
-    attr_accessor :code, :used_times, :attributes, :vertex_shader, :fragment_shader
-
-    def initialize(renderer, code, material, parameters)
-      @id = (@@id ||= 1).tap { @@id += 1 }
-      @renderer = renderer
-
-      compile_and_link_program(material, parameters)
-
-      cache_uniform_locations(material.shader[:uniforms] || {}, parameters)
-      cache_attribute_locations(material.attributes || {}, parameters)
-
-      @code = code
-      @used_times = 2
-    end
-
-    private
-
-    def compile_and_link_program(material, parameters)
-      @program = glCreateProgram
-
-      # TODO: necessary for OpenGL?
-      # index0_attribute_name = material.index0_attribute_name
-      #
-      # if index0_attribute_name.nil? && parameters[:morph_targets]
-      #   # programs with morph_targets displace position of attribute 0
-      #
-      #   index0_attribute_name = 'position'
-      # end
-
-      compile_shaders(material, parameters)
-
-      # if !index0_attribute_name.nil?
-        # TODO: is this necessary in OpenGL ???
-        # Force a particular attribute to index 0.
-        # because potentially expensive emulation is done by __browser__ if attribute 0 is disabled. (no browser here!)
-        # And, color, for example is often automatically bound to index 0 so disabling it
-
-      #   glBindAttributeLocation(program, 0, index0_attribute_name)
-      # end
-
-      glLinkProgram(@program)
-      check_for_link_errors
-      post_link_clean_up
-    end
-
-    def generate_defines(defines)
-      chunks = []
-
-      defines.each do |d, value|
-        next if value == false
-
-        chunk = "#define #{d} #{value}"
-        chunks << chunk
-      end
-
-      chunks.join("\n")
-    end
-
-    def link_status
-      ptr = ' '*8
-      glGetProgramiv @program, GL_LINK_STATUS, ptr
-      ptr.unpack('L')[0]
-    end
-
-    def program_info_log
-      ptr = ' '*8
-      glGetProgramiv @program, GL_INFO_LOG_LENGTH, ptr
-      length = ptr.unpack('L')[0]
-
-      if length > 0
-        log = ' '*length
-        glGetProgramInfoLog @program, length, ptr, log
-        log.unpack("A#{length}")[0]
-      else
-        ''
-      end
-    end
-
-    def check_for_link_errors
-      log_info = program_info_log
-
-      if !link_status
-        puts "ERROR: Mittsu::OpenGLProgram: shader error: #{glGetError}, GL_INVALID_STATUS, #{glGetProgramParameter(program, GL_VALIDATE_STATUS)}, glGetProgramParameterInfoLog, #{log_info}"
-      end
-
-      if !log_info.empty?
-        puts "WARNING: Mittsu::OpenGLProgram: glGetProgramInfoLog, #{log_info}"
-        # TODO: useless in OpenGL ???
-        # puts "WARNING: #{glGetExtension( 'OPENGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader )}"
-        # puts "WARNING: #{glGetExtension( 'OPENGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader )}"
-      end
-    end
-
-    def get_shadow_map_define(shadow_map_param)
-      case shadow_map_param
-      when PCFShadowMap
-        'SHADOWMAP_TYPE_PCF'
-      when PCFSoftShadowMap
-        'SHADOWMAP_TYPE_PCF_SOFT'
-      else
-        'SHADOWMAP_TYPE_BASIC'
-      end
-    end
-
-    def get_env_map_type_define(env_map_param, material)
-      return 'ENVMAP_TYPE_CUBE' unless env_map_param
-      case material.env_map.mapping
-      when CubeReflectionMapping, CubeRefractionMapping
-        'ENVMAP_TYPE_CUBE'
-      when EquirectangularReflectionMapping, EquirectangularRefractionMapping
-        'ENVMAP_TYPE_EQUIREC'
-      when SphericalReflectionMapping
-        'ENVMAP_TYPE_SPHERE'
-      else
-        'ENVMAP_TYPE_CUBE'
-      end
-    end
-
-    def get_env_map_mode_define(env_map_param, material)
-      return 'ENVMAP_MODE_REFLECTION' unless env_map_param
-      case material.env_map.mapping
-      when CubeRefractionMapping, EquirectangularRefractionMapping
-        'ENVMAP_MODE_REFRACTION'
-      else
-        'ENVMAP_MODE_REFLECTION'
-      end
-    end
-
-    def get_env_map_blending_define(env_map_param, material)
-      return 'ENVMAP_BLENDING_MULTIPLY' unless env_map_param
-      case material.combine
-      when MultiplyOperation
-        'ENVMAP_BLENDING_MULTIPLY'
-      when MixOperation
-        'ENVMAP_BLENDING_MIX'
-      when AddOperation
-        'ENVMAP_BLENDING_ADD'
-      else
-        'ENVMAP_BLENDING_MULTIPLY'
-      end
-    end
-
-    def compile_shaders(material, parameters)
-      shadow_map_type_define = get_shadow_map_define(parameters[:shadow_map_type])
-
-      env_map_type_define = get_env_map_type_define(parameters[:env_map], material)
-      env_map_mode_define = get_env_map_mode_define(parameters[:env_map], material)
-      env_map_blending_define = get_env_map_blending_define(parameters[:env_map], material)
-
-      gamma_factor_define = (@renderer.gamma_factor > 0) ? @renderer.gamma_factor : 1.0
-
-      custom_defines = generate_defines(material.defines || {})
-
-      if false # material.is_a?(RawShaderMaterial) # TODO: when RawShaderMaterial exists
-        prefix_vertex = ''
-        prefix_fragment = ''
-      else
-        prefix_vertex = File.read(File.expand_path('../../shaders/shader_templates/vertex.glsl.erb', __FILE__))
-        prefix_fragment = File.read(File.expand_path('../../shaders/shader_templates/fragment.glsl.erb', __FILE__))
-      end
-
-      @vertex_shader = OpenGLShader.new(GL_VERTEX_SHADER, compile_shader_template(prefix_vertex + material.shader[:vertex_shader], binding))
-      @fragment_shader = OpenGLShader.new(GL_FRAGMENT_SHADER, compile_shader_template(prefix_fragment + material.shader[:fragment_shader], binding))
-
-      glAttachShader(@program, @vertex_shader.shader)
-      glAttachShader(@program, @fragment_shader.shader)
-    end
-
-    def compile_shader_template(template, b)
-      ERB.new(template).result(b)
-    end
-
-    def post_link_clean_up
-      glDeleteShader(@vertex_shader.shader)
-      glDeleteShader(@fragment_shader.shader)
-    end
-
-    def cache_uniform_locations(uniforms, parameters)
-      identifiers = [
-        'viewMatrix',
-        'modelViewMatrix',
-        'projectionMatrix',
-        'normalMatrix',
-        'modelMatrix',
-        'cameraPosition',
-        'morphTargetInfluences',
-        'bindMatrix',
-        'bindMatrixInverse'
-      ]
-
-      if parameters[:use_vertex_texture]
-        identifiers << 'boneTexture'
-        identifiers << 'boneTextureWidth'
-        identifiers << 'boneTextureHeight'
-      else
-        identifiers << 'boneGlobalMatrices'
-      end
-
-      if parameters[:logarithmic_depth_buffer]
-        identifiers << 'logDepthBufFC'
-      end
-
-      uniforms.each do |k, v|
-        identifiers << k.to_s
-      end
-
-      @uniforms = {}
-      identifiers.each do |id|
-        @uniforms[id] = glGetUniformLocation(program, id)
-      end
-    end
-
-    def cache_attribute_locations(attributes, parameters)
-      identifiers = [
-        'position',
-        'normal',
-        'uv',
-        'uv2',
-        'tangent',
-        'color',
-        'skinIndex',
-        'skinWeight',
-        'lineDistance'
-      ]
-
-      parameters[:max_morph_targets].times do |i|
-        identifiers << "morphTarget#{i}"
-      end
-
-      parameters[:max_morph_normals].times do |i|
-        identifiers << "morphNormal#{i}"
-      end
-
-      attributes.each do |k, v|
-        identifiers << k
-      end
-
-      @attributes = {}
-      identifiers.each do |id|
-        @attributes[id] = glGetAttribLocation(program, id)
-      end
-    end
-  end
-end