dymokomi/luce-3d
Source of release 0.9.4
0.9.4 / tests / bench / display.lucb
## An offscreen viewport for display timings: a scene with the editor's two
## lights and one Lambert mesh, drawn into a 1400x900 texture. A timed draw
## ends with a one-pixel read, so it covers the GPU's work, not just recording.
from luce_gpu import gpu
import interop
import memory
import time
from luce_3d import graphics as three
from luce_geocore import geocore
from luce_3d.graphics import Vector3, Scene, Mesh, Geometry, Material, Object3D, MeshLambertMaterial, AmbientLight, DirectionalLight, PerspectiveCamera, Renderer
from fixtures import since
pub struct Viewport:
var device: gpu.Device
var texture: gpu.Texture
let scene: interop.Reference[Scene]
let root: interop.Interface[Object3D]
let camera: interop.Reference[PerspectiveCamera]
let renderer: interop.Reference[Renderer]
var shown: interop.Reference[Mesh]?
var shown_object: interop.Interface[Object3D]?
## Fails with gpu.unavailable (or unsupported) when there is no device.
pub func init() -> !:
var device = try gpu.Device.open()
errdefer device.destroy()
var texture = try gpu.Texture.create(device, 1400, 900, gpu.Format.rgba8)
errdefer texture.destroy()
let scene = try interop.Reference[Scene].adopt(new Scene() in memory.heap, three.scene_type, memory.heap)
let ambient = try interop.Reference[AmbientLight].adopt(new AmbientLight(intensity = 0.35) in memory.heap, three.ambient_type, memory.heap)
defer ambient.release()
let ambient_object = ambient.as_interface[Object3D](ambient.value())
defer ambient_object.release()
try scene.value().add(ambient_object)
let sun = try interop.Reference[DirectionalLight].adopt(new DirectionalLight(intensity = 0.85, direction = Vector3(3.0, 5.0, 2.0)) in memory.heap, three.directional_type, memory.heap)
defer sun.release()
let sun_object = sun.as_interface[Object3D](sun.value())
defer sun_object.release()
try scene.value().add(sun_object)
let camera = try interop.Reference[PerspectiveCamera].adopt(new PerspectiveCamera(45.0, 1.0, 0.05, 100.0) in memory.heap, three.perspective_camera_type, memory.heap)
try camera.value().set_position(Vector3(0.0, 1.2, 1.2))
self.device = device
self.texture = texture
self.scene = scene
self.root = scene.as_interface[Object3D](scene.value())
self.camera = camera
self.renderer = try interop.Reference[Renderer].adopt(new Renderer(true) in memory.heap, three.renderer_type, memory.heap)
self.shown = none
self.shown_object = none
## Display `mesh` instead of the previous one, as the editor does when a
## cook publishes a new result.
pub func show(mesh: interop.Reference[geocore.Mesh]) -> !:
self.hide()
let material = try interop.Reference[MeshLambertMaterial].adopt(new MeshLambertMaterial(gpu.Color(0.7, 0.7, 0.7)) in memory.heap, three.lambert_material_type, memory.heap)
defer material.release()
let appearance = material.as_interface[Material](material.value())
defer appearance.release()
let object = try Mesh.of(mesh, appearance)
let node = object.as_interface[Object3D](object.value())
try self.scene.value().add(node)
self.shown = object
self.shown_object = node
func hide():
if let node = self.shown_object:
_ = self.scene.value().remove(node) catch failure: recover false
node.release()
if let object = self.shown: object.release()
self.shown = none
self.shown_object = none
## Orbit a little, so a redraw is a camera change.
pub func orbit(step: f64) -> !:
try self.camera.value().set_position(Vector3(step, 1.2, 1.2))
## One complete frame, including GPU completion. Milliseconds.
pub func draw() -> f64!:
let start = time.now()
let recording = try self.texture.frame()
defer recording.release()
let target = try recording.value().target()
let result = self.renderer.value().render(self.root, self.camera, target, true)
target.release()
defer result.release()
try result.get()
_ = try recording.value().present(gpu.Color(0.1, 0.1, 0.1))
var pixel: u8[4]
try self.texture.read(pixel, gpu.Region(700, 450, 1, 1))
return since(start)
pub func close():
self.hide()
self.renderer.release()
self.camera.release()
self.root.release()
self.scene.release()
self.texture.destroy()
self.device.destroy()