mittsu-opengl 0.5.0

data/lib/mittsu/opengl_implementation/materials/mesh_lambert_material.rb

@@ -0,0 +1,33 @@
+require 'mittsu/opengl/material_basics'
+
+module Mittsu
+  class MeshLambertMaterial
+    include OpenGL::MaterialBasics
+
+    def refresh_uniforms(uniforms)
+      refresh_uniforms_basic(uniforms)
+
+      uniforms['emissive'].value = emissive
+
+      if wrap_around
+        uniforms['wrapRGB'].value.copy(wrap_rgb)
+      end
+    end
+
+    def needs_view_matrix_uniform?
+      true
+    end
+
+    def needs_lights?
+      true
+    end
+
+    def init_shader
+      @shader = OpenGL::Shader::Lib.create_shader(shader_id)
+    end
+
+    def shader_id
+      :lambert
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/materials/mesh_phong_material.rb

@@ -0,0 +1,44 @@
+require 'mittsu/opengl/material_basics'
+
+module Mittsu
+  class MeshPhongMaterial
+    include OpenGL::MaterialBasics
+
+    def needs_face_normals?
+      false
+    end
+
+    def refresh_uniforms(uniforms)
+      refresh_uniforms_basic(uniforms)
+
+      uniforms['shininess'].value = shininess
+
+      uniforms['emissive'].value = emissive
+      uniforms['specular'].value = specular
+
+      if wrap_around
+        uniforms['wrapRGB'].value.copy(wrap_rgb)
+      end
+    end
+
+    def needs_camera_position_uniform?
+      true
+    end
+
+    def needs_view_matrix_uniform?
+      true
+    end
+
+    def needs_lights?
+      true
+    end
+
+    def init_shader
+      @shader = OpenGL::Shader::Lib.create_shader(shader_id)
+    end
+
+    def shader_id
+      :phong
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/materials/point_cloud_material.rb

@@ -0,0 +1,27 @@
+module Mittsu
+  class PointCloudMaterial
+    def refresh_uniforms(uniforms)
+      uniforms['psColor'].value = color
+      uniforms['opacity'].value = opacity
+      uniforms['size'].value = size
+      # uniforms['scale'].value = _canvas.height / 2.0 # TODO get window height?
+
+      uniforms['map'].value = map
+
+      if !map.nil?
+        offset = material.map.offset
+        repeat = material.map.repeat
+
+        uniforms['offsetRepeat'].value.set(offset.x, offset.y, repeat.x, repeat.y)
+      end
+    end
+
+    def init_shader
+      @shader = OpenGL::Shader::Lib.create_shader(shader_id)
+    end
+
+    def shader_id
+      :particle_basic
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/materials/shader_material.rb

@@ -0,0 +1,11 @@
+module Mittsu
+  class ShaderMaterial
+    def needs_camera_position_uniform?
+      true
+    end
+
+    def needs_view_matrix_uniform?
+      true
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/objects/group.rb

@@ -0,0 +1,9 @@
+module Mittsu
+  class Group
+    def project(renderer)
+      @renderer = renderer
+      return unless visible
+      project_children
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/objects/line.rb

@@ -0,0 +1,45 @@
+module Mittsu
+  class Line
+    def render_buffer(camera, lights, fog, material, geometry_group, update_buffers)
+      opengl_mode = mode == LineStrip ? GL::LINE_STRIP : GL::LINES
+
+      @renderer.state.set_line_width(material.line_width * @renderer.pixel_ratio)
+
+      GL.DrawArrays(opengl_mode, 0, geometry_group.line_count)
+
+      @renderer.info[:render][:calls] += 1
+    end
+
+    def update
+      # TODO: GL.BindVertexArray ???
+      material = buffer_material(geometry)
+      custom_attributes_dirty = material.attributes && material.custom_attributes_dirty?
+
+      if geometry.vertices_need_update || geometry.colors_need_update || geometry.line_distances_need_update || custom_attributes_dirty
+        geometry.set_line_buffers(GL::DYNAMIC_DRAW)
+      end
+
+      geometry.vertices_need_update = false
+      geometry.colors_need_update = false
+      geometry.line_distances_need_update = false
+
+      material.attributes && material.clear_custom_attributes
+    end
+
+    def init_geometry
+      geometry.renderer = @renderer
+      if geometry.vertex_buffer.nil?
+        geometry.create_line_buffers
+        geometry.init_line_buffers(self)
+
+        geometry.vertices_need_update = true
+        geometry.colors_need_update = true
+        geometry.line_distances_need_update = true
+      end
+    end
+
+    def add_opengl_object
+      @renderer.add_opengl_object(geometry, self)
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/objects/mesh.rb

@@ -0,0 +1,70 @@
+module Mittsu
+  class Mesh
+    attr_accessor :renderer
+
+    def render_buffer(camera, lights, fog, material, geometry_group, update_buffers)
+      type = GL::UNSIGNED_INT # geometry_group.type_array == Uint32Array ? GL::UNSIGNED_INT : GL::UNSIGNED_SHORT
+
+      # wireframe
+      if material.wireframe
+        @renderer.state.set_line_width(material.wireframe_linewidth * @renderer.pixel_ratio)
+
+        GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, geometry_group.line_buffer) if update_buffers
+        GL.DrawElements(GL::LINES, geometry_group.line_count, type, 0)
+
+      # triangles
+      else
+        GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, geometry_group.face_buffer) if update_buffers
+        GL.DrawElements(GL::TRIANGLES, geometry_group.face_count, type, 0)
+      end
+
+      @renderer.info[:render][:calls] += 1
+      @renderer.info[:render][:vertices] += geometry_group.face_count
+      @renderer.info[:render][:faces] += geometry_group.face_count / 3
+    end
+
+    def update
+      # check all geometry groubs
+      mat = nil
+      geometry.groups.each do |geometry_group|
+        # TODO: place to put this???
+        # GL.BindVertexArray(geometry_group.vertex_array_object)
+        mat = buffer_material(geometry_group)
+
+        custom_attributes_dirty = mat.attributes && mat.custom_attributes_dirty?
+
+        if geometry.vertices_need_update || geometry.morph_targets_need_update || geometry.elements_need_update || geometry.uvs_need_update || geometry.normals_need_update || geometry.colors_need_update || geometry.tangents_need_update || custom_attributes_dirty
+          geometry_group.set_mesh_buffers(self, GL::DYNAMIC_DRAW, !geometry.dynamic, mat)
+        end
+      end
+
+      geometry.vertices_need_update = false
+      geometry.morph_targets_need_update = false
+      geometry.elements_need_update = false
+      geometry.uvs_need_update = false
+      geometry.normals_need_update = false
+      geometry.colors_need_update = false
+      geometry.tangents_need_update = false
+
+      mat.attributes && mat.clear_custom_attributes
+    end
+
+    def init_geometry
+      geometry.renderer = @renderer
+      geometry.init_geometry_groups(self)
+    end
+
+    def add_opengl_object
+      case geometry
+      when BufferGeometry
+        @renderer.add_opengl_object(geometry, self)
+      when Geometry
+        geometry.groups.each do |group|
+          @renderer.add_opengl_object(group, self)
+        end
+      else
+        raise "GEOMETRY IS NULL"
+      end
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/objects/point_cloud.rb

@@ -0,0 +1,39 @@
+module Mittsu
+  class PointCloud
+    def render_buffer(camera, lights, fog, material, geometry_group, update_buffers)
+      GL.DrawArrays(GL::POINTS, 0, geometry_group.particle_count)
+
+      @renderer.info[:render][:calls] += 1
+      @renderer.info[:render][:points] += geometry_group.particle_count
+    end
+
+    def update
+			material = buffer_material(geometry)
+			custom_attributes_dirty = material.attributes &&  material.custom_attributes_dirty?
+
+			if geometry.vertices_need_update || geometry.colors_need_update || custom_attributes_dirty
+				geometry.set_particle_buffers(GL::DYNAMIC_DRAW)
+			end
+
+			geometry.vertices_need_update = false
+			geometry.colors_need_update = false
+
+      material.attributes && material.clear_custom_attributes
+    end
+
+    def init_geometry
+      geometry.renderer = @renderer
+      if geometry.vertex_buffer.nil?
+        geometry.create_particle_buffers
+        geometry.init_particle_buffers(self)
+
+        geometry.vertices_need_update = true
+        geometry.colors_need_update = true
+      end
+    end
+
+    def add_opengl_object
+      @renderer.add_opengl_object(geometry, self)
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/objects/sprite.rb

@@ -0,0 +1,12 @@
+module Mittsu
+  class Sprite
+    def project(renderer)
+      @renderer = renderer
+      return unless visible
+      init
+      # TODO!!! FIXME!!!
+      @renderer.instance_variable_get(:@sprites) << self
+      project_children
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/scenes/scene.rb

@@ -0,0 +1,9 @@
+module Mittsu
+  class Scene
+    def project(renderer)
+      @renderer = renderer
+      return unless visible
+      project_children
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/textures/compressed_texture.rb

@@ -0,0 +1,20 @@
+module Mittsu
+  class CompressedTexture
+    def update_specific
+      gl_format = GL::MITTSU_PARAMS[format]
+      gl_type = GL::MITTSU_PARAMS[type]
+
+      mipmaps.each_with_index do |mipmap, i|
+        if format != RGBAFormat && format != RGBFormat
+          if @renderer.compressed_texture_formats.include?(gl_format)
+            GL.CompressedTexImage2D(GL::TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, mipmap.data)
+          else
+            puts 'WARNING: Mittsu::Texture: Attempt to load unsupported compressed texture format in #update_texture'
+          end
+        else
+          GL.TexImage2D(GL::TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
+        end
+      end
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/textures/cube_texture.rb

@@ -0,0 +1,77 @@
+module Mittsu
+  class CubeTexture
+    def set(slot, renderer)
+      @renderer = renderer
+
+      if image.length == 6
+        if needs_update?
+          if !image[:_opengl_texture_cube]
+            add_event_listener(:dispose, @renderer.method(:on_texture_dispose))
+            image[:_opengl_texture_cube] = GL.CreateTexture
+            @renderer.info[:memory][:textures] += 1
+          end
+
+          GL.ActiveTexture(GL::TEXTURE0 + slot)
+          GL.BindTexture(GL::TEXTURE_CUBE_MAP, image[:_opengl_texture_cube])
+
+          # GL.PixelStorei(GL::UNPACK_FLIP_Y_WEBGL, texture.flip_y)
+
+          is_compressed = is_a?(CompressedTexture)
+          is_data_texture = image[0].is_a?(DataTexture)
+
+          cube_image = [];
+
+          6.times do |i|
+            if @auto_scale_cubemaps && !is_compressed && !is_data_texture
+              cube_image[i] = clamp_to_max_size(image[i], @_max_cubemap_size)
+            else
+              cube_image[i] = is_data_texture ? image[i].image : image[i];
+            end
+          end
+
+          img = cube_image[0]
+          is_image_power_of_two = Math.power_of_two?(img.width) && Math.power_of_two?(img.height)
+          gl_format = GL::MITTSU_PARAMS[format]
+          gl_type = GL::MITTSU_PARAMS[type]
+
+          set_parameters(GL::TEXTURE_CUBE_MAP, is_image_power_of_two)
+
+          6.times do |i|
+            if !is_compressed
+              if is_data_texture
+                GL.TexImage2D(GL::TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, gl_format, cube_image[i].width, cube_image[i].height, 0, gl_format, gl_type, cube_image[i].data)
+              else
+                GL.TexImage2D(GL::TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, gl_format, cube_image[i].width, cube_image[i].height, 0, gl_format, gl_type, cube_image[i].data)
+              end
+            else
+              mipmaps = cube_image[i].mipmaps
+
+              mipmaps.each_with_index do |mipmap, j|
+                if format != RGBAFormat && format != RGBFormat
+                  if @renderer.compressed_texture_formats.include?(gl_format)
+                    GL.CompressedTexImage2D(GL::TEXTURE_CUBE_MAP_POSITIVE_X + i, j, gl_format, mipmap.width, mipmap.height, 0, mipmap.data)
+                  else
+                    puts "WARNING: Mittsu::OpenGLCubeTexture: Attempt to load unsupported compressed texture format in #set"
+                  end
+                else
+                  GL.TexImage2D(GL::TEXTURE_CUBE_MAP_POSITIVE_X + i, j, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
+                end
+              end
+            end
+          end
+
+          if generate_mipmaps && is_image_power_of_two
+            GL.GenerateMipmap(GL::TEXTURE_CUBE_MAP)
+          end
+
+          self.needs_update = false
+
+          on_update.call if on_update
+        else
+          GL.ActiveTexture(GL::TEXTURE0 + slot)
+          GL.BindTexture(GL::TEXTURE_CUBE_MAP, image[:_opengl_texture_cube])
+        end
+      end
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/textures/data_texture.rb

@@ -0,0 +1,21 @@
+module Mittsu
+  class DataTexture
+    def update_specific
+      gl_format = GL::MITTSU_PARAMS[format]
+      gl_type = GL::MITTSU_PARAMS[type]
+      is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
+
+      # use manually created mipmaps if available
+      # if there are no manual mipmaps
+      # set 0 level mipmap and then use GL to generate other mipmap levels
+
+      if !mipmaps.empty? && is_image_power_of_two
+        mipmaps.each_with_index do |mipmap, i|
+          GL.TexImage2D(GL::TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
+        end
+      else
+        GL.TexImage2D(GL::TEXTURE_2D, 0, gl_format, image.width, image.height, 0, gl_format, gl_type, image.data)
+      end
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/textures/render_target.rb

@@ -0,0 +1,124 @@
+module Mittsu
+  class RenderTarget < Texture
+    attr_writer :renderer
+
+    alias :original_clone :clone
+    def clone
+      original_clone.tap do |tmp|
+        tmp.renderer = @renderer
+      end
+    end
+
+    def setup_buffers
+      return unless @framebuffer.nil?
+
+      # TODO: when OpenGLRenderTargetCube exists
+      is_cube = false # render_target.is_a? OpenGLRenderTargetCube
+
+      @depth_buffer = true if @depth_buffer.nil?
+      @stencil_buffer = true if @stencil_buffer.nil?
+
+      add_event_listener(:dispose, @renderer.method(:on_render_target_dispose))
+
+      @opengl_texture = GL.CreateTexture
+
+      @renderer.info[:memory][:textures] += 1
+
+      # Setup texture, create render and frame buffers
+
+      is_target_power_of_two = Math.power_of_two?(@width) && Math.power_of_two?(@height)
+      gl_format = GL::MITTSU_PARAMS[@format]
+      gl_type = GL::MITTSU_PARAMS[@type]
+
+      if is_cube
+        # TODO
+      else
+        @framebuffer = GL.CreateFramebuffer
+
+        if @share_depth_from
+          @renderbuffer = share_depth_from.renderbuffer
+        else
+          @renderbuffer = GL.CreateRenderbuffer
+        end
+
+        GL.BindTexture(GL::TEXTURE_2D, @opengl_texture)
+        set_parameters(GL::TEXTURE_2D, is_target_power_of_two)
+
+        GL.TexImage2D(GL::TEXTURE_2D, 0, gl_format, @width, @height, 0, gl_format, gl_type, nil)
+
+        setup_framebuffer(GL::TEXTURE_2D)
+
+        if @share_depth_from
+          if @depth_buffer && !@stencil_buffer
+            GL.FramebufferRenderbuffer(GL::FRAMEBUFFER, GL::DEPTH_ATTACHMENT, GL::RENDERBUFFER, @renderbuffer)
+          elsif @depth_buffer && @stencil_buffer
+            GL.FramebufferRenderbuffer(GL::FRAMEBUFFER, GL::DEPTH_STENCIL_ATTACHMENT, GL::RENDERBUFFER, @renderbuffer)
+          end
+        else
+          setup_renderbuffer
+        end
+
+        GL.GenerateMipmap(GL::TEXTURE_2D) if is_target_power_of_two
+      end
+
+      # Release everything
+
+      if is_cube
+        # TODO
+      else
+        GL.BindTexture(GL::TEXTURE_2D, 0)
+      end
+
+      GL.BindRenderbuffer(GL::RENDERBUFFER, 0)
+      GL.BindFramebuffer(GL::FRAMEBUFFER, 0)
+    end
+
+    def use
+      GL.BindFramebuffer(GL::FRAMEBUFFER, @framebuffer)
+      GL.Viewport(0, 0, @width, @height)
+    end
+
+    def dispose
+      dispatch_event(type: :dispose)
+    end
+
+    def update_mipmap
+      return if !@generate_mipmaps || @min_filter == NearestFilter || @min_filter == LinearFilter
+      # TODO: when OpenGLRenderTargetCube exists
+  		# 	GL.BindTexture(GL::TEXTURE_CUBE_MAP, @opengl_texture)
+  		# 	GL.GenerateMipmap(GL::TEXTURE_CUBE_MAP)
+  		# 	GL.BindTexture(GL::TEXTURE_CUBE_MAP, nil)
+			GL.BindTexture(GL::TEXTURE_2D, @opengl_texture)
+			GL.GenerateMipmap(GL::TEXTURE_2D)
+			GL.BindTexture(GL::TEXTURE_2D, nil)
+    end
+
+    private
+
+    def setup_framebuffer(texture_target)
+      GL.BindFramebuffer(GL::FRAMEBUFFER, @framebuffer)
+      GL.FramebufferTexture2D(GL::FRAMEBUFFER, GL::COLOR_ATTACHMENT0, texture_target, @opengl_texture, 0)
+    end
+
+    def setup_renderbuffer
+      GL.BindRenderbuffer(GL::RENDERBUFFER, @renderbuffer)
+
+      if @depth_buffer && !@stencil_buffer
+        GL.RenderbufferStorage(GL::RENDERBUFFER, GL::DEPTH_COMPONENT16, @width, @height)
+        GL.FramebufferRenderbuffer(GL::FRAMEBUFFER, GL::DEPTH_ATTACHMENT, GL::RENDERBUFFER, @renderbuffer)
+
+        # TODO: investigate this (?):
+    		# THREE.js - For some reason this is not working. Defaulting to RGBA4.
+    		# } else if ( ! renderTarget.depthBuffer && renderTarget.stencilBuffer ) {
+        #
+    		# 	_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.STENCIL_INDEX8, renderTarget.width, renderTarget.height );
+    		# 	_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );
+      elsif @depth_buffer && @stencil_buffer
+        GL.RenderbufferStorage(GL::RENDERBUFFER, GL::DEPTH_STENCIL, @width, @height)
+        GL.FramebufferRenderbuffer(GL::FRAMEBUFFER, GL::DEPTH_STENCIL_ATTACHMENT, GL::RENDERBUFFER, @renderbuffer)
+      else
+        GL.RenderbufferStorage(GL::RENDERBUFFER, GL::RGBA4, @width, @height)
+      end
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/textures/texture.rb

@@ -0,0 +1,107 @@
+module Mittsu
+  class Texture
+    attr_reader :opengl_texture
+
+    def set(slot, renderer)
+      @renderer = renderer
+
+      GL.ActiveTexture(GL::TEXTURE0 + slot)
+
+      if needs_update?
+        update_opengl(@renderer)
+      else
+        GL.BindTexture(GL::TEXTURE_2D, @opengl_texture)
+      end
+    end
+
+    def update_opengl(renderer)
+      @renderer = renderer
+
+      if !@initted
+        @initted = true
+        add_event_listener(:dispose, @renderer.method(:on_texture_dispose))
+        @opengl_texture = GL.CreateTexture
+        @renderer.info[:memory][:textures] += 1
+      end
+
+      GL.BindTexture(GL::TEXTURE_2D, @opengl_texture)
+
+      # GL.PixelStorei(GL::UNPACK_FLIP_Y_WEBGL, flip_y) ???
+      # GL.PixelStorei(GL::UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultiply_alpha) ???
+      GL.PixelStorei(GL::UNPACK_ALIGNMENT, unpack_alignment)
+
+      self.image = @renderer.clamp_to_max_size(image)
+
+      is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
+
+      set_parameters(GL::TEXTURE_2D, is_image_power_of_two)
+
+      update_specific
+
+      if generate_mipmaps && is_image_power_of_two
+        GL.GenerateMipmap(GL::TEXTURE_2D)
+      end
+
+      self.needs_update = false
+
+      on_update.call if on_update
+    end
+
+    protected
+
+    def set_parameters(texture_type, is_image_power_of_two)
+      if is_image_power_of_two
+        GL.TexParameteri(texture_type, GL::TEXTURE_WRAP_S, GL::MITTSU_PARAMS[wrap_s])
+        GL.TexParameteri(texture_type, GL::TEXTURE_WRAP_T, GL::MITTSU_PARAMS[wrap_t])
+
+        GL.TexParameteri(texture_type, GL::TEXTURE_MAG_FILTER, GL::MITTSU_PARAMS[mag_filter])
+        GL.TexParameteri(texture_type, GL::TEXTURE_MIN_FILTER, GL::MITTSU_PARAMS[min_filter])
+      else
+        GL.TexParameteri(texture_type, GL::TEXTURE_WRAP_S, GL::CLAMP_TO_EDGE)
+        GL.TexParameteri(texture_type, GL::TEXTURE_WRAP_T, GL::CLAMP_TO_EDGE)
+
+        if wrap_s != ClampToEdgeWrapping || wrap_t != ClampToEdgeWrapping
+          puts "WARNING: Mittsu::Texture: Texture is not power of two. Texture.wrap_s and Texture.wrap_t should be set to Mittsu::ClampToEdgeWrapping. (#{source_file})"
+        end
+
+        GL.TexParameteri(texture_type, GL::TEXTURE_MAG_FILTER, filter_fallback(mag_filter))
+        GL.TexParameteri(texture_type, GL::TEXTURE_MIN_FILTER, filter_fallback(min_filter))
+
+        if min_filter != NearestFilter && min_filter != LinearFilter
+          puts "WARNING: Mittsu::Texture: Texture is not a power of two. Texture.min_filter should be set to Mittsu::NearestFilter or Mittsu::LinearFilter. (#{source_file})"
+        end
+
+        # TODO: anisotropic extension ???
+      end
+    end
+
+  	# Fallback filters for non-power-of-2 textures
+  	def filter_fallback(filter)
+  		if filter == NearestFilter || filter == NearestMipMapNearestFilter || filter == NearestMipMapLinearFilter
+  			GL::NEAREST
+  		end
+
+      GL::LINEAR
+  	end
+
+    def update_specific
+      gl_format = GL::MITTSU_PARAMS[format]
+      gl_type = GL::MITTSU_PARAMS[type]
+      is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
+
+      # use manually created mipmaps if available
+      # if there are no manual mipmaps
+      # set 0 level mipmap and then use GL to generate other mipmap levels
+
+      if !mipmaps.empty? && is_image_power_of_two
+        mipmaps.each_with_index do |mipmap, i|
+          GL.TexImage2D(GL::TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
+        end
+
+        self.generate_mipmaps = false
+      else
+        GL.TexImage2D(GL::TEXTURE_2D, 0, gl_format, image.width, image.height, 0, gl_format, gl_type, image.data)
+      end
+    end
+  end
+end