maobo/cup_edit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

renaming/refactoring and allow creating new cameras

Browse Source
This commit is contained in:
Nick Fisher
2024-09-25 23:56:25 +08:00
parent 2b1339b560
commit a2684ae47d
14 changed files with 665 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
thermion_dart/lib/thermion_dart/viewer/ffi/src/camera_ffi.dart
View File

@@ -5,19 +5,33 @@ import 'package:thermion_dart/thermion_dart/viewer/ffi/src/thermion_dart.g.dart'
import 'package:thermion_dart/thermion_dart/viewer/shared_types/camera.dart'; import 'package:thermion_dart/thermion_dart/viewer/shared_types/camera.dart';
import 'package:vector_math/vector_math_64.dart'; import 'package:vector_math/vector_math_64.dart';
class ThermionFFICamera extends Camera { import '../../thermion_viewer_base.dart';
final Pointer<TCamera> pointer;
ThermionFFICamera(this.pointer); class ThermionFFICamera extends Camera {
final Pointer<TCamera> camera;
final Pointer<TEngine> engine;
ThermionFFICamera(this.camera, this.engine);
@override @override
Future setProjectionMatrixWithCulling( Future setProjectionMatrixWithCulling(
Matrix4 projectionMatrix, double near, double far) async { Matrix4 projectionMatrix, double near, double far) async {
Camera_setCustomProjectionWithCulling( Camera_setCustomProjectionWithCulling(
pointer, matrix4ToDouble4x4(projectionMatrix), near, far); camera, matrix4ToDouble4x4(projectionMatrix), near, far);
} }
Future<Matrix4> getModelMatrix() async { Future<Matrix4> getModelMatrix() async {
return double4x4ToMatrix4(Camera_getModelMatrix(pointer)); return double4x4ToMatrix4(Camera_getModelMatrix(camera));
}
@override
Future setTransform(Matrix4 transform) async {
var entity = Camera_getEntity(camera);
Engine_setTransform(engine, entity, matrix4ToDouble4x4(transform));
}
@override
Future setLensProjection({double near = kNear, double far = kFar, double aspect = 1.0, double focalLength = kFocalLength}) async {
Camera_setLensProjection(camera, near, far, aspect, focalLength);
} }
} }

530
thermion_dart/lib/thermion_dart/viewer/ffi/src/thermion_dart.g.dart
View File

File diff suppressed because it is too large Load Diff

54
thermion_dart/lib/thermion_dart/viewer/ffi/src/thermion_viewer_ffi.dart
View File

@@ -25,7 +25,7 @@ class ThermionViewerFFI extends ThermionViewer {
double pixelRatio = 1.0; double pixelRatio = 1.0;
Pointer<Void>? _sceneManager; Pointer<TSceneManager>? _sceneManager;
Pointer<TViewer>? _viewer; Pointer<TViewer>? _viewer;
@@ -115,12 +115,12 @@ class ThermionViewerFFI extends ThermionViewer {
} }
var aspect = viewportDimensions.$1 / viewportDimensions.$2; var aspect = viewportDimensions.$1 / viewportDimensions.$2;
var focalLength = get_camera_focal_length(mainCamera.pointer); var focalLength = get_camera_focal_length(mainCamera.camera);
if (focalLength.abs() < 0.1) { if (focalLength.abs() < 0.1) {
focalLength = kFocalLength; focalLength = kFocalLength;
} }
set_camera_lens_projection( Camera_setLensProjection(
mainCamera.pointer, near, far, aspect, focalLength); mainCamera.camera, near, far, aspect, focalLength);
} }
Future createSwapChain(double width, double height, Future createSwapChain(double width, double height,
@@ -161,7 +161,7 @@ class ThermionViewerFFI extends ThermionViewer {
throw Exception("Failed to create viewer. Check logs for details"); throw Exception("Failed to create viewer. Check logs for details");
} }
_sceneManager = get_scene_manager(_viewer!); _sceneManager = Viewer_getSceneManager(_viewer!);
await setCameraManipulatorOptions(zoomSpeed: 1.0); await setCameraManipulatorOptions(zoomSpeed: 1.0);
@@ -1165,7 +1165,7 @@ class ThermionViewerFFI extends ThermionViewer {
Future<Camera?> getCameraComponent(ThermionEntity cameraEntity) async { Future<Camera?> getCameraComponent(ThermionEntity cameraEntity) async {
var engine = Viewer_getEngine(_viewer!); var engine = Viewer_getEngine(_viewer!);
var camera = Engine_getCameraComponent(engine, cameraEntity); var camera = Engine_getCameraComponent(engine, cameraEntity);
return ThermionFFICamera(camera); return ThermionFFICamera(camera, engine);
} }
/// ///
@@ -1250,7 +1250,7 @@ class ThermionViewerFFI extends ThermionViewer {
/// ///
Future<double> getCameraFov(bool horizontal) async { Future<double> getCameraFov(bool horizontal) async {
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
return get_camera_fov(mainCamera.pointer, horizontal); return get_camera_fov(mainCamera.camera, horizontal);
} }
/// ///
@@ -1279,7 +1279,7 @@ class ThermionViewerFFI extends ThermionViewer {
Future<double> getCameraNear() async { Future<double> getCameraNear() async {
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
return get_camera_near(mainCamera.pointer); return get_camera_near(mainCamera.camera);
} }
/// ///
@@ -1288,7 +1288,7 @@ class ThermionViewerFFI extends ThermionViewer {
@override @override
Future<double> getCameraCullingFar() async { Future<double> getCameraCullingFar() async {
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
return get_camera_culling_far(mainCamera.pointer); return get_camera_culling_far(mainCamera.camera);
} }
/// ///
@@ -1297,7 +1297,7 @@ class ThermionViewerFFI extends ThermionViewer {
@override @override
Future setCameraFocusDistance(double focusDistance) async { Future setCameraFocusDistance(double focusDistance) async {
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
set_camera_focus_distance(mainCamera.pointer, focusDistance); set_camera_focus_distance(mainCamera.camera, focusDistance);
} }
/// ///
@@ -1333,7 +1333,8 @@ class ThermionViewerFFI extends ThermionViewer {
Future setCameraExposure( Future setCameraExposure(
double aperture, double shutterSpeed, double sensitivity) async { double aperture, double shutterSpeed, double sensitivity) async {
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
set_camera_exposure(mainCamera.pointer, aperture, shutterSpeed, sensitivity); set_camera_exposure(
mainCamera.camera, aperture, shutterSpeed, sensitivity);
} }
/// ///
@@ -1363,7 +1364,7 @@ class ThermionViewerFFI extends ThermionViewer {
Future setCameraModelMatrix4(Matrix4 modelMatrix) async { Future setCameraModelMatrix4(Matrix4 modelMatrix) async {
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
final out = matrix4ToDouble4x4(modelMatrix); final out = matrix4ToDouble4x4(modelMatrix);
set_camera_model_matrix(mainCamera.pointer, out); set_camera_model_matrix(mainCamera.camera, out);
} }
/// ///
@@ -1377,7 +1378,7 @@ class ThermionViewerFFI extends ThermionViewer {
double focalLength = kFocalLength}) async { double focalLength = kFocalLength}) async {
aspect ??= viewportDimensions.$1 / viewportDimensions.$2; aspect ??= viewportDimensions.$1 / viewportDimensions.$2;
var mainCamera = get_camera(_viewer!, get_main_camera(_viewer!)); var mainCamera = get_camera(_viewer!, get_main_camera(_viewer!));
set_camera_lens_projection(mainCamera, near, far, aspect, focalLength); Camera_setLensProjection(mainCamera, near, far, aspect, focalLength);
} }
/// ///
@@ -1596,7 +1597,7 @@ class ThermionViewerFFI extends ThermionViewer {
throw Exception("No viewer available"); throw Exception("No viewer available");
} }
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
var matrixStruct = get_camera_view_matrix(mainCamera.pointer); var matrixStruct = get_camera_view_matrix(mainCamera.camera);
return double4x4ToMatrix4(matrixStruct); return double4x4ToMatrix4(matrixStruct);
} }
@@ -1609,7 +1610,7 @@ class ThermionViewerFFI extends ThermionViewer {
throw Exception("No viewer available"); throw Exception("No viewer available");
} }
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
var matrixStruct = get_camera_model_matrix(mainCamera.pointer); var matrixStruct = get_camera_model_matrix(mainCamera.camera);
return double4x4ToMatrix4(matrixStruct); return double4x4ToMatrix4(matrixStruct);
} }
@@ -1622,7 +1623,7 @@ class ThermionViewerFFI extends ThermionViewer {
throw Exception("No viewer available"); throw Exception("No viewer available");
} }
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
var matrixStruct = get_camera_projection_matrix(mainCamera.pointer); var matrixStruct = get_camera_projection_matrix(mainCamera.camera);
return double4x4ToMatrix4(matrixStruct); return double4x4ToMatrix4(matrixStruct);
} }
@@ -1635,7 +1636,7 @@ class ThermionViewerFFI extends ThermionViewer {
throw Exception("No viewer available"); throw Exception("No viewer available");
} }
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
var matrixStruct = get_camera_culling_projection_matrix(mainCamera.pointer); var matrixStruct = get_camera_culling_projection_matrix(mainCamera.camera);
return double4x4ToMatrix4(matrixStruct); return double4x4ToMatrix4(matrixStruct);
} }
@@ -1695,7 +1696,7 @@ class ThermionViewerFFI extends ThermionViewer {
throw Exception("No viewer available"); throw Exception("No viewer available");
} }
var mainCamera = await getMainCamera() as ThermionFFICamera; var mainCamera = await getMainCamera() as ThermionFFICamera;
var arrayPtr = get_camera_frustum(mainCamera.pointer); var arrayPtr = get_camera_frustum(mainCamera.camera);
var doubleList = arrayPtr.asTypedList(24); var doubleList = arrayPtr.asTypedList(24);
var frustum = Frustum(); var frustum = Frustum();
@@ -2169,6 +2170,23 @@ class ThermionViewerFFI extends ThermionViewer {
void requestFrame() { void requestFrame() {
request_frame_render_thread(_viewer!); request_frame_render_thread(_viewer!);
} }
Future<Camera> createCamera() async {
var camera = SceneManager_createCamera(_sceneManager!);
var engine = Viewer_getEngine(_viewer!);
return ThermionFFICamera(camera, engine);
}
Future destroyCamera(ThermionFFICamera camera) async {
SceneManager_destroyCamera(_sceneManager!, camera.camera);
}
///
///
///
Future setActiveCamera(ThermionFFICamera camera) async {
SceneManager_setCamera(_sceneManager!, camera.camera);
}
} }
class ThermionFFITexture extends ThermionTexture { class ThermionFFITexture extends ThermionTexture {

10
thermion_dart/lib/thermion_dart/viewer/shared_types/camera.dart
View File

@@ -1,8 +1,18 @@
import 'package:vector_math/vector_math_64.dart'; import 'package:vector_math/vector_math_64.dart';
import '../thermion_viewer_base.dart';
abstract class Camera { abstract class Camera {
Future setProjectionMatrixWithCulling( Future setProjectionMatrixWithCulling(
Matrix4 projectionMatrix, double near, double far); Matrix4 projectionMatrix, double near, double far);
Future setLensProjection(
{double near = kNear,
double far = kFar,
double aspect=1.0,
double focalLength = kFocalLength});
Future<Matrix4> getModelMatrix(); Future<Matrix4> getModelMatrix();
Future setTransform(Matrix4 transform);
} }

10
thermion_dart/lib/thermion_dart/viewer/thermion_viewer_base.dart
View File

@@ -960,4 +960,14 @@ abstract class ThermionViewer {
/// ///
Future<MaterialInstance?> getMaterialInstanceAt( Future<MaterialInstance?> getMaterialInstanceAt(
ThermionEntity entity, int index); ThermionEntity entity, int index);
///
///
///
Future<Camera> createCamera();
///
///
///
Future setActiveCamera(covariant Camera camera);
} }

2
thermion_dart/native/include/APIBoundaryTypes.h
View File

@@ -12,7 +12,9 @@ extern "C"
typedef struct TCamera TCamera; typedef struct TCamera TCamera;
typedef struct TMaterialInstance TMaterialInstance; typedef struct TMaterialInstance TMaterialInstance;
typedef struct TEngine TEngine; typedef struct TEngine TEngine;
typedef struct TEntityManager TEntityManager;
typedef struct TViewer TViewer; typedef struct TViewer TViewer;
typedef struct TSceneManager TSceneManager;
struct TMaterialKey { struct TMaterialKey {
bool doubleSided = 1; bool doubleSided = 1;

7
thermion_dart/native/include/SceneManager.hpp
View File

@@ -299,6 +299,12 @@ namespace thermion_filament
void setVisibilityLayer(EntityId entityId, int layer); void setVisibilityLayer(EntityId entityId, int layer);
Camera* createCamera();
void destroyCamera(Camera* camera);
void setCamera(Camera* camera);
private: private:
gltfio::AssetLoader *_assetLoader = nullptr; gltfio::AssetLoader *_assetLoader = nullptr;
const ResourceLoaderWrapperImpl *const _resourceLoaderWrapper; const ResourceLoaderWrapperImpl *const _resourceLoaderWrapper;
@@ -325,6 +331,7 @@ namespace thermion_filament
tsl::robin_map<EntityId, unique_ptr<HighlightOverlay>> _highlighted; tsl::robin_map<EntityId, unique_ptr<HighlightOverlay>> _highlighted;
tsl::robin_map<EntityId, std::tuple<math::float3, bool, math::quatf, bool, float>> _transformUpdates; tsl::robin_map<EntityId, std::tuple<math::float3, bool, math::quatf, bool, float>> _transformUpdates;
std::set<Texture*> _textures; std::set<Texture*> _textures;
std::vector<Camera*> _cameras;
AnimationComponentManager *_animationComponentManager = nullptr; AnimationComponentManager *_animationComponentManager = nullptr;
CollisionComponentManager *_collisionComponentManager = nullptr; CollisionComponentManager *_collisionComponentManager = nullptr;

165
thermion_dart/native/include/ThermionDartApi.h
View File

@@ -56,11 +56,12 @@ extern "C"
EMSCRIPTEN_KEEPALIVE TViewer *create_filament_viewer(const void *const context, const void *const loader, void *const platform, const char *uberArchivePath); EMSCRIPTEN_KEEPALIVE TViewer *create_filament_viewer(const void *const context, const void *const loader, void *const platform, const char *uberArchivePath);
EMSCRIPTEN_KEEPALIVE void destroy_filament_viewer(TViewer *viewer); EMSCRIPTEN_KEEPALIVE void destroy_filament_viewer(TViewer *viewer);
EMSCRIPTEN_KEEPALIVE void *get_scene_manager(TViewer *viewer); EMSCRIPTEN_KEEPALIVE TSceneManager *Viewer_getSceneManager(TViewer *viewer);
// Engine // Engine
EMSCRIPTEN_KEEPALIVE TEngine *Viewer_getEngine(TViewer* viewer); EMSCRIPTEN_KEEPALIVE TEngine *Viewer_getEngine(TViewer* viewer);
EMSCRIPTEN_KEEPALIVE TCamera *Engine_getCameraComponent(TEngine* tEngine, EntityId entityId); EMSCRIPTEN_KEEPALIVE TCamera *Engine_getCameraComponent(TEngine* tEngine, EntityId entityId);
EMSCRIPTEN_KEEPALIVE void Engine_setTransform(TEngine* tEngine, EntityId entity, double4x4 transform);
EMSCRIPTEN_KEEPALIVE void create_render_target(TViewer *viewer, intptr_t texture, uint32_t width, uint32_t height); EMSCRIPTEN_KEEPALIVE void create_render_target(TViewer *viewer, intptr_t texture, uint32_t width, uint32_t height);
EMSCRIPTEN_KEEPALIVE void clear_background_image(TViewer *viewer); EMSCRIPTEN_KEEPALIVE void clear_background_image(TViewer *viewer);
@@ -97,12 +98,12 @@ extern "C"
EMSCRIPTEN_KEEPALIVE void clear_lights(TViewer *viewer); EMSCRIPTEN_KEEPALIVE void clear_lights(TViewer *viewer);
EMSCRIPTEN_KEEPALIVE void set_light_position(TViewer *viewer, EntityId light, float x, float y, float z); EMSCRIPTEN_KEEPALIVE void set_light_position(TViewer *viewer, EntityId light, float x, float y, float z);
EMSCRIPTEN_KEEPALIVE void set_light_direction(TViewer *viewer, EntityId light, float x, float y, float z); EMSCRIPTEN_KEEPALIVE void set_light_direction(TViewer *viewer, EntityId light, float x, float y, float z);
EMSCRIPTEN_KEEPALIVE EntityId load_glb(void *sceneManager, const char *assetPath, int numInstances, bool keepData); EMSCRIPTEN_KEEPALIVE EntityId load_glb(TSceneManager *sceneManager, const char *assetPath, int numInstances, bool keepData);
EMSCRIPTEN_KEEPALIVE EntityId load_glb_from_buffer(void *sceneManager, const void *const data, size_t length, bool keepData, int priority, int layer); EMSCRIPTEN_KEEPALIVE EntityId load_glb_from_buffer(TSceneManager *sceneManager, const void *const data, size_t length, bool keepData, int priority, int layer);
EMSCRIPTEN_KEEPALIVE EntityId load_gltf(void *sceneManager, const char *assetPath, const char *relativePath, bool keepData); EMSCRIPTEN_KEEPALIVE EntityId load_gltf(TSceneManager *sceneManager, const char *assetPath, const char *relativePath, bool keepData);
EMSCRIPTEN_KEEPALIVE EntityId create_instance(void *sceneManager, EntityId id); EMSCRIPTEN_KEEPALIVE EntityId create_instance(TSceneManager *sceneManager, EntityId id);
EMSCRIPTEN_KEEPALIVE int get_instance_count(void *sceneManager, EntityId entityId); EMSCRIPTEN_KEEPALIVE int get_instance_count(TSceneManager *sceneManager, EntityId entityId);
EMSCRIPTEN_KEEPALIVE void get_instances(void *sceneManager, EntityId entityId, EntityId *out); EMSCRIPTEN_KEEPALIVE void get_instances(TSceneManager *sceneManager, EntityId entityId, EntityId *out);
EMSCRIPTEN_KEEPALIVE void set_main_camera(TViewer *viewer); EMSCRIPTEN_KEEPALIVE void set_main_camera(TViewer *viewer);
EMSCRIPTEN_KEEPALIVE EntityId get_main_camera(TViewer *viewer); EMSCRIPTEN_KEEPALIVE EntityId get_main_camera(TViewer *viewer);
EMSCRIPTEN_KEEPALIVE bool set_camera(TViewer *viewer, EntityId entity, const char *nodeName); EMSCRIPTEN_KEEPALIVE bool set_camera(TViewer *viewer, EntityId entity, const char *nodeName);
@@ -128,18 +129,18 @@ extern "C"
EMSCRIPTEN_KEEPALIVE void grab_update(TViewer *viewer, float x, float y); EMSCRIPTEN_KEEPALIVE void grab_update(TViewer *viewer, float x, float y);
EMSCRIPTEN_KEEPALIVE void grab_end(TViewer *viewer); EMSCRIPTEN_KEEPALIVE void grab_end(TViewer *viewer);
EMSCRIPTEN_KEEPALIVE void apply_weights( EMSCRIPTEN_KEEPALIVE void apply_weights(
void *sceneManager, TSceneManager *sceneManager,
EntityId entity, EntityId entity,
const char *const entityName, const char *const entityName,
float *const weights, float *const weights,
int count); int count);
EMSCRIPTEN_KEEPALIVE bool set_morph_target_weights( EMSCRIPTEN_KEEPALIVE bool set_morph_target_weights(
void *sceneManager, TSceneManager *sceneManager,
EntityId entity, EntityId entity,
const float *const morphData, const float *const morphData,
int numWeights); int numWeights);
EMSCRIPTEN_KEEPALIVE bool set_morph_animation( EMSCRIPTEN_KEEPALIVE bool set_morph_animation(
void *sceneManager, TSceneManager *sceneManager,
EntityId entity, EntityId entity,
const float *const morphData, const float *const morphData,
const int *const morphIndices, const int *const morphIndices,
@@ -147,19 +148,19 @@ extern "C"
int numFrames, int numFrames,
float frameLengthInMs); float frameLengthInMs);
EMSCRIPTEN_KEEPALIVE TMaterialInstance *create_material_instance(void *const sceneManager, TMaterialKey materialConfig); EMSCRIPTEN_KEEPALIVE TMaterialInstance *create_material_instance(TSceneManager *sceneManager, TMaterialKey materialConfig);
EMSCRIPTEN_KEEPALIVE TMaterialInstance *create_unlit_material_instance(void *const sceneManager); EMSCRIPTEN_KEEPALIVE TMaterialInstance *create_unlit_material_instance(TSceneManager *sceneManager);
EMSCRIPTEN_KEEPALIVE void destroy_material_instance(void *const sceneManager, TMaterialInstance *instance); EMSCRIPTEN_KEEPALIVE void destroy_material_instance(TSceneManager *sceneManager, TMaterialInstance *instance);
EMSCRIPTEN_KEEPALIVE void clear_morph_animation( EMSCRIPTEN_KEEPALIVE void clear_morph_animation(
void *sceneManager, TSceneManager *sceneManager,
EntityId entity); EntityId entity);
EMSCRIPTEN_KEEPALIVE void reset_to_rest_pose( EMSCRIPTEN_KEEPALIVE void reset_to_rest_pose(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset); EntityId asset);
EMSCRIPTEN_KEEPALIVE void add_bone_animation( EMSCRIPTEN_KEEPALIVE void add_bone_animation(
void *sceneManager, TSceneManager *sceneManager,
EntityId entity, EntityId entity,
int skinIndex, int skinIndex,
int boneIndex, int boneIndex,
@@ -169,47 +170,47 @@ extern "C"
float fadeOutInSecs, float fadeOutInSecs,
float fadeInInSecs, float fadeInInSecs,
float maxDelta); float maxDelta);
EMSCRIPTEN_KEEPALIVE void get_local_transform(void *sceneManager, EMSCRIPTEN_KEEPALIVE void get_local_transform(TSceneManager *sceneManager,
EntityId entityId, float *const); EntityId entityId, float *const);
EMSCRIPTEN_KEEPALIVE void get_rest_local_transforms(void *sceneManager, EMSCRIPTEN_KEEPALIVE void get_rest_local_transforms(TSceneManager *sceneManager,
EntityId entityId, int skinIndex, float *const out, int numBones); EntityId entityId, int skinIndex, float *const out, int numBones);
EMSCRIPTEN_KEEPALIVE void get_world_transform(void *sceneManager, EMSCRIPTEN_KEEPALIVE void get_world_transform(TSceneManager *sceneManager,
EntityId entityId, float *const); EntityId entityId, float *const);
EMSCRIPTEN_KEEPALIVE void get_inverse_bind_matrix(void *sceneManager, EMSCRIPTEN_KEEPALIVE void get_inverse_bind_matrix(TSceneManager *sceneManager,
EntityId entityId, int skinIndex, int boneIndex, float *const); EntityId entityId, int skinIndex, int boneIndex, float *const);
EMSCRIPTEN_KEEPALIVE bool set_bone_transform( EMSCRIPTEN_KEEPALIVE bool set_bone_transform(
void *sceneManager, TSceneManager *sceneManager,
EntityId entity, EntityId entity,
int skinIndex, int skinIndex,
int boneIndex, int boneIndex,
const float *const transform); const float *const transform);
EMSCRIPTEN_KEEPALIVE void play_animation(void *sceneManager, EntityId entity, int index, bool loop, bool reverse, bool replaceActive, float crossfade, float startOffset); EMSCRIPTEN_KEEPALIVE void play_animation(TSceneManager *sceneManager, EntityId entity, int index, bool loop, bool reverse, bool replaceActive, float crossfade, float startOffset);
EMSCRIPTEN_KEEPALIVE void set_animation_frame(void *sceneManager, EntityId entity, int animationIndex, int animationFrame); EMSCRIPTEN_KEEPALIVE void set_animation_frame(TSceneManager *sceneManager, EntityId entity, int animationIndex, int animationFrame);
EMSCRIPTEN_KEEPALIVE void stop_animation(void *sceneManager, EntityId entity, int index); EMSCRIPTEN_KEEPALIVE void stop_animation(TSceneManager *sceneManager, EntityId entity, int index);
EMSCRIPTEN_KEEPALIVE int get_animation_count(void *sceneManager, EntityId asset); EMSCRIPTEN_KEEPALIVE int get_animation_count(TSceneManager *sceneManager, EntityId asset);
EMSCRIPTEN_KEEPALIVE void get_animation_name(void *sceneManager, EntityId entity, char *const outPtr, int index); EMSCRIPTEN_KEEPALIVE void get_animation_name(TSceneManager *sceneManager, EntityId entity, char *const outPtr, int index);
EMSCRIPTEN_KEEPALIVE float get_animation_duration(void *sceneManager, EntityId entity, int index); EMSCRIPTEN_KEEPALIVE float get_animation_duration(TSceneManager *sceneManager, EntityId entity, int index);
EMSCRIPTEN_KEEPALIVE int get_bone_count(void *sceneManager, EntityId assetEntity, int skinIndex); EMSCRIPTEN_KEEPALIVE int get_bone_count(TSceneManager *sceneManager, EntityId assetEntity, int skinIndex);
EMSCRIPTEN_KEEPALIVE void get_bone_names(void *sceneManager, EntityId assetEntity, const char **outPtr, int skinIndex); EMSCRIPTEN_KEEPALIVE void get_bone_names(TSceneManager *sceneManager, EntityId assetEntity, const char **outPtr, int skinIndex);
EMSCRIPTEN_KEEPALIVE EntityId get_bone(void *sceneManager, EMSCRIPTEN_KEEPALIVE EntityId get_bone(TSceneManager *sceneManager,
EntityId entityId, EntityId entityId,
int skinIndex, int skinIndex,
int boneIndex); int boneIndex);
EMSCRIPTEN_KEEPALIVE bool set_transform(void *sceneManager, EntityId entityId, const float *const transform); EMSCRIPTEN_KEEPALIVE bool set_transform(TSceneManager *sceneManager, EntityId entityId, const float *const transform);
EMSCRIPTEN_KEEPALIVE bool update_bone_matrices(void *sceneManager, EntityId entityId); EMSCRIPTEN_KEEPALIVE bool update_bone_matrices(TSceneManager *sceneManager, EntityId entityId);
EMSCRIPTEN_KEEPALIVE void get_morph_target_name(void *sceneManager, EntityId assetEntity, EntityId childEntity, char *const outPtr, int index); EMSCRIPTEN_KEEPALIVE void get_morph_target_name(TSceneManager *sceneManager, EntityId assetEntity, EntityId childEntity, char *const outPtr, int index);
EMSCRIPTEN_KEEPALIVE int get_morph_target_name_count(void *sceneManager, EntityId assetEntity, EntityId childEntity); EMSCRIPTEN_KEEPALIVE int get_morph_target_name_count(TSceneManager *sceneManager, EntityId assetEntity, EntityId childEntity);
EMSCRIPTEN_KEEPALIVE void remove_entity(TViewer *viewer, EntityId asset); EMSCRIPTEN_KEEPALIVE void remove_entity(TViewer *viewer, EntityId asset);
EMSCRIPTEN_KEEPALIVE void clear_entities(TViewer *viewer); EMSCRIPTEN_KEEPALIVE void clear_entities(TViewer *viewer);
EMSCRIPTEN_KEEPALIVE bool set_material_color(void *sceneManager, EntityId entity, const char *meshName, int materialIndex, const float r, const float g, const float b, const float a); EMSCRIPTEN_KEEPALIVE bool set_material_color(TSceneManager *sceneManager, EntityId entity, const char *meshName, int materialIndex, const float r, const float g, const float b, const float a);
EMSCRIPTEN_KEEPALIVE void transform_to_unit_cube(void *sceneManager, EntityId asset); EMSCRIPTEN_KEEPALIVE void transform_to_unit_cube(TSceneManager *sceneManager, EntityId asset);
EMSCRIPTEN_KEEPALIVE void queue_position_update(void *sceneManager, EntityId entity, float x, float y, float z, bool relative); EMSCRIPTEN_KEEPALIVE void queue_position_update(TSceneManager *sceneManager, EntityId entity, float x, float y, float z, bool relative);
EMSCRIPTEN_KEEPALIVE void queue_relative_position_update_world_axis(void *sceneManager, EntityId entity, float viewportX, float viewportY, float x, float y, float z); EMSCRIPTEN_KEEPALIVE void queue_relative_position_update_world_axis(TSceneManager *sceneManager, EntityId entity, float viewportX, float viewportY, float x, float y, float z);
EMSCRIPTEN_KEEPALIVE void queue_position_update_from_viewport_coords(void *sceneManager, EntityId entity, float viewportX, float viewportY); EMSCRIPTEN_KEEPALIVE void queue_position_update_from_viewport_coords(TSceneManager *sceneManager, EntityId entity, float viewportX, float viewportY);
EMSCRIPTEN_KEEPALIVE void queue_rotation_update(void *sceneManager, EntityId entity, float rads, float x, float y, float z, float w, bool relative); EMSCRIPTEN_KEEPALIVE void queue_rotation_update(TSceneManager *sceneManager, EntityId entity, float rads, float x, float y, float z, float w, bool relative);
EMSCRIPTEN_KEEPALIVE void set_position(void *sceneManager, EntityId entity, float x, float y, float z); EMSCRIPTEN_KEEPALIVE void set_position(TSceneManager *sceneManager, EntityId entity, float x, float y, float z);
EMSCRIPTEN_KEEPALIVE void set_rotation(void *sceneManager, EntityId entity, float rads, float x, float y, float z, float w); EMSCRIPTEN_KEEPALIVE void set_rotation(TSceneManager *sceneManager, EntityId entity, float rads, float x, float y, float z, float w);
EMSCRIPTEN_KEEPALIVE void set_scale(void *sceneManager, EntityId entity, float scale); EMSCRIPTEN_KEEPALIVE void set_scale(TSceneManager *sceneManager, EntityId entity, float scale);
// Camera methods // Camera methods
EMSCRIPTEN_KEEPALIVE void set_view_frustum_culling(TViewer *viewer, bool enabled); EMSCRIPTEN_KEEPALIVE void set_view_frustum_culling(TViewer *viewer, bool enabled);
@@ -227,38 +228,46 @@ extern "C"
EMSCRIPTEN_KEEPALIVE double get_camera_near(TCamera *camera); EMSCRIPTEN_KEEPALIVE double get_camera_near(TCamera *camera);
EMSCRIPTEN_KEEPALIVE double get_camera_culling_far(TCamera *camera); EMSCRIPTEN_KEEPALIVE double get_camera_culling_far(TCamera *camera);
EMSCRIPTEN_KEEPALIVE float get_camera_fov(TCamera *camera, bool horizontal); EMSCRIPTEN_KEEPALIVE float get_camera_fov(TCamera *camera, bool horizontal);
EMSCRIPTEN_KEEPALIVE void set_camera_lens_projection(TCamera *camera, double near, double far, double aspect, double focalLength);
EMSCRIPTEN_KEEPALIVE void set_camera_focus_distance(TCamera *camera, float focusDistance); EMSCRIPTEN_KEEPALIVE void set_camera_focus_distance(TCamera *camera, float focusDistance);
EMSCRIPTEN_KEEPALIVE void set_camera_manipulator_options(TViewer *viewer, _ManipulatorMode mode, double orbitSpeedX, double orbitSpeedY, double zoomSpeed); EMSCRIPTEN_KEEPALIVE void set_camera_manipulator_options(TViewer *viewer, _ManipulatorMode mode, double orbitSpeedX, double orbitSpeedY, double zoomSpeed);
EMSCRIPTEN_KEEPALIVE void Camera_setCustomProjectionWithCulling(TCamera* camera, double4x4 projectionMatrix, double near, double far); EMSCRIPTEN_KEEPALIVE void Camera_setCustomProjectionWithCulling(TCamera* camera, double4x4 projectionMatrix, double near, double far);
EMSCRIPTEN_KEEPALIVE void Camera_setLensProjection(TCamera *camera, double near, double far, double aspect, double focalLength);
EMSCRIPTEN_KEEPALIVE double4x4 Camera_getModelMatrix(TCamera* camera); EMSCRIPTEN_KEEPALIVE double4x4 Camera_getModelMatrix(TCamera* camera);
EMSCRIPTEN_KEEPALIVE EntityId Camera_getEntity(TCamera* camera);
EMSCRIPTEN_KEEPALIVE TCamera *Engine_getCameraComponent(TEngine *engine, EntityId entity); EMSCRIPTEN_KEEPALIVE TCamera *Engine_getCameraComponent(TEngine *engine, EntityId entity);
EMSCRIPTEN_KEEPALIVE int hide_mesh(void *sceneManager, EntityId entity, const char *meshName); EMSCRIPTEN_KEEPALIVE TEntityManager *Engine_getEntityManager(TEngine *engine);
EMSCRIPTEN_KEEPALIVE int reveal_mesh(void *sceneManager, EntityId entity, const char *meshName);
// SceneManager
EMSCRIPTEN_KEEPALIVE TCamera* SceneManager_createCamera(TSceneManager *sceneManager);
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyCamera(TSceneManager *sceneManager, TCamera* camera);
EMSCRIPTEN_KEEPALIVE void SceneManager_setCamera(TSceneManager *sceneManager, TCamera* camera);
EMSCRIPTEN_KEEPALIVE int hide_mesh(TSceneManager *sceneManager, EntityId entity, const char *meshName);
EMSCRIPTEN_KEEPALIVE int reveal_mesh(TSceneManager *sceneManager, EntityId entity, const char *meshName);
EMSCRIPTEN_KEEPALIVE void set_post_processing(TViewer *viewer, bool enabled); EMSCRIPTEN_KEEPALIVE void set_post_processing(TViewer *viewer, bool enabled);
EMSCRIPTEN_KEEPALIVE void set_shadows_enabled(TViewer *viewer, bool enabled); EMSCRIPTEN_KEEPALIVE void set_shadows_enabled(TViewer *viewer, bool enabled);
EMSCRIPTEN_KEEPALIVE void set_shadow_type(TViewer *viewer, int shadowType); EMSCRIPTEN_KEEPALIVE void set_shadow_type(TViewer *viewer, int shadowType);
EMSCRIPTEN_KEEPALIVE void set_soft_shadow_options(TViewer *viewer, float penumbraScale, float penumbraRatioScale); EMSCRIPTEN_KEEPALIVE void set_soft_shadow_options(TViewer *viewer, float penumbraScale, float penumbraRatioScale);
EMSCRIPTEN_KEEPALIVE void set_antialiasing(TViewer *viewer, bool msaa, bool fxaa, bool taa); EMSCRIPTEN_KEEPALIVE void set_antialiasing(TViewer *viewer, bool msaa, bool fxaa, bool taa);
EMSCRIPTEN_KEEPALIVE void filament_pick(TViewer *viewer, int x, int y, void (*callback)(EntityId entityId, int x, int y)); EMSCRIPTEN_KEEPALIVE void filament_pick(TViewer *viewer, int x, int y, void (*callback)(EntityId entityId, int x, int y));
EMSCRIPTEN_KEEPALIVE const char *get_name_for_entity(void *const sceneManager, const EntityId entityId); EMSCRIPTEN_KEEPALIVE const char *get_name_for_entity(TSceneManager *sceneManager, const EntityId entityId);
EMSCRIPTEN_KEEPALIVE EntityId find_child_entity_by_name(void *const sceneManager, const EntityId parent, const char *name); EMSCRIPTEN_KEEPALIVE EntityId find_child_entity_by_name(TSceneManager *sceneManager, const EntityId parent, const char *name);
EMSCRIPTEN_KEEPALIVE int get_entity_count(void *const sceneManager, const EntityId target, bool renderableOnly); EMSCRIPTEN_KEEPALIVE int get_entity_count(TSceneManager *sceneManager, const EntityId target, bool renderableOnly);
EMSCRIPTEN_KEEPALIVE void get_entities(void *const sceneManager, const EntityId target, bool renderableOnly, EntityId *out); EMSCRIPTEN_KEEPALIVE void get_entities(TSceneManager *sceneManager, const EntityId target, bool renderableOnly, EntityId *out);
EMSCRIPTEN_KEEPALIVE const char *get_entity_name_at(void *const sceneManager, const EntityId target, int index, bool renderableOnly); EMSCRIPTEN_KEEPALIVE const char *get_entity_name_at(TSceneManager *sceneManager, const EntityId target, int index, bool renderableOnly);
EMSCRIPTEN_KEEPALIVE void set_recording(TViewer *viewer, bool recording); EMSCRIPTEN_KEEPALIVE void set_recording(TViewer *viewer, bool recording);
EMSCRIPTEN_KEEPALIVE void set_recording_output_directory(TViewer *viewer, const char *outputDirectory); EMSCRIPTEN_KEEPALIVE void set_recording_output_directory(TViewer *viewer, const char *outputDirectory);
EMSCRIPTEN_KEEPALIVE void ios_dummy(); EMSCRIPTEN_KEEPALIVE void ios_dummy();
EMSCRIPTEN_KEEPALIVE void thermion_flutter_free(void *ptr); EMSCRIPTEN_KEEPALIVE void thermion_flutter_free(void *ptr);
EMSCRIPTEN_KEEPALIVE void add_collision_component(void *const sceneManager, EntityId entityId, void (*callback)(const EntityId entityId1, const EntityId entityId2), bool affectsCollidingTransform); EMSCRIPTEN_KEEPALIVE void add_collision_component(TSceneManager *sceneManager, EntityId entityId, void (*callback)(const EntityId entityId1, const EntityId entityId2), bool affectsCollidingTransform);
EMSCRIPTEN_KEEPALIVE void remove_collision_component(void *const sceneManager, EntityId entityId); EMSCRIPTEN_KEEPALIVE void remove_collision_component(TSceneManager *sceneManager, EntityId entityId);
EMSCRIPTEN_KEEPALIVE bool add_animation_component(void *const sceneManager, EntityId entityId); EMSCRIPTEN_KEEPALIVE bool add_animation_component(TSceneManager *sceneManager, EntityId entityId);
EMSCRIPTEN_KEEPALIVE void remove_animation_component(void *const sceneManager, EntityId entityId); EMSCRIPTEN_KEEPALIVE void remove_animation_component(TSceneManager *sceneManager, EntityId entityId);
EMSCRIPTEN_KEEPALIVE EntityId create_geometry( EMSCRIPTEN_KEEPALIVE EntityId create_geometry(
void *const sceneManager, TSceneManager *sceneManager,
float *vertices, float *vertices,
int numVertices, int numVertices,
float *normals, float *normals,
@@ -270,30 +279,30 @@ extern "C"
int primitiveType, int primitiveType,
TMaterialInstance *materialInstance, TMaterialInstance *materialInstance,
bool keepData); bool keepData);
EMSCRIPTEN_KEEPALIVE EntityId get_parent(void *const sceneManager, EntityId child); EMSCRIPTEN_KEEPALIVE EntityId get_parent(TSceneManager *sceneManager, EntityId child);
EMSCRIPTEN_KEEPALIVE EntityId get_ancestor(void *const sceneManager, EntityId child); EMSCRIPTEN_KEEPALIVE EntityId get_ancestor(TSceneManager *sceneManager, EntityId child);
EMSCRIPTEN_KEEPALIVE void set_parent(void *const sceneManager, EntityId child, EntityId parent, bool preserveScaling); EMSCRIPTEN_KEEPALIVE void set_parent(TSceneManager *sceneManager, EntityId child, EntityId parent, bool preserveScaling);
EMSCRIPTEN_KEEPALIVE void test_collisions(void *const sceneManager, EntityId entity); EMSCRIPTEN_KEEPALIVE void test_collisions(TSceneManager *sceneManager, EntityId entity);
EMSCRIPTEN_KEEPALIVE void set_priority(void *const sceneManager, EntityId entityId, int priority); EMSCRIPTEN_KEEPALIVE void set_priority(TSceneManager *sceneManager, EntityId entityId, int priority);
EMSCRIPTEN_KEEPALIVE void get_gizmo(void *const sceneManager, EntityId *out); EMSCRIPTEN_KEEPALIVE void get_gizmo(TSceneManager *sceneManager, EntityId *out);
EMSCRIPTEN_KEEPALIVE Aabb2 get_bounding_box(void *const sceneManager, EntityId entity); EMSCRIPTEN_KEEPALIVE Aabb2 get_bounding_box(TSceneManager *sceneManager, EntityId entity);
EMSCRIPTEN_KEEPALIVE void get_bounding_box_to_out(void *const sceneManager, EntityId entity, float *minX, float *minY, float *maxX, float *maxY); EMSCRIPTEN_KEEPALIVE void get_bounding_box_to_out(TSceneManager *sceneManager, EntityId entity, float *minX, float *minY, float *maxX, float *maxY);
EMSCRIPTEN_KEEPALIVE void set_layer_visibility(void *const sceneManager, int layer, bool visible); EMSCRIPTEN_KEEPALIVE void set_layer_visibility(TSceneManager *sceneManager, int layer, bool visible);
EMSCRIPTEN_KEEPALIVE void set_visibility_layer(void *const sceneManager, EntityId entity, int layer); EMSCRIPTEN_KEEPALIVE void set_visibility_layer(TSceneManager *sceneManager, EntityId entity, int layer);
EMSCRIPTEN_KEEPALIVE void pick_gizmo(void *const sceneManager, int x, int y, void (*callback)(EntityId entityId, int x, int y)); EMSCRIPTEN_KEEPALIVE void pick_gizmo(TSceneManager *sceneManager, int x, int y, void (*callback)(EntityId entityId, int x, int y));
EMSCRIPTEN_KEEPALIVE void set_gizmo_visibility(void *const sceneManager, bool visible); EMSCRIPTEN_KEEPALIVE void set_gizmo_visibility(TSceneManager *sceneManager, bool visible);
EMSCRIPTEN_KEEPALIVE void set_stencil_highlight(void *const sceneManager, EntityId entity, float r, float g, float b); EMSCRIPTEN_KEEPALIVE void set_stencil_highlight(TSceneManager *sceneManager, EntityId entity, float r, float g, float b);
EMSCRIPTEN_KEEPALIVE void remove_stencil_highlight(void *const sceneManager, EntityId entity); EMSCRIPTEN_KEEPALIVE void remove_stencil_highlight(TSceneManager *sceneManager, EntityId entity);
EMSCRIPTEN_KEEPALIVE void set_material_property_float(void *const sceneManager, EntityId entity, int materialIndex, const char *property, float value); EMSCRIPTEN_KEEPALIVE void set_material_property_float(TSceneManager *sceneManager, EntityId entity, int materialIndex, const char *property, float value);
EMSCRIPTEN_KEEPALIVE void set_material_property_int(void *const sceneManager, EntityId entity, int materialIndex, const char *property, int value); EMSCRIPTEN_KEEPALIVE void set_material_property_int(TSceneManager *sceneManager, EntityId entity, int materialIndex, const char *property, int value);
EMSCRIPTEN_KEEPALIVE void set_material_property_float4(void *const sceneManager, EntityId entity, int materialIndex, const char *property, double4 value); EMSCRIPTEN_KEEPALIVE void set_material_property_float4(TSceneManager *sceneManager, EntityId entity, int materialIndex, const char *property, double4 value);
EMSCRIPTEN_KEEPALIVE void set_material_depth_write(void *const sceneManager, EntityId entity, int materialIndex, bool enabled); EMSCRIPTEN_KEEPALIVE void set_material_depth_write(TSceneManager *sceneManager, EntityId entity, int materialIndex, bool enabled);
EMSCRIPTEN_KEEPALIVE void unproject_texture(TViewer* viewer, EntityId entity,uint8_t* input, uint32_t inputWidth, uint32_t inputHeight, uint8_t *out, uint32_t outWidth, uint32_t outHeight); EMSCRIPTEN_KEEPALIVE void unproject_texture(TViewer* viewer, EntityId entity,uint8_t* input, uint32_t inputWidth, uint32_t inputHeight, uint8_t *out, uint32_t outWidth, uint32_t outHeight);
EMSCRIPTEN_KEEPALIVE void *const create_texture(void *const sceneManager, uint8_t *data, size_t length); EMSCRIPTEN_KEEPALIVE void *const create_texture(TSceneManager *sceneManager, uint8_t *data, size_t length);
EMSCRIPTEN_KEEPALIVE void destroy_texture(void *const sceneManager, void *const texture); EMSCRIPTEN_KEEPALIVE void destroy_texture(TSceneManager *sceneManager, void *const texture);
EMSCRIPTEN_KEEPALIVE void apply_texture_to_material(void *const sceneManager, EntityId entity, void *const texture, const char *parameterName, int materialIndex); EMSCRIPTEN_KEEPALIVE void apply_texture_to_material(TSceneManager *sceneManager, EntityId entity, void *const texture, const char *parameterName, int materialIndex);
EMSCRIPTEN_KEEPALIVE TMaterialInstance* get_material_instance_at(void *const sceneManager, EntityId entity, int materialIndex); EMSCRIPTEN_KEEPALIVE TMaterialInstance* get_material_instance_at(TSceneManager *sceneManager, EntityId entity, int materialIndex);
EMSCRIPTEN_KEEPALIVE void MaterialInstance_setDepthWrite(TMaterialInstance* materialInstance, bool enabled); EMSCRIPTEN_KEEPALIVE void MaterialInstance_setDepthWrite(TMaterialInstance* materialInstance, bool enabled);
EMSCRIPTEN_KEEPALIVE void MaterialInstance_setDepthCulling(TMaterialInstance* materialInstance, bool enabled); EMSCRIPTEN_KEEPALIVE void MaterialInstance_setDepthCulling(TMaterialInstance* materialInstance, bool enabled);

32
thermion_dart/native/include/ThermionDartRenderThreadApi.h
View File

@@ -66,44 +66,44 @@ extern "C"
void (*callback)(EntityId)); void (*callback)(EntityId));
EMSCRIPTEN_KEEPALIVE void remove_light_render_thread(TViewer *viewer, EntityId entityId); EMSCRIPTEN_KEEPALIVE void remove_light_render_thread(TViewer *viewer, EntityId entityId);
EMSCRIPTEN_KEEPALIVE void clear_lights_render_thread(TViewer *viewer); EMSCRIPTEN_KEEPALIVE void clear_lights_render_thread(TViewer *viewer);
EMSCRIPTEN_KEEPALIVE void load_glb_render_thread(void *const sceneManager, const char *assetPath, int numInstances, bool keepData, void (*callback)(EntityId)); EMSCRIPTEN_KEEPALIVE void load_glb_render_thread(TSceneManager *sceneManager, const char *assetPath, int numInstances, bool keepData, void (*callback)(EntityId));
EMSCRIPTEN_KEEPALIVE void load_glb_from_buffer_render_thread(void *const sceneManager, const uint8_t *const data, size_t length, int numInstances, bool keepData, int priority, int layer, void (*callback)(EntityId)); EMSCRIPTEN_KEEPALIVE void load_glb_from_buffer_render_thread(TSceneManager *sceneManager, const uint8_t *const data, size_t length, int numInstances, bool keepData, int priority, int layer, void (*callback)(EntityId));
EMSCRIPTEN_KEEPALIVE void load_gltf_render_thread(void *const sceneManager, const char *assetPath, const char *relativePath, bool keepData, void (*callback)(EntityId)); EMSCRIPTEN_KEEPALIVE void load_gltf_render_thread(TSceneManager *sceneManager, const char *assetPath, const char *relativePath, bool keepData, void (*callback)(EntityId));
EMSCRIPTEN_KEEPALIVE void create_instance_render_thread(void *const sceneManager, EntityId entityId, void (*callback)(EntityId)); EMSCRIPTEN_KEEPALIVE void create_instance_render_thread(TSceneManager *sceneManager, EntityId entityId, void (*callback)(EntityId));
EMSCRIPTEN_KEEPALIVE void remove_entity_render_thread(TViewer *viewer, EntityId asset, void (*callback)()); EMSCRIPTEN_KEEPALIVE void remove_entity_render_thread(TViewer *viewer, EntityId asset, void (*callback)());
EMSCRIPTEN_KEEPALIVE void clear_entities_render_thread(TViewer *viewer, void (*callback)()); EMSCRIPTEN_KEEPALIVE void clear_entities_render_thread(TViewer *viewer, void (*callback)());
EMSCRIPTEN_KEEPALIVE void set_camera_render_thread(TViewer *viewer, EntityId asset, const char *nodeName, void (*callback)(bool)); EMSCRIPTEN_KEEPALIVE void set_camera_render_thread(TViewer *viewer, EntityId asset, const char *nodeName, void (*callback)(bool));
EMSCRIPTEN_KEEPALIVE void apply_weights_render_thread( EMSCRIPTEN_KEEPALIVE void apply_weights_render_thread(
void *const sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
const char *const entityName, const char *const entityName,
float *const weights, float *const weights,
int count); int count);
EMSCRIPTEN_KEEPALIVE void set_animation_frame_render_thread(void *const sceneManager, EntityId asset, int animationIndex, int animationFrame); EMSCRIPTEN_KEEPALIVE void set_animation_frame_render_thread(TSceneManager *sceneManager, EntityId asset, int animationIndex, int animationFrame);
EMSCRIPTEN_KEEPALIVE void stop_animation_render_thread(void *const sceneManager, EntityId asset, int index); EMSCRIPTEN_KEEPALIVE void stop_animation_render_thread(TSceneManager *sceneManager, EntityId asset, int index);
EMSCRIPTEN_KEEPALIVE void get_animation_count_render_thread(void *const sceneManager, EntityId asset, void (*callback)(int)); EMSCRIPTEN_KEEPALIVE void get_animation_count_render_thread(TSceneManager *sceneManager, EntityId asset, void (*callback)(int));
EMSCRIPTEN_KEEPALIVE void get_animation_name_render_thread(void *const sceneManager, EntityId asset, char *const outPtr, int index, void (*callback)()); EMSCRIPTEN_KEEPALIVE void get_animation_name_render_thread(TSceneManager *sceneManager, EntityId asset, char *const outPtr, int index, void (*callback)());
EMSCRIPTEN_KEEPALIVE void get_morph_target_name_render_thread(void *const sceneManager, EntityId assetEntity, EntityId childEntity, char *const outPtr, int index, void (*callback)()); EMSCRIPTEN_KEEPALIVE void get_morph_target_name_render_thread(TSceneManager *sceneManager, EntityId assetEntity, EntityId childEntity, char *const outPtr, int index, void (*callback)());
EMSCRIPTEN_KEEPALIVE void get_morph_target_name_count_render_thread(void *const sceneManager, EntityId asset, EntityId childEntity, void (*callback)(int32_t)); EMSCRIPTEN_KEEPALIVE void get_morph_target_name_count_render_thread(TSceneManager *sceneManager, EntityId asset, EntityId childEntity, void (*callback)(int32_t));
EMSCRIPTEN_KEEPALIVE void set_morph_target_weights_render_thread(void *const sceneManager, EMSCRIPTEN_KEEPALIVE void set_morph_target_weights_render_thread(TSceneManager *sceneManager,
EntityId asset, EntityId asset,
const float *const morphData, const float *const morphData,
int numWeights, int numWeights,
void (*callback)(bool)); void (*callback)(bool));
EMSCRIPTEN_KEEPALIVE void update_bone_matrices_render_thread(void *sceneManager, EMSCRIPTEN_KEEPALIVE void update_bone_matrices_render_thread(TSceneManager *sceneManager,
EntityId asset, void(*callback)(bool)); EntityId asset, void(*callback)(bool));
EMSCRIPTEN_KEEPALIVE void set_bone_transform_render_thread( EMSCRIPTEN_KEEPALIVE void set_bone_transform_render_thread(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
int skinIndex, int skinIndex,
int boneIndex, int boneIndex,
const float *const transform, const float *const transform,
void (*callback)(bool)); void (*callback)(bool));
EMSCRIPTEN_KEEPALIVE void set_post_processing_render_thread(TViewer *viewer, bool enabled); EMSCRIPTEN_KEEPALIVE void set_post_processing_render_thread(TViewer *viewer, bool enabled);
EMSCRIPTEN_KEEPALIVE void reset_to_rest_pose_render_thread(void *const sceneManager, EntityId entityId, void(*callback)()); EMSCRIPTEN_KEEPALIVE void reset_to_rest_pose_render_thread(TSceneManager *sceneManager, EntityId entityId, void(*callback)());
EMSCRIPTEN_KEEPALIVE void create_geometry_render_thread( EMSCRIPTEN_KEEPALIVE void create_geometry_render_thread(
void *const sceneManager, TSceneManager *sceneManager,
float *vertices, float *vertices,
int numVertices, int numVertices,
float *normals, float *normals,

1
thermion_dart/native/src/FilamentViewer.cpp
View File

@@ -750,7 +750,6 @@ namespace thermion_filament
delete _sceneManager; delete _sceneManager;
_engine->destroyCameraComponent(_mainCamera->getEntity()); _engine->destroyCameraComponent(_mainCamera->getEntity());
_mainCamera = nullptr; _mainCamera = nullptr;
_view->setScene(nullptr);
_engine->destroy(_view); _engine->destroy(_view);
_engine->destroy(_scene); _engine->destroy(_scene);
_engine->destroy(_renderer); _engine->destroy(_renderer);

29
thermion_dart/native/src/SceneManager.cpp
View File

@@ -110,6 +110,14 @@ namespace thermion_filament
SceneManager::~SceneManager() SceneManager::~SceneManager()
{ {
_view->setScene(nullptr);
_view->setCamera(nullptr);
for(auto camera : _cameras) {
auto entity = camera->getEntity();
_engine->destroyCameraComponent(entity);
_engine->getEntityManager().destroy(entity);
}
_cameras.clear();
delete gizmo; delete gizmo;
_gridOverlay->destroy(); _gridOverlay->destroy();
destroyAll(); destroyAll();
@@ -2633,6 +2641,27 @@ EntityId SceneManager::createGeometry(
auto instance = _unlitMaterialProvider->createMaterialInstance(nullptr, &uvmap); auto instance = _unlitMaterialProvider->createMaterialInstance(nullptr, &uvmap);
return instance; return instance;
} }
Camera* SceneManager::createCamera() {
auto entity = EntityManager::get().create();
auto camera = _engine->createCamera(entity);
_cameras.push_back(camera);
return camera;
}
void SceneManager::destroyCamera(Camera* camera) {
auto entity = camera->getEntity();
_engine->destroyCameraComponent(entity);
_engine->getEntityManager().destroy(entity);
auto it = std::find(_cameras.begin(), _cameras.end(), camera);
if(it != _cameras.end()) {
_cameras.erase(it);
}
}
void SceneManager::setCamera(Camera* camera) {
_view->setCamera(camera);
}
} // namespace thermion_filament } // namespace thermion_filament

191
thermion_dart/native/src/ThermionDartApi.cpp
View File

@@ -177,32 +177,32 @@ extern "C"
((FilamentViewer *)viewer)->clearLights(); ((FilamentViewer *)viewer)->clearLights();
} }
EMSCRIPTEN_KEEPALIVE EntityId load_glb(void *sceneManager, const char *assetPath, int numInstances, bool keepData) EMSCRIPTEN_KEEPALIVE EntityId load_glb(TSceneManager *sceneManager, const char *assetPath, int numInstances, bool keepData)
{ {
return ((SceneManager *)sceneManager)->loadGlb(assetPath, numInstances, keepData); return ((SceneManager *)sceneManager)->loadGlb(assetPath, numInstances, keepData);
} }
EMSCRIPTEN_KEEPALIVE EntityId load_glb_from_buffer(void *sceneManager, const void *const data, size_t length, bool keepData, int priority, int layer) EMSCRIPTEN_KEEPALIVE EntityId load_glb_from_buffer(TSceneManager *sceneManager, const void *const data, size_t length, bool keepData, int priority, int layer)
{ {
return ((SceneManager *)sceneManager)->loadGlbFromBuffer((const uint8_t *)data, length, 1, keepData, priority, layer); return ((SceneManager *)sceneManager)->loadGlbFromBuffer((const uint8_t *)data, length, 1, keepData, priority, layer);
} }
EMSCRIPTEN_KEEPALIVE EntityId create_instance(void *sceneManager, EntityId entityId) EMSCRIPTEN_KEEPALIVE EntityId create_instance(TSceneManager *sceneManager, EntityId entityId)
{ {
return ((SceneManager *)sceneManager)->createInstance(entityId); return ((SceneManager *)sceneManager)->createInstance(entityId);
} }
EMSCRIPTEN_KEEPALIVE int get_instance_count(void *sceneManager, EntityId entityId) EMSCRIPTEN_KEEPALIVE int get_instance_count(TSceneManager *sceneManager, EntityId entityId)
{ {
return ((SceneManager *)sceneManager)->getInstanceCount(entityId); return ((SceneManager *)sceneManager)->getInstanceCount(entityId);
} }
EMSCRIPTEN_KEEPALIVE void get_instances(void *sceneManager, EntityId entityId, EntityId *out) EMSCRIPTEN_KEEPALIVE void get_instances(TSceneManager *sceneManager, EntityId entityId, EntityId *out)
{ {
return ((SceneManager *)sceneManager)->getInstances(entityId, out); return ((SceneManager *)sceneManager)->getInstances(entityId, out);
} }
EMSCRIPTEN_KEEPALIVE EntityId load_gltf(void *sceneManager, const char *assetPath, const char *relativePath, bool keepData) EMSCRIPTEN_KEEPALIVE EntityId load_gltf(TSceneManager *sceneManager, const char *assetPath, const char *relativePath, bool keepData)
{ {
return ((SceneManager *)sceneManager)->loadGltf(assetPath, relativePath, keepData); return ((SceneManager *)sceneManager)->loadGltf(assetPath, relativePath, keepData);
} }
@@ -277,7 +277,7 @@ extern "C"
cam->setCustomProjection(mat, near, far); cam->setCustomProjection(mat, near, far);
} }
void set_camera_lens_projection(TCamera *camera, double near, double far, double aspect, double focalLength) void Camera_setLensProjection(TCamera *camera, double near, double far, double aspect, double focalLength)
{ {
auto cam = reinterpret_cast<filament::Camera *>(camera); auto cam = reinterpret_cast<filament::Camera *>(camera);
cam->setLensProjection(focalLength, aspect, near, far); cam->setLensProjection(focalLength, aspect, near, far);
@@ -418,13 +418,15 @@ extern "C"
((FilamentViewer *)viewer)->grabEnd(); ((FilamentViewer *)viewer)->grabEnd();
} }
EMSCRIPTEN_KEEPALIVE void *get_scene_manager(TViewer *viewer) EMSCRIPTEN_KEEPALIVE TSceneManager* Viewer_getSceneManager(TViewer *tViewer)
{ {
return (void *)((FilamentViewer *)viewer)->getSceneManager(); auto * viewer = reinterpret_cast<FilamentViewer*>(tViewer);
auto * sceneManager = viewer->getSceneManager();
return reinterpret_cast<TSceneManager*>(sceneManager);
} }
EMSCRIPTEN_KEEPALIVE void apply_weights( EMSCRIPTEN_KEEPALIVE void apply_weights(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
const char *const entityName, const char *const entityName,
float *const weights, float *const weights,
@@ -434,7 +436,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE bool set_morph_target_weights( EMSCRIPTEN_KEEPALIVE bool set_morph_target_weights(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
const float *const weights, const float *const weights,
const int numWeights) const int numWeights)
@@ -443,7 +445,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE bool set_morph_animation( EMSCRIPTEN_KEEPALIVE bool set_morph_animation(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
const float *const morphData, const float *const morphData,
const int *const morphIndices, const int *const morphIndices,
@@ -455,18 +457,18 @@ extern "C"
return result; return result;
} }
EMSCRIPTEN_KEEPALIVE void clear_morph_animation(void *sceneManager, EntityId asset) EMSCRIPTEN_KEEPALIVE void clear_morph_animation(TSceneManager *sceneManager, EntityId asset)
{ {
((SceneManager *)sceneManager)->clearMorphAnimationBuffer(asset); ((SceneManager *)sceneManager)->clearMorphAnimationBuffer(asset);
} }
EMSCRIPTEN_KEEPALIVE void reset_to_rest_pose(void *sceneManager, EntityId entityId) EMSCRIPTEN_KEEPALIVE void reset_to_rest_pose(TSceneManager *sceneManager, EntityId entityId)
{ {
((SceneManager *)sceneManager)->resetBones(entityId); ((SceneManager *)sceneManager)->resetBones(entityId);
} }
EMSCRIPTEN_KEEPALIVE void add_bone_animation( EMSCRIPTEN_KEEPALIVE void add_bone_animation(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
int skinIndex, int skinIndex,
int boneIndex, int boneIndex,
@@ -505,14 +507,14 @@ extern "C"
((FilamentViewer *)viewer)->setAntiAliasing(msaa, fxaa, taa); ((FilamentViewer *)viewer)->setAntiAliasing(msaa, fxaa, taa);
} }
EMSCRIPTEN_KEEPALIVE EntityId get_bone(void *sceneManager, EMSCRIPTEN_KEEPALIVE EntityId get_bone(TSceneManager *sceneManager,
EntityId entityId, EntityId entityId,
int skinIndex, int skinIndex,
int boneIndex) int boneIndex)
{ {
return ((SceneManager *)sceneManager)->getBone(entityId, skinIndex, boneIndex); return ((SceneManager *)sceneManager)->getBone(entityId, skinIndex, boneIndex);
} }
EMSCRIPTEN_KEEPALIVE void get_world_transform(void *sceneManager, EMSCRIPTEN_KEEPALIVE void get_world_transform(TSceneManager *sceneManager,
EntityId entityId, float *const out) EntityId entityId, float *const out)
{ {
auto transform = ((SceneManager *)sceneManager)->getWorldTransform(entityId); auto transform = ((SceneManager *)sceneManager)->getWorldTransform(entityId);
@@ -534,7 +536,7 @@ extern "C"
out[15] = transform[3][3]; out[15] = transform[3][3];
} }
EMSCRIPTEN_KEEPALIVE void get_local_transform(void *sceneManager, EMSCRIPTEN_KEEPALIVE void get_local_transform(TSceneManager *sceneManager,
EntityId entityId, float *const out) EntityId entityId, float *const out)
{ {
auto transform = ((SceneManager *)sceneManager)->getLocalTransform(entityId); auto transform = ((SceneManager *)sceneManager)->getLocalTransform(entityId);
@@ -556,7 +558,7 @@ extern "C"
out[15] = transform[3][3]; out[15] = transform[3][3];
} }
EMSCRIPTEN_KEEPALIVE void get_rest_local_transforms(void *sceneManager, EMSCRIPTEN_KEEPALIVE void get_rest_local_transforms(TSceneManager *sceneManager,
EntityId entityId, int skinIndex, float *const out, int numBones) EntityId entityId, int skinIndex, float *const out, int numBones)
{ {
const auto transforms = ((SceneManager *)sceneManager)->getBoneRestTranforms(entityId, skinIndex); const auto transforms = ((SceneManager *)sceneManager)->getBoneRestTranforms(entityId, skinIndex);
@@ -579,7 +581,7 @@ extern "C"
} }
} }
EMSCRIPTEN_KEEPALIVE void get_inverse_bind_matrix(void *sceneManager, EMSCRIPTEN_KEEPALIVE void get_inverse_bind_matrix(TSceneManager *sceneManager,
EntityId entityId, int skinIndex, int boneIndex, float *const out) EntityId entityId, int skinIndex, int boneIndex, float *const out)
{ {
auto transform = ((SceneManager *)sceneManager)->getInverseBindMatrix(entityId, skinIndex, boneIndex); auto transform = ((SceneManager *)sceneManager)->getInverseBindMatrix(entityId, skinIndex, boneIndex);
@@ -602,7 +604,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE bool set_bone_transform( EMSCRIPTEN_KEEPALIVE bool set_bone_transform(
void *sceneManager, TSceneManager *sceneManager,
EntityId entityId, EntityId entityId,
int skinIndex, int skinIndex,
int boneIndex, int boneIndex,
@@ -627,7 +629,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE void play_animation( EMSCRIPTEN_KEEPALIVE void play_animation(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
int index, int index,
bool loop, bool loop,
@@ -640,7 +642,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE void set_animation_frame( EMSCRIPTEN_KEEPALIVE void set_animation_frame(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
int animationIndex, int animationIndex,
int animationFrame) int animationFrame)
@@ -648,13 +650,13 @@ extern "C"
// ((SceneManager*)sceneManager)->setAnimationFrame(asset, animationIndex, animationFrame); // ((SceneManager*)sceneManager)->setAnimationFrame(asset, animationIndex, animationFrame);
} }
float get_animation_duration(void *sceneManager, EntityId asset, int animationIndex) float get_animation_duration(TSceneManager *sceneManager, EntityId asset, int animationIndex)
{ {
return ((SceneManager *)sceneManager)->getAnimationDuration(asset, animationIndex); return ((SceneManager *)sceneManager)->getAnimationDuration(asset, animationIndex);
} }
int get_animation_count( int get_animation_count(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset) EntityId asset)
{ {
auto names = ((SceneManager *)sceneManager)->getAnimationNames(asset); auto names = ((SceneManager *)sceneManager)->getAnimationNames(asset);
@@ -662,7 +664,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE void get_animation_name( EMSCRIPTEN_KEEPALIVE void get_animation_name(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
char *const outPtr, char *const outPtr,
int index) int index)
@@ -672,13 +674,13 @@ extern "C"
strcpy(outPtr, name.c_str()); strcpy(outPtr, name.c_str());
} }
EMSCRIPTEN_KEEPALIVE int get_bone_count(void *sceneManager, EntityId assetEntity, int skinIndex) EMSCRIPTEN_KEEPALIVE int get_bone_count(TSceneManager *sceneManager, EntityId assetEntity, int skinIndex)
{ {
auto names = ((SceneManager *)sceneManager)->getBoneNames(assetEntity, skinIndex); auto names = ((SceneManager *)sceneManager)->getBoneNames(assetEntity, skinIndex);
return names->size(); return names->size();
} }
EMSCRIPTEN_KEEPALIVE void get_bone_names(void *sceneManager, EntityId assetEntity, const char **out, int skinIndex) EMSCRIPTEN_KEEPALIVE void get_bone_names(TSceneManager *sceneManager, EntityId assetEntity, const char **out, int skinIndex)
{ {
auto names = ((SceneManager *)sceneManager)->getBoneNames(assetEntity, skinIndex); auto names = ((SceneManager *)sceneManager)->getBoneNames(assetEntity, skinIndex);
for (int i = 0; i < names->size(); i++) for (int i = 0; i < names->size(); i++)
@@ -688,7 +690,7 @@ extern "C"
} }
} }
EMSCRIPTEN_KEEPALIVE bool set_transform(void *sceneManager, EntityId entityId, const float *const transform) EMSCRIPTEN_KEEPALIVE bool set_transform(TSceneManager *sceneManager, EntityId entityId, const float *const transform)
{ {
auto matrix = math::mat4f( auto matrix = math::mat4f(
transform[0], transform[1], transform[2], transform[0], transform[1], transform[2],
@@ -708,18 +710,18 @@ extern "C"
return ((SceneManager *)sceneManager)->setTransform(entityId, matrix); return ((SceneManager *)sceneManager)->setTransform(entityId, matrix);
} }
EMSCRIPTEN_KEEPALIVE bool update_bone_matrices(void *sceneManager, EntityId entityId) EMSCRIPTEN_KEEPALIVE bool update_bone_matrices(TSceneManager *sceneManager, EntityId entityId)
{ {
return ((SceneManager *)sceneManager)->updateBoneMatrices(entityId); return ((SceneManager *)sceneManager)->updateBoneMatrices(entityId);
} }
EMSCRIPTEN_KEEPALIVE int get_morph_target_name_count(void *sceneManager, EntityId assetEntity, EntityId childEntity) EMSCRIPTEN_KEEPALIVE int get_morph_target_name_count(TSceneManager *sceneManager, EntityId assetEntity, EntityId childEntity)
{ {
auto names = ((SceneManager *)sceneManager)->getMorphTargetNames(assetEntity, childEntity); auto names = ((SceneManager *)sceneManager)->getMorphTargetNames(assetEntity, childEntity);
return (int)names->size(); return (int)names->size();
} }
EMSCRIPTEN_KEEPALIVE void get_morph_target_name(void *sceneManager, EntityId assetEntity, EntityId childEntity, char *const outPtr, int index) EMSCRIPTEN_KEEPALIVE void get_morph_target_name(TSceneManager *sceneManager, EntityId assetEntity, EntityId childEntity, char *const outPtr, int index)
{ {
auto names = ((SceneManager *)sceneManager)->getMorphTargetNames(assetEntity, childEntity); auto names = ((SceneManager *)sceneManager)->getMorphTargetNames(assetEntity, childEntity);
std::string name = names->at(index); std::string name = names->at(index);
@@ -736,62 +738,62 @@ extern "C"
((FilamentViewer *)viewer)->clearEntities(); ((FilamentViewer *)viewer)->clearEntities();
} }
bool set_material_color(void *sceneManager, EntityId asset, const char *meshName, int materialIndex, const float r, const float g, const float b, const float a) bool set_material_color(TSceneManager *sceneManager, EntityId asset, const char *meshName, int materialIndex, const float r, const float g, const float b, const float a)
{ {
return ((SceneManager *)sceneManager)->setMaterialColor(asset, meshName, materialIndex, r, g, b, a); return ((SceneManager *)sceneManager)->setMaterialColor(asset, meshName, materialIndex, r, g, b, a);
} }
EMSCRIPTEN_KEEPALIVE void transform_to_unit_cube(void *sceneManager, EntityId asset) EMSCRIPTEN_KEEPALIVE void transform_to_unit_cube(TSceneManager *sceneManager, EntityId asset)
{ {
((SceneManager *)sceneManager)->transformToUnitCube(asset); ((SceneManager *)sceneManager)->transformToUnitCube(asset);
} }
EMSCRIPTEN_KEEPALIVE void set_position(void *sceneManager, EntityId asset, float x, float y, float z) EMSCRIPTEN_KEEPALIVE void set_position(TSceneManager *sceneManager, EntityId asset, float x, float y, float z)
{ {
((SceneManager *)sceneManager)->setPosition(asset, x, y, z); ((SceneManager *)sceneManager)->setPosition(asset, x, y, z);
} }
EMSCRIPTEN_KEEPALIVE void set_rotation(void *sceneManager, EntityId asset, float rads, float x, float y, float z, float w) EMSCRIPTEN_KEEPALIVE void set_rotation(TSceneManager *sceneManager, EntityId asset, float rads, float x, float y, float z, float w)
{ {
((SceneManager *)sceneManager)->setRotation(asset, rads, x, y, z, w); ((SceneManager *)sceneManager)->setRotation(asset, rads, x, y, z, w);
} }
EMSCRIPTEN_KEEPALIVE void set_scale(void *sceneManager, EntityId asset, float scale) EMSCRIPTEN_KEEPALIVE void set_scale(TSceneManager *sceneManager, EntityId asset, float scale)
{ {
((SceneManager *)sceneManager)->setScale(asset, scale); ((SceneManager *)sceneManager)->setScale(asset, scale);
} }
EMSCRIPTEN_KEEPALIVE void queue_position_update(void *sceneManager, EntityId asset, float x, float y, float z, bool relative) EMSCRIPTEN_KEEPALIVE void queue_position_update(TSceneManager *sceneManager, EntityId asset, float x, float y, float z, bool relative)
{ {
((SceneManager *)sceneManager)->queuePositionUpdate(asset, x, y, z, relative); ((SceneManager *)sceneManager)->queuePositionUpdate(asset, x, y, z, relative);
} }
EMSCRIPTEN_KEEPALIVE void queue_relative_position_update_world_axis(void *sceneManager, EntityId entity, float viewportX, float viewportY, float x, float y, float z) EMSCRIPTEN_KEEPALIVE void queue_relative_position_update_world_axis(TSceneManager *sceneManager, EntityId entity, float viewportX, float viewportY, float x, float y, float z)
{ {
((SceneManager *)sceneManager)->queueRelativePositionUpdateWorldAxis(entity, viewportX, viewportY, x, y, z); ((SceneManager *)sceneManager)->queueRelativePositionUpdateWorldAxis(entity, viewportX, viewportY, x, y, z);
} }
EMSCRIPTEN_KEEPALIVE void queue_rotation_update(void *sceneManager, EntityId asset, float rads, float x, float y, float z, float w, bool relative) EMSCRIPTEN_KEEPALIVE void queue_rotation_update(TSceneManager *sceneManager, EntityId asset, float rads, float x, float y, float z, float w, bool relative)
{ {
((SceneManager *)sceneManager)->queueRotationUpdate(asset, rads, x, y, z, w, relative); ((SceneManager *)sceneManager)->queueRotationUpdate(asset, rads, x, y, z, w, relative);
} }
EMSCRIPTEN_KEEPALIVE void queue_position_update_from_viewport_coords(void *sceneManager, EntityId entity, float viewportX, float viewportY) EMSCRIPTEN_KEEPALIVE void queue_position_update_from_viewport_coords(TSceneManager *sceneManager, EntityId entity, float viewportX, float viewportY)
{ {
((SceneManager *)sceneManager)->queueRelativePositionUpdateFromViewportVector(entity, viewportX, viewportY); ((SceneManager *)sceneManager)->queueRelativePositionUpdateFromViewportVector(entity, viewportX, viewportY);
} }
EMSCRIPTEN_KEEPALIVE void stop_animation(void *sceneManager, EntityId asset, int index) EMSCRIPTEN_KEEPALIVE void stop_animation(TSceneManager *sceneManager, EntityId asset, int index)
{ {
((SceneManager *)sceneManager)->stopAnimation(asset, index); ((SceneManager *)sceneManager)->stopAnimation(asset, index);
} }
EMSCRIPTEN_KEEPALIVE int hide_mesh(void *sceneManager, EntityId asset, const char *meshName) EMSCRIPTEN_KEEPALIVE int hide_mesh(TSceneManager *sceneManager, EntityId asset, const char *meshName)
{ {
return ((SceneManager *)sceneManager)->hide(asset, meshName); return ((SceneManager *)sceneManager)->hide(asset, meshName);
} }
EMSCRIPTEN_KEEPALIVE int reveal_mesh(void *sceneManager, EntityId asset, const char *meshName) EMSCRIPTEN_KEEPALIVE int reveal_mesh(TSceneManager *sceneManager, EntityId asset, const char *meshName)
{ {
return ((SceneManager *)sceneManager)->reveal(asset, meshName); return ((SceneManager *)sceneManager)->reveal(asset, meshName);
} }
@@ -801,22 +803,22 @@ extern "C"
((FilamentViewer *)viewer)->pick(static_cast<uint32_t>(x), static_cast<uint32_t>(y), callback); ((FilamentViewer *)viewer)->pick(static_cast<uint32_t>(x), static_cast<uint32_t>(y), callback);
} }
EMSCRIPTEN_KEEPALIVE const char *get_name_for_entity(void *const sceneManager, const EntityId entityId) EMSCRIPTEN_KEEPALIVE const char *get_name_for_entity(TSceneManager *sceneManager, const EntityId entityId)
{ {
return ((SceneManager *)sceneManager)->getNameForEntity(entityId); return ((SceneManager *)sceneManager)->getNameForEntity(entityId);
} }
EMSCRIPTEN_KEEPALIVE int get_entity_count(void *const sceneManager, const EntityId target, bool renderableOnly) EMSCRIPTEN_KEEPALIVE int get_entity_count(TSceneManager *sceneManager, const EntityId target, bool renderableOnly)
{ {
return ((SceneManager *)sceneManager)->getEntityCount(target, renderableOnly); return ((SceneManager *)sceneManager)->getEntityCount(target, renderableOnly);
} }
EMSCRIPTEN_KEEPALIVE void get_entities(void *const sceneManager, const EntityId target, bool renderableOnly, EntityId *out) EMSCRIPTEN_KEEPALIVE void get_entities(TSceneManager *sceneManager, const EntityId target, bool renderableOnly, EntityId *out)
{ {
((SceneManager *)sceneManager)->getEntities(target, renderableOnly, out); ((SceneManager *)sceneManager)->getEntities(target, renderableOnly, out);
} }
EMSCRIPTEN_KEEPALIVE const char *get_entity_name_at(void *const sceneManager, const EntityId target, int index, bool renderableOnly) EMSCRIPTEN_KEEPALIVE const char *get_entity_name_at(TSceneManager *sceneManager, const EntityId target, int index, bool renderableOnly)
{ {
return ((SceneManager *)sceneManager)->getEntityNameAt(target, index, renderableOnly); return ((SceneManager *)sceneManager)->getEntityNameAt(target, index, renderableOnly);
} }
@@ -841,28 +843,28 @@ extern "C"
free(ptr); free(ptr);
} }
EMSCRIPTEN_KEEPALIVE void add_collision_component(void *const sceneManager, EntityId entityId, void (*onCollisionCallback)(const EntityId entityId1, const EntityId entityId2), bool affectsCollidingTransform) EMSCRIPTEN_KEEPALIVE void add_collision_component(TSceneManager *sceneManager, EntityId entityId, void (*onCollisionCallback)(const EntityId entityId1, const EntityId entityId2), bool affectsCollidingTransform)
{ {
((SceneManager *)sceneManager)->addCollisionComponent(entityId, onCollisionCallback, affectsCollidingTransform); ((SceneManager *)sceneManager)->addCollisionComponent(entityId, onCollisionCallback, affectsCollidingTransform);
} }
EMSCRIPTEN_KEEPALIVE void remove_collision_component(void *const sceneManager, EntityId entityId) EMSCRIPTEN_KEEPALIVE void remove_collision_component(TSceneManager *sceneManager, EntityId entityId)
{ {
((SceneManager *)sceneManager)->removeCollisionComponent(entityId); ((SceneManager *)sceneManager)->removeCollisionComponent(entityId);
} }
EMSCRIPTEN_KEEPALIVE bool add_animation_component(void *const sceneManager, EntityId entityId) EMSCRIPTEN_KEEPALIVE bool add_animation_component(TSceneManager *sceneManager, EntityId entityId)
{ {
return ((SceneManager *)sceneManager)->addAnimationComponent(entityId); return ((SceneManager *)sceneManager)->addAnimationComponent(entityId);
} }
EMSCRIPTEN_KEEPALIVE void remove_animation_component(void *const sceneManager, EntityId entityId) EMSCRIPTEN_KEEPALIVE void remove_animation_component(TSceneManager *sceneManager, EntityId entityId)
{ {
((SceneManager *)sceneManager)->removeAnimationComponent(entityId); ((SceneManager *)sceneManager)->removeAnimationComponent(entityId);
} }
EMSCRIPTEN_KEEPALIVE EntityId create_geometry( EMSCRIPTEN_KEEPALIVE EntityId create_geometry(
void *const sceneManager, TSceneManager *sceneManager,
float *vertices, float *vertices,
int numVertices, int numVertices,
float *normals, float *normals,
@@ -878,38 +880,38 @@ extern "C"
return ((SceneManager *)sceneManager)->createGeometry(vertices, (uint32_t)numVertices, normals, (uint32_t)numNormals, uvs, numUvs, indices, numIndices, (filament::RenderableManager::PrimitiveType)primitiveType, reinterpret_cast<MaterialInstance *>(materialInstance), keepData); return ((SceneManager *)sceneManager)->createGeometry(vertices, (uint32_t)numVertices, normals, (uint32_t)numNormals, uvs, numUvs, indices, numIndices, (filament::RenderableManager::PrimitiveType)primitiveType, reinterpret_cast<MaterialInstance *>(materialInstance), keepData);
} }
EMSCRIPTEN_KEEPALIVE EntityId find_child_entity_by_name(void *const sceneManager, const EntityId parent, const char *name) EMSCRIPTEN_KEEPALIVE EntityId find_child_entity_by_name(TSceneManager *sceneManager, const EntityId parent, const char *name)
{ {
auto entity = ((SceneManager *)sceneManager)->findChildEntityByName(parent, name); auto entity = ((SceneManager *)sceneManager)->findChildEntityByName(parent, name);
return utils::Entity::smuggle(entity); return utils::Entity::smuggle(entity);
} }
EMSCRIPTEN_KEEPALIVE EntityId get_parent(void *const sceneManager, EntityId child) EMSCRIPTEN_KEEPALIVE EntityId get_parent(TSceneManager *sceneManager, EntityId child)
{ {
return ((SceneManager *)sceneManager)->getParent(child); return ((SceneManager *)sceneManager)->getParent(child);
} }
EMSCRIPTEN_KEEPALIVE EntityId get_ancestor(void *const sceneManager, EntityId child) EMSCRIPTEN_KEEPALIVE EntityId get_ancestor(TSceneManager *sceneManager, EntityId child)
{ {
return ((SceneManager *)sceneManager)->getAncestor(child); return ((SceneManager *)sceneManager)->getAncestor(child);
} }
EMSCRIPTEN_KEEPALIVE void set_parent(void *const sceneManager, EntityId child, EntityId parent, bool preserveScaling) EMSCRIPTEN_KEEPALIVE void set_parent(TSceneManager *sceneManager, EntityId child, EntityId parent, bool preserveScaling)
{ {
((SceneManager *)sceneManager)->setParent(child, parent, preserveScaling); ((SceneManager *)sceneManager)->setParent(child, parent, preserveScaling);
} }
EMSCRIPTEN_KEEPALIVE void test_collisions(void *const sceneManager, EntityId entity) EMSCRIPTEN_KEEPALIVE void test_collisions(TSceneManager *sceneManager, EntityId entity)
{ {
((SceneManager *)sceneManager)->testCollisions(entity); ((SceneManager *)sceneManager)->testCollisions(entity);
} }
EMSCRIPTEN_KEEPALIVE void set_priority(void *const sceneManager, EntityId entity, int priority) EMSCRIPTEN_KEEPALIVE void set_priority(TSceneManager *sceneManager, EntityId entity, int priority)
{ {
((SceneManager *)sceneManager)->setPriority(entity, priority); ((SceneManager *)sceneManager)->setPriority(entity, priority);
} }
EMSCRIPTEN_KEEPALIVE void get_gizmo(void *const sceneManager, EntityId *out) EMSCRIPTEN_KEEPALIVE void get_gizmo(TSceneManager *sceneManager, EntityId *out)
{ {
auto gizmo = ((SceneManager *)sceneManager)->gizmo; auto gizmo = ((SceneManager *)sceneManager)->gizmo;
out[0] = Entity::smuggle(gizmo->x()); out[0] = Entity::smuggle(gizmo->x());
@@ -918,12 +920,12 @@ extern "C"
out[3] = Entity::smuggle(gizmo->center()); out[3] = Entity::smuggle(gizmo->center());
} }
EMSCRIPTEN_KEEPALIVE Aabb2 get_bounding_box(void *const sceneManager, EntityId entity) EMSCRIPTEN_KEEPALIVE Aabb2 get_bounding_box(TSceneManager *sceneManager, EntityId entity)
{ {
return ((SceneManager *)sceneManager)->getBoundingBox(entity); return ((SceneManager *)sceneManager)->getBoundingBox(entity);
} }
EMSCRIPTEN_KEEPALIVE void get_bounding_box_to_out(void *const sceneManager, EntityId entity, float *minX, float *minY, float *maxX, float *maxY) EMSCRIPTEN_KEEPALIVE void get_bounding_box_to_out(TSceneManager *sceneManager, EntityId entity, float *minX, float *minY, float *maxX, float *maxY)
{ {
auto box = ((SceneManager *)sceneManager)->getBoundingBox(entity); auto box = ((SceneManager *)sceneManager)->getBoundingBox(entity);
*minX = box.minX; *minX = box.minX;
@@ -932,12 +934,12 @@ extern "C"
*maxY = box.maxY; *maxY = box.maxY;
} }
EMSCRIPTEN_KEEPALIVE void set_visibility_layer(void *const sceneManager, EntityId entity, int layer) { EMSCRIPTEN_KEEPALIVE void set_visibility_layer(TSceneManager *sceneManager, EntityId entity, int layer) {
((SceneManager*)sceneManager)->setVisibilityLayer(entity, layer); ((SceneManager*)sceneManager)->setVisibilityLayer(entity, layer);
} }
EMSCRIPTEN_KEEPALIVE void set_layer_visibility(void *const sceneManager, int layer, bool visible) EMSCRIPTEN_KEEPALIVE void set_layer_visibility(TSceneManager *sceneManager, int layer, bool visible)
{ {
((SceneManager *)sceneManager)->setLayerVisibility((SceneManager::LAYERS)layer, visible); ((SceneManager *)sceneManager)->setLayerVisibility((SceneManager::LAYERS)layer, visible);
} }
@@ -947,42 +949,42 @@ extern "C"
free(ptr); free(ptr);
} }
EMSCRIPTEN_KEEPALIVE void pick_gizmo(void *const sceneManager, int x, int y, void (*callback)(EntityId entityId, int x, int y)) EMSCRIPTEN_KEEPALIVE void pick_gizmo(TSceneManager *sceneManager, int x, int y, void (*callback)(EntityId entityId, int x, int y))
{ {
((SceneManager *)sceneManager)->gizmo->pick(x, y, callback); ((SceneManager *)sceneManager)->gizmo->pick(x, y, callback);
} }
EMSCRIPTEN_KEEPALIVE void set_gizmo_visibility(void *const sceneManager, bool visible) EMSCRIPTEN_KEEPALIVE void set_gizmo_visibility(TSceneManager *sceneManager, bool visible)
{ {
((SceneManager *)sceneManager)->gizmo->setVisibility(visible); ((SceneManager *)sceneManager)->gizmo->setVisibility(visible);
} }
EMSCRIPTEN_KEEPALIVE void set_stencil_highlight(void *const sceneManager, EntityId entityId, float r, float g, float b) EMSCRIPTEN_KEEPALIVE void set_stencil_highlight(TSceneManager *sceneManager, EntityId entityId, float r, float g, float b)
{ {
((SceneManager *)sceneManager)->setStencilHighlight(entityId, r, g, b); ((SceneManager *)sceneManager)->setStencilHighlight(entityId, r, g, b);
} }
EMSCRIPTEN_KEEPALIVE void remove_stencil_highlight(void *const sceneManager, EntityId entityId) EMSCRIPTEN_KEEPALIVE void remove_stencil_highlight(TSceneManager *sceneManager, EntityId entityId)
{ {
((SceneManager *)sceneManager)->removeStencilHighlight(entityId); ((SceneManager *)sceneManager)->removeStencilHighlight(entityId);
} }
EMSCRIPTEN_KEEPALIVE void set_material_property_float(void *const sceneManager, EntityId entity, int materialIndex, const char *property, float value) EMSCRIPTEN_KEEPALIVE void set_material_property_float(TSceneManager *sceneManager, EntityId entity, int materialIndex, const char *property, float value)
{ {
((SceneManager *)sceneManager)->setMaterialProperty(entity, materialIndex, property, value); ((SceneManager *)sceneManager)->setMaterialProperty(entity, materialIndex, property, value);
} }
EMSCRIPTEN_KEEPALIVE TMaterialInstance* get_material_instance_at(void *const sceneManager, EntityId entity, int materialIndex) { EMSCRIPTEN_KEEPALIVE TMaterialInstance* get_material_instance_at(TSceneManager *sceneManager, EntityId entity, int materialIndex) {
auto instance = ((SceneManager *)sceneManager)->getMaterialInstanceAt(entity, materialIndex); auto instance = ((SceneManager *)sceneManager)->getMaterialInstanceAt(entity, materialIndex);
return reinterpret_cast<TMaterialInstance*>(instance); return reinterpret_cast<TMaterialInstance*>(instance);
} }
EMSCRIPTEN_KEEPALIVE void set_material_property_int(void *const sceneManager, EntityId entity, int materialIndex, const char *property, int32_t value) EMSCRIPTEN_KEEPALIVE void set_material_property_int(TSceneManager *sceneManager, EntityId entity, int materialIndex, const char *property, int32_t value)
{ {
((SceneManager *)sceneManager)->setMaterialProperty(entity, materialIndex, property, value); ((SceneManager *)sceneManager)->setMaterialProperty(entity, materialIndex, property, value);
} }
EMSCRIPTEN_KEEPALIVE void set_material_property_float4(void *const sceneManager, EntityId entity, int materialIndex, const char *property, double4 value) EMSCRIPTEN_KEEPALIVE void set_material_property_float4(TSceneManager *sceneManager, EntityId entity, int materialIndex, const char *property, double4 value)
{ {
filament::math::float4 filamentValue; filament::math::float4 filamentValue;
filamentValue.x = static_cast<float32_t>(value.x); filamentValue.x = static_cast<float32_t>(value.x);
@@ -997,23 +999,23 @@ extern "C"
((FilamentViewer *)viewer)->unprojectTexture(entity, input, inputWidth, inputHeight, out, outWidth, outHeight); ((FilamentViewer *)viewer)->unprojectTexture(entity, input, inputWidth, inputHeight, out, outWidth, outHeight);
} }
EMSCRIPTEN_KEEPALIVE void *const create_texture(void *const sceneManager, uint8_t *data, size_t length) EMSCRIPTEN_KEEPALIVE void *const create_texture(TSceneManager *sceneManager, uint8_t *data, size_t length)
{ {
return (void *const)((SceneManager *)sceneManager)->createTexture(data, length, "SOMETEXTURE"); return (void *const)((SceneManager *)sceneManager)->createTexture(data, length, "SOMETEXTURE");
} }
EMSCRIPTEN_KEEPALIVE void apply_texture_to_material(void *const sceneManager, EntityId entity, void *const texture, const char *parameterName, int materialIndex) EMSCRIPTEN_KEEPALIVE void apply_texture_to_material(TSceneManager *sceneManager, EntityId entity, void *const texture, const char *parameterName, int materialIndex)
{ {
((SceneManager *)sceneManager)->applyTexture(entity, reinterpret_cast<Texture *>(texture), parameterName, materialIndex); ((SceneManager *)sceneManager)->applyTexture(entity, reinterpret_cast<Texture *>(texture), parameterName, materialIndex);
} }
EMSCRIPTEN_KEEPALIVE void destroy_texture(void *const sceneManager, void *const texture) EMSCRIPTEN_KEEPALIVE void destroy_texture(TSceneManager *sceneManager, void *const texture)
{ {
((SceneManager *)sceneManager)->destroyTexture(reinterpret_cast<Texture *>(texture)); ((SceneManager *)sceneManager)->destroyTexture(reinterpret_cast<Texture *>(texture));
} }
EMSCRIPTEN_KEEPALIVE TMaterialInstance* create_material_instance(void *const sceneManager, TMaterialKey materialConfig) EMSCRIPTEN_KEEPALIVE TMaterialInstance* create_material_instance(TSceneManager *sceneManager, TMaterialKey materialConfig)
{ {
filament::gltfio::MaterialKey config; filament::gltfio::MaterialKey config;
@@ -1047,12 +1049,12 @@ extern "C"
return reinterpret_cast<TMaterialInstance*>(materialInstance); return reinterpret_cast<TMaterialInstance*>(materialInstance);
} }
EMSCRIPTEN_KEEPALIVE TMaterialInstance *create_unlit_material_instance(void *const sceneManager) { EMSCRIPTEN_KEEPALIVE TMaterialInstance *create_unlit_material_instance(TSceneManager *sceneManager) {
auto * instance = ((SceneManager*)sceneManager)->createUnlitMaterialInstance(); auto * instance = ((SceneManager*)sceneManager)->createUnlitMaterialInstance();
return reinterpret_cast<TMaterialInstance*>(instance); return reinterpret_cast<TMaterialInstance*>(instance);
} }
EMSCRIPTEN_KEEPALIVE void destroy_material_instance(void *const sceneManager, TMaterialInstance *instance) { EMSCRIPTEN_KEEPALIVE void destroy_material_instance(TSceneManager *sceneManager, TMaterialInstance *instance) {
((SceneManager *)sceneManager)->destroy(reinterpret_cast<MaterialInstance*>(instance)); ((SceneManager *)sceneManager)->destroy(reinterpret_cast<MaterialInstance*>(instance));
} }
@@ -1073,9 +1075,42 @@ EMSCRIPTEN_KEEPALIVE double4x4 Camera_getModelMatrix(TCamera* tCamera) {
return convert_mat4_to_double4x4(camera->getModelMatrix()); return convert_mat4_to_double4x4(camera->getModelMatrix());
} }
EMSCRIPTEN_KEEPALIVE EntityId Camera_getEntity(TCamera* tCamera) {
auto * camera = reinterpret_cast<Camera*>(tCamera);
return Entity::smuggle(camera->getEntity());
}
EMSCRIPTEN_KEEPALIVE TCamera *Engine_getCameraComponent(TEngine* tEngine, EntityId entityId) { EMSCRIPTEN_KEEPALIVE TCamera *Engine_getCameraComponent(TEngine* tEngine, EntityId entityId) {
auto * engine = reinterpret_cast<Engine*>(tEngine); auto * engine = reinterpret_cast<Engine*>(tEngine);
auto * camera = engine->getCameraComponent(utils::Entity::import(entityId)); auto * camera = engine->getCameraComponent(utils::Entity::import(entityId));
return reinterpret_cast<TCamera*>(camera); return reinterpret_cast<TCamera*>(camera);
} }
EMSCRIPTEN_KEEPALIVE void Engine_setTransform(TEngine* tEngine, EntityId entity, double4x4 transform) {
auto * engine = reinterpret_cast<Engine*>(tEngine);
auto& transformManager = engine->getTransformManager();
auto transformInstance = transformManager.getInstance(utils::Entity::import(entity));
if(!transformInstance.isValid()) {
Log("Transform instance not valid");
}
transformManager.setTransform(transformInstance, convert_double4x4_to_mat4(transform));
}
EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_createCamera(TSceneManager* tSceneManager) {
auto * sceneManager = reinterpret_cast<SceneManager*>(tSceneManager);
return reinterpret_cast<TCamera*>(sceneManager->createCamera());
}
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyCamera(TSceneManager* tSceneManager, TCamera* tCamera) {
auto * sceneManager = reinterpret_cast<SceneManager*>(tSceneManager);
auto * camera = reinterpret_cast<Camera*>(tCamera);
sceneManager->destroyCamera(camera);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_setCamera(TSceneManager* tSceneManager, TCamera* tCamera) {
auto * sceneManager = reinterpret_cast<SceneManager*>(tSceneManager);
auto * camera = reinterpret_cast<Camera*>(tCamera);
sceneManager->setCamera(camera);
}
} }

30
thermion_dart/native/src/ThermionDartRenderThreadApi.cpp
View File

@@ -362,7 +362,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void load_gltf_render_thread(void *const sceneManager, EMSCRIPTEN_KEEPALIVE void load_gltf_render_thread(TSceneManager *sceneManager,
const char *path, const char *path,
const char *relativeResourcePath, const char *relativeResourcePath,
bool keepData, bool keepData,
@@ -382,7 +382,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void load_glb_render_thread(void *const sceneManager, EMSCRIPTEN_KEEPALIVE void load_glb_render_thread(TSceneManager *sceneManager,
const char *path, const char *path,
int numInstances, int numInstances,
bool keepData, bool keepData,
@@ -402,7 +402,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void load_glb_from_buffer_render_thread(void *const sceneManager, EMSCRIPTEN_KEEPALIVE void load_glb_from_buffer_render_thread(TSceneManager *sceneManager,
const uint8_t *const data, const uint8_t *const data,
size_t length, size_t length,
int numInstances, int numInstances,
@@ -619,7 +619,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE void EMSCRIPTEN_KEEPALIVE void
get_morph_target_name_render_thread(void *sceneManager, EntityId assetEntity, get_morph_target_name_render_thread(TSceneManager *sceneManager, EntityId assetEntity,
EntityId childEntity, char *const outPtr, int index, void (*callback)()) EntityId childEntity, char *const outPtr, int index, void (*callback)())
{ {
std::packaged_task<void()> lambda([=] std::packaged_task<void()> lambda([=]
@@ -635,7 +635,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE void EMSCRIPTEN_KEEPALIVE void
get_morph_target_name_count_render_thread(void *sceneManager, EntityId assetEntity, get_morph_target_name_count_render_thread(TSceneManager *sceneManager, EntityId assetEntity,
EntityId childEntity, void (*callback)(int)) EntityId childEntity, void (*callback)(int))
{ {
std::packaged_task<int()> lambda([=] std::packaged_task<int()> lambda([=]
@@ -652,7 +652,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void set_animation_frame_render_thread(void *const sceneManager, EMSCRIPTEN_KEEPALIVE void set_animation_frame_render_thread(TSceneManager *sceneManager,
EntityId asset, EntityId asset,
int animationIndex, int animationIndex,
int animationFrame) int animationFrame)
@@ -662,7 +662,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void stop_animation_render_thread(void *const sceneManager, EMSCRIPTEN_KEEPALIVE void stop_animation_render_thread(TSceneManager *sceneManager,
EntityId asset, int index) EntityId asset, int index)
{ {
std::packaged_task<void()> lambda( std::packaged_task<void()> lambda(
@@ -671,7 +671,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void get_animation_count_render_thread(void *const sceneManager, EMSCRIPTEN_KEEPALIVE void get_animation_count_render_thread(TSceneManager *sceneManager,
EntityId asset, EntityId asset,
void (*callback)(int)) void (*callback)(int))
{ {
@@ -689,7 +689,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void get_animation_name_render_thread(void *const sceneManager, EMSCRIPTEN_KEEPALIVE void get_animation_name_render_thread(TSceneManager *sceneManager,
EntityId asset, EntityId asset,
char *const outPtr, char *const outPtr,
int index, int index,
@@ -718,7 +718,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE void EMSCRIPTEN_KEEPALIVE void
get_name_for_entity_render_thread(void *const sceneManager, const EntityId entityId, void (*callback)(const char *)) get_name_for_entity_render_thread(TSceneManager *sceneManager, const EntityId entityId, void (*callback)(const char *))
{ {
std::packaged_task<const char *()> lambda( std::packaged_task<const char *()> lambda(
[=] [=]
@@ -734,7 +734,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
void set_morph_target_weights_render_thread(void *const sceneManager, void set_morph_target_weights_render_thread(TSceneManager *sceneManager,
EntityId asset, EntityId asset,
const float *const morphData, const float *const morphData,
int numWeights, int numWeights,
@@ -754,7 +754,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE void set_bone_transform_render_thread( EMSCRIPTEN_KEEPALIVE void set_bone_transform_render_thread(
void *sceneManager, TSceneManager *sceneManager,
EntityId asset, EntityId asset,
int skinIndex, int skinIndex,
int boneIndex, int boneIndex,
@@ -775,7 +775,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void update_bone_matrices_render_thread(void *sceneManager, EMSCRIPTEN_KEEPALIVE void update_bone_matrices_render_thread(TSceneManager *sceneManager,
EntityId entity, void (*callback)(bool)) EntityId entity, void (*callback)(bool))
{ {
std::packaged_task<void()> lambda( std::packaged_task<void()> lambda(
@@ -791,7 +791,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void reset_to_rest_pose_render_thread(void *const sceneManager, EntityId entityId, void (*callback)()) EMSCRIPTEN_KEEPALIVE void reset_to_rest_pose_render_thread(TSceneManager *sceneManager, EntityId entityId, void (*callback)())
{ {
std::packaged_task<void()> lambda( std::packaged_task<void()> lambda(
[=] [=]
@@ -807,7 +807,7 @@ extern "C"
} }
EMSCRIPTEN_KEEPALIVE void create_geometry_render_thread( EMSCRIPTEN_KEEPALIVE void create_geometry_render_thread(
void *const sceneManager, TSceneManager *sceneManager,
float *vertices, float *vertices,
int numVertices, int numVertices,
float *normals, float *normals,

17
thermion_dart/test/integration_test.dart
View File

@@ -139,6 +139,23 @@ void main() async {
expect(modelMatrix.getColumn(3).z, 0.0); expect(modelMatrix.getColumn(3).z, 0.0);
expect(modelMatrix.getColumn(3).w, 1.0); expect(modelMatrix.getColumn(3).w, 1.0);
}); });
test('create camera', () async {
var viewer = await createViewer();
await viewer.setCameraPosition(0, 0, 5);
await viewer.setBackgroundColor(1.0, 0.0, 1.0, 1.0);
await viewer.createGeometry(GeometryHelper.cube());
await _capture(viewer, "create_camera_main_camera");
var newCamera = await viewer.createCamera();
await newCamera.setTransform(Matrix4.translation(Vector3(0, 0, 4)));
newCamera.setLensProjection();
await viewer.setActiveCamera(newCamera);
await _capture(viewer, "create_camera_new_camera");
final mainCamera = await viewer.getMainCamera();
await viewer.setActiveCamera(mainCamera);
await _capture(viewer, "create_camera_back_to_main");
});
}); });
group('background', () { group('background', () {