sceneview/io.github.sceneview

Package-level declarations

Types

Entity

typealias Entity = Int

EntityInstance

typealias EntityInstance = Int

FilamentEntity

typealias FilamentEntity = Entity

FilamentEntityInstance

typealias FilamentEntityInstance = EntityInstance

SceneView

open class SceneView @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0, defStyleRes: Int = 0, sharedEngine: Engine? = null, sharedModelLoader: ModelLoader? = null, sharedMaterialLoader: MaterialLoader? = null, sharedEnvironmentLoader: EnvironmentLoader? = null, sharedScene: Scene? = null, sharedView: View? = null, sharedRenderer: Renderer? = null, sharedCameraNode: CameraNode? = null, sharedMainLightNode: LightNode? = null, sharedEnvironment: Environment? = null, isOpaque: Boolean = true, sharedCollisionSystem: CollisionSystem? = null, cameraManipulator: Manipulator? = createDefaultCameraManipulator(sharedCameraNode?.worldPosition), var viewNodeWindowManager: ViewNode2.WindowManager? = null, onGestureListener: GestureDetector.OnGestureListener? = null, var onTouchEvent: (e: MotionEvent, hitResult: HitResult?) -> Boolean? = null, sharedActivity: ComponentActivity? = null, sharedLifecycle: Lifecycle? = null) : SurfaceView

A SurfaceView that manages rendering and interactions with the 3D scene.

Functions

createCamera

fun Engine.createCamera(): Camera

createEnvironmentLoader

fun Engine.createEnvironmentLoader(context: Context): EnvironmentLoader

createMaterialLoader

fun Engine.createMaterialLoader(context: Context): MaterialLoader

createModelLoader

fun Engine.createModelLoader(context: Context): ModelLoader

destroyGeometry

fun Engine.destroyGeometry(geometry: Geometry)

destroyRenderable

fun Engine.destroyRenderable(entity: Entity)

destroyTransformable

fun Engine.destroyTransformable(entity: Entity)

rememberCameraManipulator

@Composable

fun rememberCameraManipulator(orbitHomePosition: Position? = null, targetPosition: Position? = null, creator: () -> Manipulator = { SceneView.createDefaultCameraManipulator(orbitHomePosition, targetPosition) }): Manipulator

rememberCameraNode

@Composable

fun rememberCameraNode(engine: Engine, apply: CameraNode.() -> Unit = {}): CameraNode

rememberCollisionSystem

@Composable

fun rememberCollisionSystem(view: View, creator: () -> CollisionSystem = { SceneView.createCollisionSystem(view) }): CollisionSystem

rememberEngine

@Composable

fun rememberEngine(eglContextCreator: () -> EGLContext = { SceneView.createEglContext() }, engineCreator: (eglContext: EGLContext) -> Engine = { SceneView.createEngine(it) }): Engine

rememberEnvironment

@Composable

fun rememberEnvironment(engine: Engine, isOpaque: Boolean = true, environment: () -> Environment = { SceneView.createEnvironment(engine, isOpaque) }): Environment

@Composable

fun rememberEnvironment(environmentLoader: EnvironmentLoader, isOpaque: Boolean = true, environment: () -> Environment = { SceneView.createEnvironment(environmentLoader, isOpaque) }): Environment

rememberEnvironmentLoader

@Composable

fun rememberEnvironmentLoader(engine: Engine, context: Context = LocalContext.current, creator: () -> EnvironmentLoader = { SceneView.createEnvironmentLoader(engine, context) }): EnvironmentLoader

rememberMainLightNode

@Composable

fun rememberMainLightNode(engine: Engine, apply: LightNode.() -> Unit = {}): LightNode

rememberMaterialLoader

@Composable

fun rememberMaterialLoader(engine: Engine, context: Context = LocalContext.current, creator: () -> MaterialLoader = { SceneView.createMaterialLoader(engine, context) }): MaterialLoader

rememberModelLoader

@Composable

fun rememberModelLoader(engine: Engine, context: Context = LocalContext.current, creator: () -> ModelLoader = { SceneView.createModelLoader(engine, context) }): ModelLoader

rememberNode

@Composable

inline fun <T : Node> rememberNode(crossinline creator: () -> T): T

@Composable

fun rememberNode(engine: Engine, creator: Node.() -> Unit = {}): Node

rememberNodes

@Composable

fun rememberNodes(creator: MutableList<Node>.() -> Unit = {}): SnapshotStateList<Node>

rememberOnGestureListener

@Composable

fun rememberOnGestureListener(onDown: (e: MotionEvent, node: Node?) -> Unit = { _, _ -> }, onShowPress: (e: MotionEvent, node: Node?) -> Unit = { _, _ -> }, onSingleTapUp: (e: MotionEvent, node: Node?) -> Unit = { _, _ -> }, onScroll: (e1: MotionEvent?, e2: MotionEvent, node: Node?, distance: Float2) -> Unit = { _, _, _, _ -> }, onLongPress: (e: MotionEvent, node: Node?) -> Unit = { _, _ -> }, onFling: (e1: MotionEvent?, e2: MotionEvent, node: Node?, velocity: Float2) -> Unit = { _, _, _, _ -> }, onSingleTapConfirmed: (e: MotionEvent, node: Node?) -> Unit = { _, _ -> }, onDoubleTap: (e: MotionEvent, node: Node?) -> Unit = { _, _ -> }, onDoubleTapEvent: (e: MotionEvent, node: Node?) -> Unit = { _, _ -> }, onContextClick: (e: MotionEvent, node: Node?) -> Unit = { _, _ -> }, onMoveBegin: (detector: MoveGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, onMove: (detector: MoveGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, onMoveEnd: (detector: MoveGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, onRotateBegin: (detector: RotateGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, onRotate: (detector: RotateGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, onRotateEnd: (detector: RotateGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, onScaleBegin: (detector: ScaleGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, onScale: (detector: ScaleGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, onScaleEnd: (detector: ScaleGestureDetector, e: MotionEvent, node: Node?) -> Unit = { _, _, _ -> }, creator: () -> GestureDetector.OnGestureListener = { object : GestureDetector.OnGestureListener { override fun onDown(e: MotionEvent, node: Node?) = onDown(e, node) override fun onShowPress(e: MotionEvent, node: Node?) = onShowPress(e, node) override fun onSingleTapUp(e: MotionEvent, node: Node?) = onSingleTapUp(e, node) override fun onScroll( e1: MotionEvent?, e2: MotionEvent, node: Node?, distance: Float2 ) = onScroll(e1, e2, node, distance) override fun onLongPress(e: MotionEvent, node: Node?) = onLongPress(e, node) override fun onFling(e1: MotionEvent?, e2: MotionEvent, node: Node?, velocity: Float2) = onFling(e1, e2, node, velocity) override fun onSingleTapConfirmed(e: MotionEvent, node: Node?) = onSingleTapConfirmed(e, node) override fun onDoubleTap(e: MotionEvent, node: Node?) = onDoubleTap(e, node) override fun onDoubleTapEvent(e: MotionEvent, node: Node?) = onDoubleTapEvent(e, node) override fun onContextClick(e: MotionEvent, node: Node?) = onContextClick(e, node) override fun onMoveBegin(detector: MoveGestureDetector, e: MotionEvent, node: Node?) = onMoveBegin(detector, e, node) override fun onMove(detector: MoveGestureDetector, e: MotionEvent, node: Node?) = onMove(detector, e, node) override fun onMoveEnd(detector: MoveGestureDetector, e: MotionEvent, node: Node?) = onMoveEnd(detector, e, node) override fun onRotateBegin( detector: RotateGestureDetector, e: MotionEvent, node: Node? ) = onRotateBegin(detector, e, node) override fun onRotate(detector: RotateGestureDetector, e: MotionEvent, node: Node?) = onRotate(detector, e, node) override fun onRotateEnd(detector: RotateGestureDetector, e: MotionEvent, node: Node?) = onRotateEnd(detector, e, node) override fun onScaleBegin(detector: ScaleGestureDetector, e: MotionEvent, node: Node?) = onScaleBegin(detector, e, node) override fun onScale(detector: ScaleGestureDetector, e: MotionEvent, node: Node?) = onScale(detector, e, node) override fun onScaleEnd(detector: ScaleGestureDetector, e: MotionEvent, node: Node?) = onScaleEnd(detector, e, node) } }): GestureDetector.OnGestureListener

rememberRenderer

@Composable

fun rememberRenderer(engine: Engine, creator: () -> Renderer = { SceneView.createRenderer(engine) }): Renderer

rememberScene

@Composable

fun rememberScene(engine: Engine, creator: () -> Scene = { SceneView.createScene(engine) }): Scene

rememberView

@Composable

fun rememberView(engine: Engine, creator: () -> View = { SceneView.createView(engine) }): View

rememberViewNodeManager

@RequiresApi(value = 28)

@Composable

fun rememberViewNodeManager(context: Context = LocalContext.current, creator: () -> ViewNode2.WindowManager = { SceneView.createViewNodeManager(context) }): ViewNode2.WindowManager

safeDestroy

fun Engine.safeDestroy(): Result<Int>

safeDestroyCamera

fun Engine.safeDestroyCamera(camera: Camera): Result<Unit>

safeDestroyEntity

fun Engine.safeDestroyEntity(entity: Entity): Result<Unit>

safeDestroyEnvironment

fun Engine.safeDestroyEnvironment(environment: Environment)

safeDestroyGeometry

fun Engine.safeDestroyGeometry(geometry: Geometry)

safeDestroyIndexBuffer

fun Engine.safeDestroyIndexBuffer(indexBuffer: IndexBuffer): Result<Unit>

safeDestroyIndirectLight

fun Engine.safeDestroyIndirectLight(indirectLight: IndirectLight): Result<Unit>

safeDestroyMaterial

fun Engine.safeDestroyMaterial(material: Material): Result<Unit>

safeDestroyMaterialInstance

fun Engine.safeDestroyMaterialInstance(materialInstance: MaterialInstance): Result<Unit>

safeDestroyMaterialLoader

fun Engine.safeDestroyMaterialLoader(materialLoader: MaterialLoader): Result<Unit>

safeDestroyModel

fun AssetLoader.safeDestroyModel(model: Model)

safeDestroyModelLoader

fun Engine.safeDestroyModelLoader(modelLoader: ModelLoader): Result<Unit>

safeDestroyRenderable

fun Engine.safeDestroyRenderable(entity: Entity): Result<Unit>

safeDestroyRenderer

fun Engine.safeDestroyRenderer(renderer: Renderer): Result<Unit>

safeDestroyScene

fun Engine.safeDestroyScene(scene: Scene): Result<Unit>

safeDestroySkybox

fun Engine.safeDestroySkybox(skybox: Skybox): Result<Unit>

safeDestroyStream

fun Engine.safeDestroyStream(stream: Stream): Result<Unit>

safeDestroyTexture

fun Engine.safeDestroyTexture(texture: Texture): Result<Unit>

safeDestroyTransformable

fun Engine.safeDestroyTransformable(entity: Entity): Result<Unit>

safeDestroyVertexBuffer

fun Engine.safeDestroyVertexBuffer(vertexBuffer: VertexBuffer): Result<Unit>

safeDestroyView

fun Engine.safeDestroyView(view: View): Result<Unit>

Scene

@Composable

fun Scene(modifier: Modifier = Modifier, engine: Engine = rememberEngine(), modelLoader: ModelLoader = rememberModelLoader(engine), materialLoader: MaterialLoader = rememberMaterialLoader(engine), environmentLoader: EnvironmentLoader = rememberEnvironmentLoader(engine), view: View = rememberView(engine), isOpaque: Boolean = true, renderer: Renderer = rememberRenderer(engine), scene: Scene = rememberScene(engine), environment: Environment = rememberEnvironment(environmentLoader, isOpaque = isOpaque), mainLightNode: LightNode? = rememberMainLightNode(engine), cameraNode: CameraNode = rememberCameraNode(engine), childNodes: List<Node> = rememberNodes(), collisionSystem: CollisionSystem = rememberCollisionSystem(view), cameraManipulator: Manipulator? = rememberCameraManipulator( cameraNode.worldPosition ), viewNodeWindowManager: ViewNode2.WindowManager? = null, onGestureListener: GestureDetector.OnGestureListener? = rememberOnGestureListener(), onTouchEvent: (e: MotionEvent, hitResult: HitResult?) -> Boolean? = null, activity: ComponentActivity? = LocalContext.current as? ComponentActivity, lifecycle: Lifecycle = LocalLifecycleOwner.current.lifecycle, onFrame: (frameTimeNanos: Long) -> Unit? = null, onViewCreated: SceneView.() -> Unit? = null, onViewUpdated: SceneView.() -> Unit? = null)