@sceneview-sdk/react-native 3.6.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,139 @@
+# react-native-sceneview
+
+[![npm version](https://img.shields.io/npm/v/react-native-sceneview.svg)](https://www.npmjs.com/package/react-native-sceneview)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![GitHub](https://img.shields.io/badge/GitHub-sceneview%2Fsceneview-black)](https://github.com/sceneview/sceneview)
+
+React Native bindings for [SceneView](https://sceneview.github.io) — 3D and AR scenes powered by Filament (Android) and RealityKit (iOS).
+
+> **Status:** Alpha — 3D model loading works on both platforms. AR scene is functional on Android.
+
+## Features
+
+- Load and display 3D models (GLB/GLTF) using native renderers
+- AR scenes with plane detection — ARCore (Android) and ARKit (iOS)
+- HDR environment lighting
+- Orbit camera controls
+- TypeScript types for all props and events
+- Fallback message on unsupported platforms (web, etc.)
+
+## Installation
+
+```sh
+npm install react-native-sceneview
+```
+
+### iOS
+
+```sh
+cd ios && pod install
+```
+
+Requires iOS 17+ and Xcode 15+. The host app must also add `SceneViewSwift` via Swift Package Manager:
+- URL: `https://github.com/sceneview/SceneViewSwift`
+- Version: `3.6.0`
+
+### Android
+
+Requires `minSdk 24`. SceneView is published to Maven Central — no extra repository needed:
+
+```groovy
+// android/app/build.gradle
+android {
+    defaultConfig {
+        minSdkVersion 24
+    }
+}
+```
+
+## Usage
+
+### 3D Scene
+
+```tsx
+import { SceneView } from 'react-native-sceneview';
+
+<SceneView
+  style={{ flex: 1 }}
+  environment="environments/studio_small.hdr"
+  modelNodes={[{ src: 'models/damaged_helmet.glb', position: [0, 0, -2] }]}
+  cameraOrbit
+/>
+```
+
+### AR Scene
+
+```tsx
+import { ARSceneView } from 'react-native-sceneview';
+
+<ARSceneView
+  style={{ flex: 1 }}
+  planeDetection
+  modelNodes={[{ src: 'models/chair.glb', position: [0, 0, -1] }]}
+/>
+```
+
+### Props — SceneView
+
+| Prop             | Type            | Default | Description                              |
+|------------------|-----------------|---------|------------------------------------------|
+| `style`          | `ViewStyle`     | —       | Standard React Native style              |
+| `environment`    | `string`        | —       | HDR environment asset path               |
+| `modelNodes`     | `ModelNode[]`   | `[]`    | Models to render                         |
+| `geometryNodes`  | `GeometryNode[]`| `[]`    | Geometry nodes (forward-compatible)      |
+| `lightNodes`     | `LightNode[]`   | `[]`    | Light nodes (forward-compatible)         |
+| `cameraOrbit`    | `boolean`       | `true`  | Enable orbit camera controls             |
+| `onTap`          | `function`      | —       | Tap callback (event pending)             |
+
+### Props — ARSceneView (extends SceneView)
+
+| Prop                | Type       | Default | Description                               |
+|---------------------|------------|---------|-------------------------------------------|
+| `planeDetection`    | `boolean`  | `true`  | Enable plane detection                    |
+| `depthOcclusion`    | `boolean`  | `false` | Enable depth occlusion (Depth API/LiDAR)  |
+| `instantPlacement`  | `boolean`  | `false` | Enable instant placement                  |
+| `onPlaneDetected`   | `function` | —       | Callback when a new plane is detected     |
+
+### ModelNode interface
+
+```ts
+interface ModelNode {
+  src: string;                             // Asset path or URL to GLB/GLTF
+  position?: [number, number, number];     // World-space [x, y, z]
+  rotation?: [number, number, number];     // Euler degrees [x, y, z]
+  scale?: number | [number, number, number]; // Uniform or per-axis scale
+  animation?: string;                      // Animation name to auto-play
+}
+```
+
+## Architecture
+
+```
+React Native JS
+    |
+    v
+requireNativeComponent('RNSceneView' / 'RNARSceneView')
+    |
+    +---> Android: ViewManager -> ComposeView -> Scene { } / ARScene { }
+    |                              (Filament, SceneView SDK 3.6.0)
+    |
+    +---> iOS: RCTViewManager -> UIHostingController -> SceneView / ARSceneView
+                                  (RealityKit, SceneViewSwift 3.6.0)
+```
+
+Props are mapped from the React Native bridge to native view parameters on each platform.
+
+## Limitations
+
+- Geometry and light node props are defined in types but not yet rendered natively
+- `onTap` and `onPlaneDetected` event callbacks are declared but events are not yet dispatched
+- Scale prop on `ModelNode` is parsed as a uniform float (per-axis array not yet supported)
+- Only Android and iOS are supported; other platforms render a fallback message
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/sceneview/sceneview/blob/main/.github/CONTRIBUTING.md).
+
+## License
+
+Apache-2.0 — see [LICENSE](LICENSE) for details.

package/android/build.gradle.kts

@@ -0,0 +1,36 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "io.github.sceneview.reactnative"
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 24
+    }
+
+    buildFeatures {
+        compose = true
+    }
+
+    composeOptions {
+        kotlinCompilerExtensionVersion = "1.5.14"
+    }
+}
+
+dependencies {
+    // SceneView — latest on Maven Central
+    implementation("io.github.sceneview:sceneview:3.6.0")
+    implementation("io.github.sceneview:arsceneview:3.6.0")
+
+    // React Native
+    implementation("com.facebook.react:react-android")
+
+    // Compose
+    implementation(platform("androidx.compose:compose-bom:2024.06.00"))
+    implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.foundation:foundation")
+    implementation("androidx.compose.runtime:runtime")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.CAMERA" />
+
+    <uses-feature android:name="android.hardware.camera.ar" android:required="false" />
+</manifest>

package/android/src/main/java/io/github/sceneview/reactnative/ARSceneViewManager.kt

@@ -0,0 +1,125 @@
+package io.github.sceneview.reactnative
+
+import android.widget.FrameLayout
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.ComposeView
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import io.github.sceneview.rememberEngine
+import io.github.sceneview.rememberModelInstance
+import io.github.sceneview.rememberModelLoader
+
+/**
+ * Per-instance AR scene state stored as a tag on the FrameLayout container.
+ */
+class ARSceneViewState {
+    val modelPaths = mutableStateListOf<ModelNodeData>()
+    val planeDetection = mutableStateOf(true)
+    val depthOcclusion = mutableStateOf(false)
+    val instantPlacement = mutableStateOf(false)
+}
+
+/**
+ * ViewManager that bridges React Native's `<RNARSceneView>` to the Jetpack Compose
+ * `ARScene { }` composable from `io.github.sceneview.ar`.
+ *
+ * State is stored per-instance via [FrameLayout.getTag] to support multiple
+ * `<RNARSceneView>` components on the same screen.
+ */
+class ARSceneViewManager : SimpleViewManager<FrameLayout>() {
+
+    override fun getName(): String = "RNARSceneView"
+
+    private fun getState(view: FrameLayout): ARSceneViewState {
+        return view.tag as? ARSceneViewState ?: ARSceneViewState().also { view.tag = it }
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): FrameLayout {
+        val container = FrameLayout(reactContext)
+        val state = ARSceneViewState()
+        container.tag = state
+
+        val composeView = ComposeView(reactContext).apply {
+            setContent {
+                val engine = rememberEngine()
+                val modelLoader = rememberModelLoader(engine)
+
+                io.github.sceneview.ar.ARScene(
+                    modifier = Modifier.fillMaxSize(),
+                    engine = engine,
+                    modelLoader = modelLoader,
+                    planeRenderer = state.planeDetection.value,
+                ) {
+                    state.modelPaths.forEach { model ->
+                        val instance = rememberModelInstance(modelLoader, model.src)
+                        instance?.let {
+                            ModelNode(
+                                modelInstance = it,
+                                scaleToUnits = model.scale,
+                                autoAnimate = model.animate,
+                            )
+                        }
+                    }
+                }
+            }
+        }
+        container.addView(composeView)
+        return container
+    }
+
+    @ReactProp(name = "environment")
+    fun setEnvironment(view: FrameLayout, environment: String?) {
+        // AR scenes use camera feed as background; environment HDR
+        // affects lighting only. Not yet wired to ARScene parameters.
+    }
+
+    @ReactProp(name = "modelNodes")
+    fun setModelNodes(view: FrameLayout, nodes: ReadableArray?) {
+        val state = getState(view)
+        state.modelPaths.clear()
+        nodes?.let { array ->
+            for (i in 0 until array.size()) {
+                val map = array.getMap(i) ?: continue
+                val src = map.getString("src") ?: continue
+                val scale = if (map.hasKey("scale")) {
+                    // Scale can be a single number or array [x,y,z]; handle single number
+                    try {
+                        map.getDouble("scale").toFloat()
+                    } catch (_: Exception) {
+                        1.0f
+                    }
+                } else {
+                    1.0f
+                }
+                val animate = if (map.hasKey("animation")) {
+                    // "animation" is a string (animation name) in the TS types.
+                    // If present, auto-animate is enabled.
+                    map.getString("animation") != null
+                } else {
+                    true
+                }
+                state.modelPaths.add(ModelNodeData(src = src, scale = scale, animate = animate))
+            }
+        }
+    }
+
+    @ReactProp(name = "planeDetection", defaultBoolean = true)
+    fun setPlaneDetection(view: FrameLayout, enabled: Boolean) {
+        getState(view).planeDetection.value = enabled
+    }
+
+    @ReactProp(name = "depthOcclusion", defaultBoolean = false)
+    fun setDepthOcclusion(view: FrameLayout, enabled: Boolean) {
+        getState(view).depthOcclusion.value = enabled
+    }
+
+    @ReactProp(name = "instantPlacement", defaultBoolean = false)
+    fun setInstantPlacement(view: FrameLayout, enabled: Boolean) {
+        getState(view).instantPlacement.value = enabled
+    }
+}

package/android/src/main/java/io/github/sceneview/reactnative/SceneViewManager.kt

@@ -0,0 +1,137 @@
+package io.github.sceneview.reactnative
+
+import android.widget.FrameLayout
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.ComposeView
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import io.github.sceneview.Scene
+import io.github.sceneview.math.Position
+import io.github.sceneview.rememberCameraNode
+import io.github.sceneview.rememberEngine
+import io.github.sceneview.rememberEnvironment
+import io.github.sceneview.rememberEnvironmentLoader
+import io.github.sceneview.rememberModelInstance
+import io.github.sceneview.rememberModelLoader
+
+/**
+ * Per-instance scene state stored as a tag on the FrameLayout container.
+ * Each `<RNSceneView>` gets its own independent state.
+ */
+class SceneViewState {
+    val modelPaths = mutableStateListOf<ModelNodeData>()
+    val environmentPath = mutableStateOf<String?>(null)
+    val orbitEnabled = mutableStateOf(true)
+}
+
+/**
+ * ViewManager that bridges React Native's `<RNSceneView>` to the Jetpack Compose
+ * `Scene { }` composable from `io.github.sceneview`.
+ *
+ * State is stored per-instance via [FrameLayout.getTag] to support multiple
+ * `<RNSceneView>` components on the same screen.
+ */
+class SceneViewManager : SimpleViewManager<FrameLayout>() {
+
+    override fun getName(): String = "RNSceneView"
+
+    private fun getState(view: FrameLayout): SceneViewState {
+        return view.tag as? SceneViewState ?: SceneViewState().also { view.tag = it }
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): FrameLayout {
+        val container = FrameLayout(reactContext)
+        val state = SceneViewState()
+        container.tag = state
+
+        val composeView = ComposeView(reactContext).apply {
+            setContent {
+                val engine = rememberEngine()
+                val modelLoader = rememberModelLoader(engine)
+                val environmentLoader = rememberEnvironmentLoader(engine)
+
+                val cameraNode = rememberCameraNode(engine) {
+                    position = Position(y = 0f, z = 3.0f)
+                }
+
+                val environment = state.environmentPath.value?.let { path ->
+                    rememberEnvironment(environmentLoader) {
+                        environmentLoader.createHDREnvironment(path)
+                            ?: io.github.sceneview.createEnvironment(environmentLoader)
+                    }
+                }
+
+                Scene(
+                    modifier = Modifier.fillMaxSize(),
+                    engine = engine,
+                    modelLoader = modelLoader,
+                    cameraNode = cameraNode,
+                    environment = environment ?: rememberEnvironment(environmentLoader),
+                ) {
+                    state.modelPaths.forEach { model ->
+                        val instance = rememberModelInstance(modelLoader, model.src)
+                        instance?.let {
+                            ModelNode(
+                                modelInstance = it,
+                                scaleToUnits = model.scale,
+                                autoAnimate = model.animate,
+                            )
+                        }
+                    }
+                }
+            }
+        }
+        container.addView(composeView)
+        return container
+    }
+
+    @ReactProp(name = "environment")
+    fun setEnvironment(view: FrameLayout, environment: String?) {
+        getState(view).environmentPath.value = environment
+    }
+
+    @ReactProp(name = "modelNodes")
+    fun setModelNodes(view: FrameLayout, nodes: ReadableArray?) {
+        val state = getState(view)
+        state.modelPaths.clear()
+        nodes?.let { array ->
+            for (i in 0 until array.size()) {
+                val map = array.getMap(i) ?: continue
+                val src = map.getString("src") ?: continue
+                val scale = if (map.hasKey("scale")) {
+                    try {
+                        map.getDouble("scale").toFloat()
+                    } catch (_: Exception) {
+                        1.0f
+                    }
+                } else {
+                    1.0f
+                }
+                // "animation" is a string (animation name) in the TS types.
+                // If present and non-null, auto-animate is enabled.
+                val animate = if (map.hasKey("animation")) {
+                    map.getString("animation") != null
+                } else {
+                    true
+                }
+                state.modelPaths.add(ModelNodeData(src = src, scale = scale, animate = animate))
+            }
+        }
+    }
+
+    @ReactProp(name = "cameraOrbit", defaultBoolean = true)
+    fun setCameraOrbit(view: FrameLayout, enabled: Boolean) {
+        getState(view).orbitEnabled.value = enabled
+    }
+}
+
+data class ModelNodeData(
+    val src: String,
+    val scale: Float = 1.0f,
+    val animate: Boolean = true
+)

package/android/src/main/java/io/github/sceneview/reactnative/SceneViewModule.kt

@@ -0,0 +1,31 @@
+package io.github.sceneview.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package that registers SceneView and ARSceneView view managers.
+ *
+ * Add to your app's `getPackages()`:
+ * ```kotlin
+ * override fun getPackages() = listOf(
+ *     MainReactPackage(),
+ *     SceneViewPackage()
+ * )
+ * ```
+ */
+class SceneViewPackage : ReactPackage {
+
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): List<NativeModule> = emptyList()
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> = listOf(
+        SceneViewManager(),
+        ARSceneViewManager()
+    )
+}