Class: Three::Browser::Application

Inherits:
Object
  • Object
show all
Defined in:
lib/three/browser.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(starting: nil, status_selector: "#status", status_dot_selector: "#status-dot") ⇒ Application

Returns a new instance of Application.



93
94
95
96
97
98
99
100
 
# File 'lib/three/browser.rb', line 93

def initialize(starting: nil, status_selector: "#status", status_dot_selector: "#status-dot")
  Browser.ready!
  @document = Browser.document
  @window = Browser.window
  @status = status_selector ? query(status_selector) : nil
  @status_dot = status_dot_selector ? query(status_dot_selector) : nil
  status(starting, state: "loading") if starting
end

Instance Attribute Details

#document ⇒ Object (readonly)

Returns the value of attribute document.



91
92
93
 
# File 'lib/three/browser.rb', line 91

def document
  @document
end

#window ⇒ Object (readonly)

Returns the value of attribute window.



91
92
93
 
# File 'lib/three/browser.rb', line 91

def window
  @window
end

Instance Method Details

#animation_loop(renderer = nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/three/browser.rb', line 187

def animation_loop(renderer = nil, &block)
  raise ArgumentError, "block is required" unless block

  return renderer.animation_loop(&block) if renderer

  callback = nil
  callback = proc do |time|
    block.call(time)
    @window.call(:requestAnimationFrame, callback)
  end
  @window.call(:requestAnimationFrame, callback)
  callback
end

#boot_failed(message) ⇒ Object 



125
126
127
128
129
130
131
132
 
# File 'lib/three/browser.rb', line 125

def boot_failed(message)
  failure = Browser.global[:__threeRbBootFailed]
  if js_function?(failure)
    Browser.global.call(:__threeRbBootFailed, message)
  else
    status(message, state: "error")
  end
end

#element(handle) ⇒ Object 



106
107
108
 
# File 'lib/three/browser.rb', line 106

def element(handle)
  Element.wrap(handle)
end

#expose(values, renderer: nil, prefix: "__threeRb") ⇒ Object 



213
214
215
216
217
218
 
# File 'lib/three/browser.rb', line 213

def expose(values, renderer: nil, prefix: "__threeRb")
  values.each do |name, value|
    set(name, value, renderer: renderer, prefix: prefix)
  end
  self
end

#get(name, prefix: "__threeRb") ⇒ Object 



225
226
227
 
# File 'lib/three/browser.rb', line 225

def get(name, prefix: "__threeRb")
  Browser.global[global_name(name, prefix)]
end

#increment(name, by: 1, prefix: "__threeRb") ⇒ Object 



229
230
231
232
233
 
# File 'lib/three/browser.rb', line 229

def increment(name, by: 1, prefix: "__threeRb")
  value = get(name, prefix: prefix).to_i + by
  set(name, value, prefix: prefix)
  value
end

#on_key(name = "keydown", key: nil, target: nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/three/browser.rb', line 148

def on_key(name = "keydown", key: nil, target: nil, &block)
  raise ArgumentError, "block is required" unless block

  element = event_target(target || @window)
  callback = proc do |event|
    next if key && event[:key].to_s != key.to_s

    block.call(event)
  end
  element.on(name, &callback)
  callback
end

#on_pointer(name = "pointermove", target: "#viewport", &block) ⇒ Object

Raises:

  • (ArgumentError) 


161
162
163
164
165
166
167
168
169
170
 
# File 'lib/three/browser.rb', line 161

def on_pointer(name = "pointermove", target: "#viewport", &block)
  raise ArgumentError, "block is required" unless block

  element = event_target(target)
  callback = proc do |event|
    block.call(event, *element.pointer_ndc(event))
  end
  element.on(name, &callback)
  callback
end

#on_resize(viewport: "#viewport", &block) ⇒ Object

Raises:

  • (ArgumentError) 


134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/three/browser.rb', line 134

def on_resize(viewport: "#viewport", &block)
  raise ArgumentError, "block is required" unless block

  viewport_element = viewport.is_a?(Element) ? viewport : query(viewport)
  callback = proc do
    width, height = viewport_element.size
    block.call(width, height, width.to_f / height)
  end

  callback.call
  @window.call(:addEventListener, "resize", callback)
  callback
end

#pointer_ndc(event, target: "#viewport") ⇒ Object 



172
173
174
 
# File 'lib/three/browser.rb', line 172

def pointer_ndc(event, target: "#viewport")
  event_target(target).pointer_ndc(event)
end

#query(selector) ⇒ Object 



102
103
104
 
# File 'lib/three/browser.rb', line 102

def query(selector)
  Element.new(@document.call(:querySelector, selector))
end

#resize_renderer(renderer, camera, viewport: "#viewport") ⇒ Object 



201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/three/browser.rb', line 201

def resize_renderer(renderer, camera, viewport: "#viewport")
  on_resize(viewport: viewport) do |width, height, aspect|
    if block_given?
      yield(width, height, aspect)
    elsif camera.respond_to?(:aspect=)
      camera.aspect = aspect
      camera.update_projection_matrix if camera.respond_to?(:update_projection_matrix)
    end
    renderer.set_size(width, height)
  end
end

#running! ⇒ Object 



121
122
123
 
# File 'lib/three/browser.rb', line 121

def running!
  status("Running", state: "running")
end

#set(name, value, renderer: nil, prefix: "__threeRb") ⇒ Object 



220
221
222
223
 
# File 'lib/three/browser.rb', line 220

def set(name, value, renderer: nil, prefix: "__threeRb")
  Browser.global[global_name(name, prefix)] = exposed_value(value, renderer)
  self
end

#status(message, state: nil) ⇒ Object 



110
111
112
113
114
115
116
117
118
119
 
# File 'lib/three/browser.rb', line 110

def status(message, state: nil)
  setter = Browser.global[:__threeRbSetStatus]
  if js_function?(setter)
    Browser.global.call(:__threeRbSetStatus, message, state)
  else
    @status.handle[:textContent] = message if @status
    @status_dot.handle[:dataset][:state] = state if @status_dot && state
  end
  self
end

#storage(kind = :local) ⇒ Object 



176
177
178
179
180
181
182
183
184
185
 
# File 'lib/three/browser.rb', line 176

def storage(kind = :local)
  handle =
    case kind
    when :local, "local" then Browser.global[:localStorage]
    when :session, "session" then Browser.global[:sessionStorage]
    else kind
    end

  Storage.new(handle)
end