three-rb 0.1.0 → 0.2.1

data/examples/browser/textures/main.rb

@@ -1,24 +1,13 @@
 # frozen_string_literal: true
 
-require "js"
-
-begin
-  JS.global[:__threeReady].await
-
-  require_relative "../../../lib/three"
-
-  document = JS.global[:document]
-  window = JS.global[:window]
-  viewport = document.call(:querySelector, "#viewport")
-  status = document.call(:querySelector, "#status")
-  status_dot = document.call(:querySelector, "#status-dot")
-  status[:textContent] = "Starting Ruby scene"
+require_relative "../../../lib/three"
 
+Three::Browser.run(starting: "Starting Ruby scene") do |app|
   scene = Three::Scene.new
   camera = Three::OrthographicCamera.new(-2.5, 2.5, 1.6, -1.6, near: 0.1, far: 100)
   camera.position.z = 5
 
-  environment_texture = Three::Loaders::RGBELoader.new.load("/examples/browser/assets/studio.hdr")
+  environment_texture = Three::Loaders::RGBELoader.new.load("/examples/browser/textures/assets/studio.hdr")
   scene.environment = environment_texture
 
   scene.add(Three::AmbientLight.new(0xffffff, 0.45))
@@ -27,7 +16,7 @@ begin
   key_light.position.set(2.5, 3.0, 4.0)
   scene.add(key_light)
 
-  texture = Three::Loaders::TextureLoader.new.load("/examples/browser/assets/checker.svg")
+  texture = Three::Loaders::TextureLoader.new.load("/examples/browser/textures/assets/checker.svg")
   texture.wrap_s = Three::RepeatWrapping
   texture.wrap_t = Three::RepeatWrapping
   texture.mag_filter = Three::NearestFilter
@@ -91,9 +80,7 @@ begin
   )
   renderer.set_clear_color(0x11161a, 1)
 
-  resize = proc do
-    width = [viewport[:clientWidth].to_i, 1].max
-    height = [viewport[:clientHeight].to_i, 1].max
+  app.resize_renderer(renderer, camera) do |width, height, _aspect|
     view_height = 3.4
     view_width = view_height * width.to_f / height
 
@@ -102,25 +89,26 @@ begin
     camera.top = view_height / 2
     camera.bottom = -view_height / 2
     camera.update_projection_matrix
-    renderer.set_size(width, height)
   end
-
-  resize.call
-  window.call(:addEventListener, "resize", resize)
   renderer.render(scene, camera)
 
-  JS.global[:__threeRbRenderer] = renderer.handle
-  JS.global[:__threeRbScene] = renderer.backend.materialize(scene)
-  JS.global[:__threeRbCamera] = renderer.backend.materialize(camera)
-  JS.global[:__threeRbTexturedMesh] = renderer.backend.materialize(mesh)
-  JS.global[:__threeRbTextureMaterial] = renderer.backend.materialize(material)
-  JS.global[:__threeRbMatcapMesh] = renderer.backend.materialize(matcap_mesh)
-  JS.global[:__threeRbMatcapMaterial] = renderer.backend.materialize(matcap_material)
-  JS.global[:__threeRbToonMesh] = renderer.backend.materialize(toon_mesh)
-  JS.global[:__threeRbToonMaterial] = renderer.backend.materialize(toon_material)
-  JS.global[:__threeRbTextureExampleTexture] = renderer.backend.materialize(texture)
-  JS.global[:__threeRbTextureExampleEnvironment] = renderer.backend.materialize(environment_texture)
-  JS.global[:__threeRbTextureExampleFrame] = 0
+  app.expose(
+    {
+      renderer: renderer,
+      scene: scene,
+      camera: camera,
+      textured_mesh: mesh,
+      texture_material: material,
+      matcap_mesh: matcap_mesh,
+      matcap_material: matcap_material,
+      toon_mesh: toon_mesh,
+      toon_material: toon_material,
+      texture_example_texture: texture,
+      texture_example_environment: environment_texture,
+      texture_example_frame: 0
+    },
+    renderer: renderer
+  )
 
   frame = 0
   renderer.animation_loop do
@@ -130,13 +118,7 @@ begin
     matcap_mesh.rotation.x += 0.005
     matcap_mesh.rotation.y -= 0.009
     toon_mesh.rotation.y += 0.012
-    JS.global[:__threeRbTextureExampleFrame] = frame
+    app.set(:texture_example_frame, frame)
     renderer.render(scene, camera)
   end
-
-  status[:textContent] = "Running"
-  status_dot[:dataset][:state] = "running"
-rescue StandardError => error
-  JS.global.call(:__threeRbBootFailed, error.message) if JS.global[:__threeRbBootFailed]
-  raise
 end

data/exe/three-rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "three/generators/browser_example"
+
+def usage
+  <<~TEXT
+    Usage:
+      three-rb browser PATH [--force]
+
+    Commands:
+      browser PATH   Generate a Ruby-only browser example at PATH.
+
+    Example:
+      three-rb browser examples/browser/quickstart
+      three-rb browser examples/browser/ruby
+  TEXT
+end
+
+command = ARGV.shift
+
+case command
+when "browser", "browser-example"
+  options = { force: false }
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: three-rb #{command} PATH [--force]"
+    opts.on("--force", "Overwrite generated example files") { options[:force] = true }
+    opts.on("-h", "--help", "Show help") do
+      puts opts
+      exit 0
+    end
+  end
+  begin
+    parser.parse!(ARGV)
+  rescue OptionParser::ParseError => error
+    warn error.message
+    warn parser
+    exit 1
+  end
+  target = ARGV.shift
+
+  unless target
+    warn parser
+    exit 1
+  end
+
+  Three::Generators::BrowserExample.new(target: target, force: options[:force]).call
+when "-h", "--help", nil
+  puts usage
+  exit(command ? 0 : 1)
+else
+  warn "Unknown command: #{command}"
+  warn usage
+  exit 1
+end

data/lib/three/backends/threejs/materialization.rb

@@ -30,6 +30,10 @@ module Three
             @adapter.load_rgbe_texture(object.source, texture_parameters(object))
           when Texture
             @adapter.load_texture(object.source, texture_parameters(object))
+          when FogExp2
+            @adapter.new_fog_exp2(object.color.hex, object.density)
+          when Fog
+            @adapter.new_fog(object.color.hex, object.near, object.far)
           when AmbientLight
             @adapter.new_ambient_light(object.color.hex, object.intensity)
           when DirectionalLight
@@ -67,6 +71,8 @@ module Three
               parameters[:theta_start],
               parameters[:theta_length]
             )
+          when TextGeometry
+            @adapter.new_text_geometry(object.text, text_geometry_parameters(object))
           when BufferGeometry
             build_buffer_geometry(object)
           when LineBasicMaterial

data/lib/three/backends/threejs/parameters.rb

@@ -89,6 +89,23 @@ module Three
             matrix: texture.matrix.to_a
           }
         end
+
+        def text_geometry_parameters(geometry)
+          parameters = geometry.parameters
+          {
+            font: parameters[:font].handle,
+            size: parameters[:size],
+            depth: parameters[:depth],
+            curveSegments: parameters[:curve_segments],
+            steps: parameters[:steps],
+            bevelEnabled: parameters[:bevel_enabled],
+            bevelThickness: parameters[:bevel_thickness],
+            bevelSize: parameters[:bevel_size],
+            bevelOffset: parameters[:bevel_offset],
+            bevelSegments: parameters[:bevel_segments],
+            direction: parameters[:direction]
+          }
+        end
       end
 
       include Parameters

data/lib/three/backends/threejs/ruby_wasm_adapter.rb

@@ -33,6 +33,75 @@ module Three
           specularIntensityMap
         ].freeze
 
+        ADDON_CONSTRUCTORS = {
+          orbit_controls: {
+            owner: "Three::Controls::OrbitControls",
+            global: :THREE_ORBIT_CONTROLS,
+            import: 'import { OrbitControls } from "three/addons/controls/OrbitControls.js";',
+            assignment: "globalThis.THREE_ORBIT_CONTROLS = OrbitControls;"
+          },
+          effect_composer: {
+            owner: "Three::Postprocessing::EffectComposer",
+            global: :THREE_EFFECT_COMPOSER,
+            import: 'import { EffectComposer } from "three/addons/postprocessing/EffectComposer.js";',
+            assignment: "globalThis.THREE_EFFECT_COMPOSER = EffectComposer;"
+          },
+          render_pass: {
+            owner: "Three::Postprocessing::RenderPass",
+            global: :THREE_RENDER_PASS,
+            import: 'import { RenderPass } from "three/addons/postprocessing/RenderPass.js";',
+            assignment: "globalThis.THREE_RENDER_PASS = RenderPass;"
+          },
+          unreal_bloom_pass: {
+            owner: "Three::Postprocessing::UnrealBloomPass",
+            global: :THREE_UNREAL_BLOOM_PASS,
+            import: 'import { UnrealBloomPass } from "three/addons/postprocessing/UnrealBloomPass.js";',
+            assignment: "globalThis.THREE_UNREAL_BLOOM_PASS = UnrealBloomPass;"
+          },
+          dot_screen_pass: {
+            owner: "Three::Postprocessing::DotScreenPass",
+            global: :THREE_DOT_SCREEN_PASS,
+            import: 'import { DotScreenPass } from "three/addons/postprocessing/DotScreenPass.js";',
+            assignment: "globalThis.THREE_DOT_SCREEN_PASS = DotScreenPass;"
+          },
+          output_pass: {
+            owner: "Three::Postprocessing::OutputPass",
+            global: :THREE_OUTPUT_PASS,
+            import: 'import { OutputPass } from "three/addons/postprocessing/OutputPass.js";',
+            assignment: "globalThis.THREE_OUTPUT_PASS = OutputPass;"
+          },
+          gltf_loader: {
+            owner: "Three::Loaders::GLTFLoader",
+            global: :THREE_GLTF_LOADER,
+            import: 'import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";',
+            assignment: "globalThis.THREE_GLTF_LOADER = GLTFLoader;"
+          },
+          draco_loader: {
+            owner: "Three::Loaders::GLTFLoader with DRACO",
+            global: :THREE_DRACO_LOADER,
+            import: 'import { DRACOLoader } from "three/addons/loaders/DRACOLoader.js";',
+            assignment: "globalThis.THREE_DRACO_LOADER = DRACOLoader;"
+          },
+          rgbe_loader: {
+            owner: "Three::Loaders::RGBELoader",
+            global: :THREE_RGBE_LOADER,
+            import: 'import { HDRLoader } from "three/addons/loaders/HDRLoader.js";',
+            assignment: "globalThis.THREE_RGBE_LOADER = HDRLoader;"
+          },
+          font_loader: {
+            owner: "Three::Loaders::FontLoader",
+            global: :THREE_FONT_LOADER,
+            import: 'import { FontLoader } from "three/addons/loaders/FontLoader.js";',
+            assignment: "globalThis.THREE_FONT_LOADER = FontLoader;"
+          },
+          text_geometry: {
+            owner: "Three::TextGeometry",
+            global: :THREE_TEXT_GEOMETRY,
+            import: 'import { TextGeometry } from "three/addons/geometries/TextGeometry.js";',
+            assignment: "globalThis.THREE_TEXT_GEOMETRY = TextGeometry;"
+          }
+        }.freeze
+
         def initialize(three: nil)
           @three = three || default_three
         end
@@ -55,6 +124,14 @@ module Three
           renderer.call(:setClearColor, color, alpha)
         end
 
+        def set_renderer_tone_mapping(renderer, value)
+          renderer[:toneMapping] = value
+        end
+
+        def set_renderer_tone_mapping_exposure(renderer, value)
+          renderer[:toneMappingExposure] = value
+        end
+
         def set_renderer_shadow_map(renderer, enabled: nil, type: nil, auto_update: nil)
           shadow_map = renderer[:shadowMap]
           shadow_map[:enabled] = enabled unless enabled.nil?
@@ -78,6 +155,10 @@ module Three
           end
         end
 
+        def add_event_listener(handle, type, callback)
+          handle.call(:addEventListener, type.to_s, callback)
+        end
+
         def new_effect_composer(renderer)
           effect_composer_constructor.new(renderer)
         end
@@ -172,6 +253,18 @@ module Three
           texture
         end
 
+        def new_fog(color, near, far)
+          @three[:Fog].new(color, near, far)
+        end
+
+        def new_fog_exp2(color, density)
+          @three[:FogExp2].new(color, density)
+        end
+
+        def load_font(source)
+          font_loader_constructor.new.call(:loadAsync, source)
+        end
+
         def load_gltf(source, draco_decoder_path: nil, draco_decoder_config: nil)
           loader = gltf_loader_constructor.new
           configure_draco_loader(loader, draco_decoder_path, draco_decoder_config) if draco_decoder_path
@@ -395,6 +488,10 @@ module Three
           @three[:SphereGeometry].new(radius, width_segments, height_segments, phi_start, phi_length, theta_start, theta_length)
         end
 
+        def new_text_geometry(text, parameters)
+          text_geometry_constructor.new(text, stringify_keys(parameters))
+        end
+
         def new_buffer_geometry
           @three[:BufferGeometry].new
         end
@@ -428,6 +525,10 @@ module Three
           geometry.call(:setDrawRange, start, count)
         end
 
+        def center_geometry(geometry)
+          geometry.call(:center)
+        end
+
         def new_mesh_basic_material(parameters)
           @three[:MeshBasicMaterial].new(stringify_keys(parameters))
         end
@@ -497,6 +598,15 @@ module Three
           object[:scale].call(:set, *scale)
         end
 
+        def set_object_matrix_auto_update(object, value)
+          object[:matrixAutoUpdate] = value
+        end
+
+        def set_object_matrix(object, elements)
+          object[:matrix].call(:fromArray, js_array(elements))
+          object[:matrixWorldNeedsUpdate] = true
+        end
+
         def update_perspective_camera(camera, fov, aspect, near, far, zoom)
           camera[:fov] = fov
           camera[:aspect] = aspect
@@ -580,6 +690,25 @@ module Three
           scene[:environment] = environment
         end
 
+        def set_scene_fog(scene, fog)
+          scene[:fog] = fog
+        end
+
+        def set_scene_override_material(scene, material)
+          scene[:overrideMaterial] = material
+        end
+
+        def update_fog(fog, color, near, far)
+          fog[:color].call(:setHex, color)
+          fog[:near] = near
+          fog[:far] = far
+        end
+
+        def update_fog_exp2(fog, color, density)
+          fog[:color].call(:setHex, color)
+          fog[:density] = density
+        end
+
         def dispose(handle)
           handle.call(:dispose) if handle.respond_to?(:call)
         end
@@ -675,83 +804,35 @@ module Three
         end
 
         def orbit_controls_constructor
-          require "js"
-          constructor = JS.global[:THREE_ORBIT_CONTROLS]
-          raise RuntimeError, "Three::Controls::OrbitControls requires globalThis.THREE_ORBIT_CONTROLS" if constructor.typeof == "undefined"
-
-          constructor
-        rescue LoadError
-          raise RuntimeError, "Three::Controls::OrbitControls requires ruby.wasm's js gem or an injected adapter"
+          addon_constructor(:orbit_controls)
         end
 
         def effect_composer_constructor
-          require "js"
-          constructor = JS.global[:THREE_EFFECT_COMPOSER]
-          raise RuntimeError, "Three::Postprocessing::EffectComposer requires globalThis.THREE_EFFECT_COMPOSER" if constructor.typeof == "undefined"
-
-          constructor
-        rescue LoadError
-          raise RuntimeError, "Three::Postprocessing::EffectComposer requires ruby.wasm's js gem or an injected adapter"
+          addon_constructor(:effect_composer)
         end
 
         def render_pass_constructor
-          require "js"
-          constructor = JS.global[:THREE_RENDER_PASS]
-          raise RuntimeError, "Three::Postprocessing::RenderPass requires globalThis.THREE_RENDER_PASS" if constructor.typeof == "undefined"
-
-          constructor
-        rescue LoadError
-          raise RuntimeError, "Three::Postprocessing::RenderPass requires ruby.wasm's js gem or an injected adapter"
+          addon_constructor(:render_pass)
         end
 
         def unreal_bloom_pass_constructor
-          require "js"
-          constructor = JS.global[:THREE_UNREAL_BLOOM_PASS]
-          raise RuntimeError, "Three::Postprocessing::UnrealBloomPass requires globalThis.THREE_UNREAL_BLOOM_PASS" if constructor.typeof == "undefined"
-
-          constructor
-        rescue LoadError
-          raise RuntimeError, "Three::Postprocessing::UnrealBloomPass requires ruby.wasm's js gem or an injected adapter"
+          addon_constructor(:unreal_bloom_pass)
         end
 
         def dot_screen_pass_constructor
-          require "js"
-          constructor = JS.global[:THREE_DOT_SCREEN_PASS]
-          raise RuntimeError, "Three::Postprocessing::DotScreenPass requires globalThis.THREE_DOT_SCREEN_PASS" if constructor.typeof == "undefined"
-
-          constructor
-        rescue LoadError
-          raise RuntimeError, "Three::Postprocessing::DotScreenPass requires ruby.wasm's js gem or an injected adapter"
+          addon_constructor(:dot_screen_pass)
         end
 
         def output_pass_constructor
-          require "js"
-          constructor = JS.global[:THREE_OUTPUT_PASS]
-          raise RuntimeError, "Three::Postprocessing::OutputPass requires globalThis.THREE_OUTPUT_PASS" if constructor.typeof == "undefined"
-
-          constructor
-        rescue LoadError
-          raise RuntimeError, "Three::Postprocessing::OutputPass requires ruby.wasm's js gem or an injected adapter"
+          addon_constructor(:output_pass)
         end
 
         def gltf_loader_constructor
-          require "js"
-          constructor = JS.global[:THREE_GLTF_LOADER]
-          raise RuntimeError, "Three::Loaders::GLTFLoader requires globalThis.THREE_GLTF_LOADER" if constructor.typeof == "undefined"
-
-          constructor
-        rescue LoadError
-          raise RuntimeError, "Three::Loaders::GLTFLoader requires ruby.wasm's js gem or an injected adapter"
+          addon_constructor(:gltf_loader)
         end
 
         def draco_loader_constructor
-          require "js"
-          constructor = JS.global[:THREE_DRACO_LOADER]
-          raise RuntimeError, "Three::Loaders::GLTFLoader with DRACO requires globalThis.THREE_DRACO_LOADER" if constructor.typeof == "undefined"
-
-          constructor
-        rescue LoadError
-          raise RuntimeError, "Three::Loaders::GLTFLoader with DRACO requires ruby.wasm's js gem or an injected adapter"
+          addon_constructor(:draco_loader)
         end
 
         def configure_draco_loader(loader, decoder_path, decoder_config)
@@ -762,13 +843,39 @@ module Three
         end
 
         def rgbe_loader_constructor
+          addon_constructor(:rgbe_loader)
+        end
+
+        def font_loader_constructor
+          addon_constructor(:font_loader)
+        end
+
+        def text_geometry_constructor
+          addon_constructor(:text_geometry)
+        end
+
+        def addon_constructor(name)
+          addon = ADDON_CONSTRUCTORS.fetch(name)
           require "js"
-          constructor = JS.global[:THREE_RGBE_LOADER]
-          raise RuntimeError, "Three::Loaders::RGBELoader requires globalThis.THREE_RGBE_LOADER" if constructor.typeof == "undefined"
+          constructor = JS.global[addon.fetch(:global)]
+          raise RuntimeError, missing_addon_constructor_message(addon) if js_undefined?(constructor)
 
           constructor
         rescue LoadError
-          raise RuntimeError, "Three::Loaders::RGBELoader requires ruby.wasm's js gem or an injected adapter"
+          raise RuntimeError, "#{addon.fetch(:owner)} requires ruby.wasm's js gem or an injected adapter"
+        end
+
+        def js_undefined?(value)
+          value.respond_to?(:typeof) && value.typeof == "undefined"
+        end
+
+        def missing_addon_constructor_message(addon)
+          <<~MESSAGE.chomp
+            #{addon.fetch(:owner)} requires globalThis.#{addon.fetch(:global)}.
+            Add this to boot.mjs before loading Ruby:
+            #{addon.fetch(:import)}
+            #{addon.fetch(:assignment)}
+          MESSAGE
         end
 
         def resolve_canvas(canvas)

data/lib/three/backends/threejs/synchronization.rb

@@ -17,7 +17,12 @@ module Three
           end
 
           if object.dirty_field?(:transform)
-            @adapter.set_object_transform(handle, object.position.to_a, object.quaternion.to_a, object.scale.to_a)
+            @adapter.set_object_matrix_auto_update(handle, object.matrix_auto_update)
+            if object.matrix_auto_update
+              @adapter.set_object_transform(handle, object.position.to_a, object.quaternion.to_a, object.scale.to_a)
+            else
+              @adapter.set_object_matrix(handle, object.matrix.to_a)
+            end
           end
 
           if object.dirty_field?(:camera)
@@ -117,14 +122,28 @@ module Three
         def sync_scene(scene, handle)
           @adapter.set_scene_background(handle, scene.background ? sync(scene.background) : nil)
           @adapter.set_scene_environment(handle, scene.environment ? sync(scene.environment) : nil)
+          @adapter.set_scene_fog(handle, scene.fog ? sync(scene.fog) : nil)
+          @adapter.set_scene_override_material(handle, scene.override_material ? sync(scene.override_material) : nil)
         end
 
         def scene_resource_dirty?(scene)
-          [scene.background, scene.environment].compact.any? do |resource|
+          [scene.background, scene.environment, scene.fog, scene.override_material].compact.any? do |resource|
             resource.respond_to?(:dirty?) && resource.dirty?
           end
         end
 
+        def sync_fog(fog, handle)
+          return handle unless fog.dirty?
+
+          if fog.is_a?(FogExp2)
+            @adapter.update_fog_exp2(handle, fog.color.hex, fog.density)
+          else
+            @adapter.update_fog(handle, fog.color.hex, fog.near, fog.far)
+          end
+          fog.mark_clean!
+          handle
+        end
+
         def sync_camera(object, handle)
           case object
           when OrthographicCamera
@@ -172,7 +191,10 @@ module Three
         end
 
         def sync_geometry(geometry, handle)
-          return handle if built_in_geometry?(geometry)
+          if built_in_geometry?(geometry)
+            sync_geometry_operations(geometry, handle)
+            return handle
+          end
           return handle unless geometry_dirty?(geometry)
 
           if geometry.dirty_field?(:all) || geometry.dirty_field?(:index) || geometry.index&.dirty?
@@ -203,10 +225,19 @@ module Three
             @adapter.set_geometry_draw_range(handle, geometry.draw_range[:start], geometry.draw_range[:count])
           end
 
+          sync_geometry_operations(geometry, handle)
           geometry.mark_clean!
           handle
         end
 
+        def sync_geometry_operations(geometry, handle)
+          return unless geometry.respond_to?(:centered?) && geometry.centered?
+          return unless geometry.dirty_field?(:geometry_operations)
+
+          @adapter.center_geometry(handle)
+          geometry.mark_clean!(:geometry_operations)
+        end
+
         def geometry_dirty?(geometry)
           geometry.dirty? ||
             geometry.index&.dirty? ||
@@ -214,7 +245,10 @@ module Three
         end
 
         def built_in_geometry?(geometry)
-          geometry.is_a?(BoxGeometry) || geometry.is_a?(PlaneGeometry) || geometry.is_a?(SphereGeometry)
+          geometry.is_a?(BoxGeometry) ||
+            geometry.is_a?(PlaneGeometry) ||
+            geometry.is_a?(SphereGeometry) ||
+            geometry.is_a?(TextGeometry)
         end
       end
 

data/lib/three/backends/threejs.rb

@@ -6,6 +6,7 @@ require_relative "../core/buffer_geometry"
 require_relative "../geometries/box_geometry"
 require_relative "../geometries/plane_geometry"
 require_relative "../geometries/sphere_geometry"
+require_relative "../geometries/text_geometry"
 require_relative "../lights/ambient_light"
 require_relative "../lights/directional_light"
 require_relative "../lights/hemisphere_light"
@@ -28,6 +29,7 @@ require_relative "../objects/line"
 require_relative "../objects/mesh"
 require_relative "../objects/points"
 require_relative "../objects/sprite"
+require_relative "../scenes/fog"
 require_relative "../scenes/scene"
 require_relative "../textures/cube_texture"
 require_relative "../textures/rgbe_texture"
@@ -93,6 +95,14 @@ module Three
         @adapter.set_clear_color(renderer_handle, color, alpha)
       end
 
+      def set_renderer_tone_mapping(renderer_handle, value)
+        @adapter.set_renderer_tone_mapping(renderer_handle, value)
+      end
+
+      def set_renderer_tone_mapping_exposure(renderer_handle, value)
+        @adapter.set_renderer_tone_mapping_exposure(renderer_handle, value)
+      end
+
       def set_renderer_shadow_map(renderer_handle, enabled: nil, type: nil, auto_update: nil)
         @adapter.set_renderer_shadow_map(renderer_handle, enabled: enabled, type: type, auto_update: auto_update)
       end
@@ -247,6 +257,7 @@ module Three
         return @handles[key] if key && @handles.key?(key)
 
         handle = build_handle(object)
+        sync_geometry_operations(object, handle) if object.is_a?(BufferGeometry)
         @handles[key] = handle if key
         register_object_handle(object, handle)
         mark_clean_after_materialize(object)
@@ -259,6 +270,8 @@ module Three
         case object
         when Object3D
           sync_object3d(object, handle)
+        when Fog
+          sync_fog(object, handle)
         when BufferGeometry
           sync_geometry(object, handle)
         when Texture
@@ -281,6 +294,17 @@ module Three
         handle
       end
 
+      def add_event_listener(object, type, callback)
+        raise ArgumentError, "callback is required" unless callback
+
+        @adapter.add_event_listener(materialize(object), type, callback)
+      end
+
+      def cached?(object)
+        key = cache_key(object)
+        key ? @handles.key?(key) : false
+      end
+
       def traverse_handles(object, &block)
         return enum_for(:traverse_handles, object) unless block