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

refactoring

Browse Source
This commit is contained in:
Nick Fisher
2025-03-19 16:02:43 +08:00
parent e73cb9c7d6
commit ac86dc7ad7
20 changed files with 290 additions and 601 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
thermion_dart/native/include/RenderTicker.hpp
View File

@@ -36,13 +36,24 @@ namespace thermion
RenderTicker(filament::Renderer *renderer) : mRenderer(renderer) { }
~RenderTicker();
/// @brief
/// @param frameTimeInNanos
void render(
uint64_t frameTimeInNanos
);
/// @brief
/// @param swapChain
/// @param view
/// @param numViews
void setRenderable(filament::SwapChain *swapChain, filament::View **view, uint8_t numViews);
/// @brief
/// @param animationManager
void addAnimationManager(AnimationManager* animationManager);
/// @brief
/// @param animationManager
void removeAnimationManager(AnimationManager* animationManager);

2
thermion_dart/native/include/c_api/TAnimationManager.h
View File

@@ -8,7 +8,7 @@ extern "C"
{
#endif
EMSCRIPTEN_KEEPALIVE TAnimationManager *AnimationManager_create(TEngine *tEngine);
EMSCRIPTEN_KEEPALIVE TAnimationManager *AnimationManager_create(TEngine *tEngine, TScene *tScene);
EMSCRIPTEN_KEEPALIVE void AnimationManager_addAnimationComponent(TAnimationManager *tAnimationManager, EntityId entityId);

2
thermion_dart/native/include/c_api/TEngine.h
View File

@@ -27,7 +27,7 @@ EMSCRIPTEN_KEEPALIVE TEngine *Engine_create(
bool disableHandleUseAfterFreeCheck
);
EMSCRIPTEN_KEEPALIVE TEngine *Engine_destroy(TEngine *tEngine);
EMSCRIPTEN_KEEPALIVE void Engine_destroy(TEngine *tEngine);
EMSCRIPTEN_KEEPALIVE TRenderer *Engine_createRenderer(TEngine *tEngine);
EMSCRIPTEN_KEEPALIVE TSwapChain *Engine_createSwapChain(TEngine *tEngine, void *window, uint64_t flags);
EMSCRIPTEN_KEEPALIVE TSwapChain *Engine_createHeadlessSwapChain(TEngine *tEngine, uint32_t width, uint32_t height, uint64_t flags);

2
thermion_dart/native/include/c_api/TLightManager.h
View File

@@ -19,7 +19,7 @@ extern "C"
EMSCRIPTEN_KEEPALIVE void LightManager_setPosition(TLightManager *tLightManager, EntityId light, double x, double y, double z);
EMSCRIPTEN_KEEPALIVE void LightManager_setDirection(TLightManager *tLightManager, EntityId light, double x, double y, double z);
EMSCRIPTEN_KEEPALIVE int LightManager_createLight(TLightManager *tLightManager, TLightType tLightTtype);
EMSCRIPTEN_KEEPALIVE int LightManager_createLight(TEngine *tEngine, TLightManager *tLightManager, TLightType tLightTtype);
EMSCRIPTEN_KEEPALIVE void LightManager_destroyLight(TLightManager *tLightManager, EntityId entity);
EMSCRIPTEN_KEEPALIVE void LightManager_setColor(TLightManager *tLightManager, EntityId entity, float colorTemperature);
EMSCRIPTEN_KEEPALIVE void LightManager_setIntensity(TLightManager *tLightManager, EntityId entity, double intensity);

4
thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
View File

@@ -17,7 +17,7 @@ namespace thermion
EMSCRIPTEN_KEEPALIVE void RenderLoop_create();
EMSCRIPTEN_KEEPALIVE void RenderLoop_destroy();
EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete));
EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos);
EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, void (*onComplete)());
// EMSCRIPTEN_KEEPALIVE void RenderLoop_addTask(TRenderLoop* tRenderLoop, void (*task)());
EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *));
@@ -75,7 +75,7 @@ namespace thermion
EMSCRIPTEN_KEEPALIVE void Material_createInstanceRenderThread(TMaterial *tMaterial, void (*onComplete)(TMaterialInstance *));
EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, ToneMapping toneMapping);
EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, TToneMapping toneMapping);
EMSCRIPTEN_KEEPALIVE void View_setBloomRenderThread(TView *tView, bool enabled, double strength);
EMSCRIPTEN_KEEPALIVE void View_setCameraRenderThread(TView *tView, TCamera *tCamera, void (*callback)());

12
thermion_dart/native/include/scene/GeometrySceneAsset.hpp
View File

@@ -72,18 +72,6 @@ namespace thermion
scene->remove(_entity);
}
void setPriority(RenderableManager &rm, int priority) override
{
auto renderableInstance = rm.getInstance(_entity);
rm.setPriority(renderableInstance, priority);
}
void setLayer(RenderableManager &rm, int layer) override
{
auto renderableInstance = rm.getInstance(_entity);
rm.setLayerMask(renderableInstance, 0xFF, 1u << (uint8_t)layer);
}
SceneAsset *getInstanceByEntity(utils::Entity entity) override
{
for (auto &instance : _instances)

9
thermion_dart/native/include/scene/Gizmo.hpp
View File

@@ -19,7 +19,6 @@
#include <filament/IndexBuffer.h>
#include <filament/InstanceBuffer.h>
#include "c_api/ThermionDartApi.h"
#include "scene/SceneAsset.hpp"
namespace thermion
@@ -106,14 +105,6 @@ namespace thermion
return utils::Entity::import(0);
}
void setPriority(RenderableManager &rm, int mask) override
{
}
void setLayer(RenderableManager &rm, int layer) override
{
}
void highlight(Gizmo::Axis axis);
void unhighlight(Gizmo::Axis axis);

26
thermion_dart/native/include/scene/GltfSceneAssetInstance.hpp
View File

@@ -133,32 +133,6 @@ namespace thermion
return std::nullptr_t();
}
void setPriority(RenderableManager &rm, int priority) override
{
const Entity *entities = _instance->getEntities();
for (int i = 0; i < _instance->getEntityCount(); i++)
{
if (rm.hasComponent(entities[i]))
{
auto renderableInstance = rm.getInstance(entities[i]);
rm.setPriority(renderableInstance, priority);
}
}
}
void setLayer(RenderableManager &rm, int layer) override
{
const Entity *entities = _instance->getEntities();
for (int i = 0; i < _instance->getEntityCount(); i++)
{
if (rm.hasComponent(entities[i]))
{
auto renderableInstance = rm.getInstance(entities[i]);
rm.setLayerMask(renderableInstance, 0xFF, 1u << (uint8_t)layer);
}
}
}
const filament::Aabb getBoundingBox() const override {
return _instance->getBoundingBox();
}

4
thermion_dart/native/src/RenderTicker.cpp
View File

@@ -49,21 +49,17 @@ namespace thermion
void RenderTicker::setRenderable(SwapChain *swapChain, View **views, uint8_t numViews) {
std::lock_guard lock(mMutex);
// Find if this swapChain already exists in our collection
auto it = std::find_if(mRenderable.begin(), mRenderable.end(),
[swapChain](const auto& pair) { return pair.first == swapChain; });
// Prepare the vector of views
std::vector<View*> swapChainViews;
for(int i = 0; i < numViews; i++) {
swapChainViews.push_back(views[i]);
}
if (it != mRenderable.end()) {
// Update existing entry
it->second = swapChainViews;
} else {
// Add new entry
mRenderable.emplace_back(swapChain, swapChainViews);
}
}

1
thermion_dart/native/src/c_api/TEngine.cpp
View File

@@ -30,6 +30,7 @@
#include <utils/NameComponentManager.h>
#include "Log.hpp"
#include "MathUtils.hpp"
#ifdef __cplusplus
namespace thermion

4
thermion_dart/native/src/c_api/TGltfAssetLoader.cpp
View File

@@ -112,8 +112,8 @@ EMSCRIPTEN_KEEPALIVE TMaterialInstance *GltfAssetLoader_getMaterialInstance(TRen
}
EMSCRIPTEN_KEEPALIVE TMaterialProvider *GltfAssetLoader_getMaterialProvider(TGltfAssetLoader *tAssetLoader) {
auto *assetLoader = reinterpret_cast<gltfio::AssetLoader>(tAssetLoader);
auto materialProvider = assetLoader->getMaterialProvider();
auto *assetLoader = reinterpret_cast<gltfio::AssetLoader *>(tAssetLoader);
auto &materialProvider = assetLoader->getMaterialProvider();
return reinterpret_cast<TMaterialProvider *>(&materialProvider);
}

2
thermion_dart/native/src/c_api/TLightManager.cpp
View File

@@ -48,7 +48,7 @@ EMSCRIPTEN_KEEPALIVE int LightManager_createLight(TEngine *tEngine, TLightManage
filament::LightManager::Builder builder(lightType);
auto entity = utils::EntityManager::create();
auto result = builder.build(*engine, utils::Entity::import(entity));
if(result != filament::LightManager::Result::Success) {
if(result != filament::LightManager::Builder::Result::Success) {
Log("Failed to create light");
}
return entity;

21
thermion_dart/native/src/c_api/TRenderTicker.cpp
View File

@@ -1,22 +1,23 @@
#ifdef _WIN32
#include "ThermionWin32.h"
#endif
#ifdef __EMSCRIPTEN__
#include <emscripten/emscripten.h>
#endif
#include <thread>
#include <functional>
#ifdef __EMSCRIPTEN__
#include <emscripten/emscripten.h>
#endif
#include <filament/LightManager.h>
#include "filament/LightManager.h"
#include "Log.hpp"
#include "RenderTicker.hpp"
using namespace thermion;
extern "C"
{
#include "c_api/TRenderTicker.hpp"
#include "c_api/TRenderTicker.h"
EMSCRIPTEN_KEEPALIVE TRenderTicker *RenderTicker_create(TRenderer *tRenderer) {
auto *renderer = reinterpret_cast<filament::Renderer *>(tRenderer);
@@ -24,7 +25,7 @@ EMSCRIPTEN_KEEPALIVE TRenderTicker *RenderTicker_create(TRenderer *tRenderer) {
return reinterpret_cast<TRenderTicker *>(renderTicker);
}
EMSCRIPTEN_KEEPALIVE void RenderTicker_destroy(TRenderTicker *tRenderTicker,) {
EMSCRIPTEN_KEEPALIVE void RenderTicker_destroy(TRenderTicker *tRenderTicker) {
auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
delete renderTicker;
}
@@ -42,12 +43,14 @@ EMSCRIPTEN_KEEPALIVE void RenderTicker_removeAnimationManager(TRenderTicker *tRe
}
EMSCRIPTEN_KEEPALIVE void RenderTicker_render(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos) {
auto *renderTicker = reinterpret_cast<RenderTicker *>
auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
renderTicker->render(frameTimeInNanos);
}
EMSCRIPTEN_KEEPALIVE void RenderTicker_setRenderable(TRenderTicker *tRenderTicker, TSwapChain *swapChain, TView **views, uint8_t numViews) {
auto *renderTicker = reinterpret_cast<RenderTicker *>
EMSCRIPTEN_KEEPALIVE void RenderTicker_setRenderable(TRenderTicker *tRenderTicker, TSwapChain *tSwapChain, TView **tViews, uint8_t numViews) {
auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
auto *swapChain = reinterpret_cast<filament::SwapChain *>(tSwapChain);
auto *views = reinterpret_cast<View **>(tViews);
renderTicker->setRenderable(swapChain, views, numViews);
}

10
thermion_dart/native/src/c_api/TRenderableManager.cpp
View File

@@ -119,16 +119,16 @@ namespace thermion
const auto &entity = utils::Entity::import(entityId);
auto renderableInstance = renderableManager->getInstance(entity);
if (!renderableInstance.isValid()) {
return false;
return Aabb3 { };
}
auto box = rm.getAxisAlignedBoundingBox(instance);
auto box = renderableManager.getAxisAlignedBoundingBox(renderableInstance);
return Aabb3{box.center.x, box.center.y, box.center.z, box.halfExtent.x, box.halfExtent.y, box.halfExtent.z};
}
EMSCRIPTEN_KEEPALIVE void RenderableManager_setVisibilityLayer(TRenderableManager *tRenderableManager, EntityId entityId, uint8_t layer) {
auto *renderableManager = reinterpret_cast<filament::RenderableManager *>(tRenderableManager);
const auto &entity = utils::Entity::import(entityId);
if (!renderableManager.hasComponent(entity)) {
if (!renderableManager->hasComponent(entity)) {
Log("Not renderable");
return;
}
@@ -140,12 +140,12 @@ namespace thermion
auto *renderableManager = reinterpret_cast<filament::RenderableManager *>(tRenderableManager);
const auto &entity = utils::Entity::import(entityId);
if (!renderableManager.hasComponent(entity)) {
if (!renderableManager->hasComponent(entity)) {
Log("Not renderable");
return;
}
auto renderableInstance = renderableManager->getInstance(entity);
renderableManager->setPriority(renderableInstance, layer);
renderableManager->setPriority(renderableInstance, priority);
}
}

2
thermion_dart/native/src/c_api/TRenderer.cpp
View File

@@ -26,7 +26,7 @@ namespace thermion
#endif
#include "c_api/ThermionDartApi.h"
#include "c_api/TRenderer.h"
EMSCRIPTEN_KEEPALIVE void Renderer_setClearOptions(TRenderer *tRenderer, double clearR, double clearG, double clearB, double clearA, uint8_t clearStencil, bool clear, bool discard) {
auto *renderer = reinterpret_cast<filament::Renderer *>(tRenderer);

2
thermion_dart/native/src/c_api/TScene.cpp
View File

@@ -32,7 +32,7 @@ namespace thermion
EMSCRIPTEN_KEEPALIVE void Scene_removeEntity(TScene* tScene, EntityId entityId) {
auto *scene = reinterpret_cast<Scene *>(tScene);
scene->removeEntity(utils::Entity::import(entityId));
scene->remove(utils::Entity::import(entityId));
}
EMSCRIPTEN_KEEPALIVE void Scene_setSkybox(TScene* tScene, TSkybox *tSkybox) {

458
thermion_dart/native/src/c_api/TSceneManager.cpp
View File

@@ -1,265 +1,265 @@
#include <filament/LightManager.h>
// #include <filament/LightManager.h>
#include "c_api/APIExport.h"
#include "ResourceBuffer.hpp"
#include "FilamentViewer.hpp"
#include "Log.hpp"
// #include "c_api/APIExport.h"
// #include "ResourceBuffer.hpp"
// #include "FilamentViewer.hpp"
// #include "Log.hpp"
using namespace thermion;
// using namespace thermion;
extern "C"
{
// extern "C"
// {
#include "c_api/TSceneManager.h"
// #include "c_api/TSceneManager.h"
EMSCRIPTEN_KEEPALIVE TScene *SceneManager_getScene(TSceneManager *tSceneManager)
{
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return reinterpret_cast<TScene *>(sceneManager->getScene());
}
// EMSCRIPTEN_KEEPALIVE TScene *SceneManager_getScene(TSceneManager *tSceneManager)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return reinterpret_cast<TScene *>(sceneManager->getScene());
// }
EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUnlitMaterialProvider(TSceneManager *tSceneManager)
{
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto provider = sceneManager->getUnlitMaterialProvider();
return reinterpret_cast<TMaterialProvider *>(provider);
}
// EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUnlitMaterialProvider(TSceneManager *tSceneManager)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto provider = sceneManager->getUnlitMaterialProvider();
// return reinterpret_cast<TMaterialProvider *>(provider);
// }
EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUbershaderMaterialProvider(TSceneManager *tSceneManager)
{
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto provider = sceneManager->getUbershaderMaterialProvider();
return reinterpret_cast<TMaterialProvider *>(provider);
}
// EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUbershaderMaterialProvider(TSceneManager *tSceneManager)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto provider = sceneManager->getUbershaderMaterialProvider();
// return reinterpret_cast<TMaterialProvider *>(provider);
// }
EMSCRIPTEN_KEEPALIVE TGizmo *SceneManager_createGizmo(TSceneManager *tSceneManager, TView *tView, TScene *tScene, TGizmoType tGizmoType)
{
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *scene = reinterpret_cast<Scene *>(tScene);
auto *view = reinterpret_cast<View *>(tView);
auto gizmo = sceneManager->createGizmo(view, scene, static_cast<SceneManager::GizmoType>(tGizmoType));
return reinterpret_cast<TGizmo *>(gizmo);
}
// EMSCRIPTEN_KEEPALIVE TGizmo *SceneManager_createGizmo(TSceneManager *tSceneManager, TView *tView, TScene *tScene, TGizmoType tGizmoType)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *scene = reinterpret_cast<Scene *>(tScene);
// auto *view = reinterpret_cast<View *>(tView);
// auto gizmo = sceneManager->createGizmo(view, scene, static_cast<SceneManager::GizmoType>(tGizmoType));
// return reinterpret_cast<TGizmo *>(gizmo);
// }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlb(TSceneManager *tSceneManager, const char *assetPath, int numInstances, bool keepData)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *asset = sceneManager->loadGlb(assetPath, numInstances, keepData);
return reinterpret_cast<TSceneAsset *>(asset);
}
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlb(TSceneManager *tSceneManager, const char *assetPath, int numInstances, bool keepData)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *asset = sceneManager->loadGlb(assetPath, numInstances, keepData);
// return reinterpret_cast<TSceneAsset *>(asset);
// }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGltf(TSceneManager *tSceneManager,
const char *assetPath,
const char *relativeResourcePath,
bool keepData)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *asset = sceneManager->loadGltf(assetPath, relativeResourcePath, 1, keepData);
return reinterpret_cast<TSceneAsset *>(asset);
}
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGltf(TSceneManager *tSceneManager,
// const char *assetPath,
// const char *relativeResourcePath,
// bool keepData)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *asset = sceneManager->loadGltf(assetPath, relativeResourcePath, 1, keepData);
// return reinterpret_cast<TSceneAsset *>(asset);
// }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlbFromBuffer(TSceneManager *tSceneManager, const uint8_t *const data, size_t length, int numInstances, bool keepData, int priority, int layer, bool loadResourcesAsync)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *asset = sceneManager->loadGlbFromBuffer((const uint8_t *)data, length, numInstances, keepData, priority, layer, loadResourcesAsync);
return reinterpret_cast<TSceneAsset *>(asset);
}
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlbFromBuffer(TSceneManager *tSceneManager, const uint8_t *const data, size_t length, int numInstances, bool keepData, int priority, int layer, bool loadResourcesAsync)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *asset = sceneManager->loadGlbFromBuffer((const uint8_t *)data, length, numInstances, keepData, priority, layer, loadResourcesAsync);
// return reinterpret_cast<TSceneAsset *>(asset);
// }
EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraByName(TSceneManager *tSceneManager, EntityId entityId, const char *name)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return nullptr;
}
// EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraByName(TSceneManager *tSceneManager, EntityId entityId, const char *name)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return nullptr;
// }
EMSCRIPTEN_KEEPALIVE Aabb3 SceneManager_getRenderableBoundingBox(TSceneManager *tSceneManager, EntityId entity)
{
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return sceneManager->getRenderableBoundingBox(entity);
}
// EMSCRIPTEN_KEEPALIVE Aabb3 SceneManager_getRenderableBoundingBox(TSceneManager *tSceneManager, EntityId entity)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return sceneManager->getRenderableBoundingBox(entity);
// }
EMSCRIPTEN_KEEPALIVE void SceneManager_setVisibilityLayer(TSceneManager *tSceneManager, EntityId entity, int layer)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->setVisibilityLayer(entity, layer);
}
// EMSCRIPTEN_KEEPALIVE void SceneManager_setVisibilityLayer(TSceneManager *tSceneManager, EntityId entity, int layer)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->setVisibilityLayer(entity, layer);
// }
EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitMaterialInstance(TSceneManager *sceneManager)
{
auto *instance = ((SceneManager *)sceneManager)->createUnlitMaterialInstance();
return reinterpret_cast<TMaterialInstance *>(instance);
}
// EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitMaterialInstance(TSceneManager *sceneManager)
// {
// auto *instance = ((SceneManager *)sceneManager)->createUnlitMaterialInstance();
// return reinterpret_cast<TMaterialInstance *>(instance);
// }
EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitFixedSizeMaterialInstance(TSceneManager *sceneManager)
{
auto *instance = ((SceneManager *)sceneManager)->createUnlitFixedSizeMaterialInstance();
return reinterpret_cast<TMaterialInstance *>(instance);
}
// EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitFixedSizeMaterialInstance(TSceneManager *sceneManager)
// {
// auto *instance = ((SceneManager *)sceneManager)->createUnlitFixedSizeMaterialInstance();
// return reinterpret_cast<TMaterialInstance *>(instance);
// }
EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_createCamera(TSceneManager *tSceneManager)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return reinterpret_cast<TCamera *>(sceneManager->createCamera());
}
// 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_destroyCamera(TSceneManager *tSceneManager, TCamera *tCamera)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *camera = reinterpret_cast<Camera *>(tCamera);
// sceneManager->destroyCamera(camera);
// }
EMSCRIPTEN_KEEPALIVE size_t SceneManager_getCameraCount(TSceneManager *tSceneManager)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return sceneManager->getCameraCount();
}
// EMSCRIPTEN_KEEPALIVE size_t SceneManager_getCameraCount(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return sceneManager->getCameraCount();
// }
EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraAt(TSceneManager *tSceneManager, size_t index)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *camera = sceneManager->getCameraAt(index);
return reinterpret_cast<TCamera *>(camera);
}
// EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraAt(TSceneManager *tSceneManager, size_t index)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *camera = sceneManager->getCameraAt(index);
// return reinterpret_cast<TCamera *>(camera);
// }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGeometry(
TSceneManager *tSceneManager,
float *vertices,
int numVertices,
float *normals,
int numNormals,
float *uvs,
int numUvs,
uint16_t *indices,
int numIndices,
int primitiveType,
TMaterialInstance **tMaterialInstances,
int materialInstanceCount,
bool keepData)
{
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto castedNumVertices = static_cast<uint32_t>(numVertices);
auto castedNumNormals = static_cast<uint32_t>(numNormals);
auto castedNumUvs = static_cast<uint32_t>(numUvs);
auto castedNumIndices = static_cast<uint32_t>(numIndices);
auto castedPrimitiveType = static_cast<filament::RenderableManager::PrimitiveType>(primitiveType);
auto materialInstances = reinterpret_cast<MaterialInstance **>(tMaterialInstances);
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGeometry(
// TSceneManager *tSceneManager,
// float *vertices,
// int numVertices,
// float *normals,
// int numNormals,
// float *uvs,
// int numUvs,
// uint16_t *indices,
// int numIndices,
// int primitiveType,
// TMaterialInstance **tMaterialInstances,
// int materialInstanceCount,
// bool keepData)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto castedNumVertices = static_cast<uint32_t>(numVertices);
// auto castedNumNormals = static_cast<uint32_t>(numNormals);
// auto castedNumUvs = static_cast<uint32_t>(numUvs);
// auto castedNumIndices = static_cast<uint32_t>(numIndices);
// auto castedPrimitiveType = static_cast<filament::RenderableManager::PrimitiveType>(primitiveType);
// auto materialInstances = reinterpret_cast<MaterialInstance **>(tMaterialInstances);
auto *asset = sceneManager->createGeometry(
vertices,
castedNumVertices,
normals,
castedNumNormals,
uvs,
castedNumUvs,
indices,
castedNumIndices,
castedPrimitiveType,
materialInstances,
materialInstanceCount,
keepData);
return reinterpret_cast<TSceneAsset *>(asset);
}
// auto *asset = sceneManager->createGeometry(
// vertices,
// castedNumVertices,
// normals,
// castedNumNormals,
// uvs,
// castedNumUvs,
// indices,
// castedNumIndices,
// castedPrimitiveType,
// materialInstances,
// materialInstanceCount,
// keepData);
// return reinterpret_cast<TSceneAsset *>(asset);
// }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstance(TSceneManager *sceneManager, TMaterialInstance *instance)
{
((SceneManager *)sceneManager)->destroy(reinterpret_cast<MaterialInstance *>(instance));
}
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstance(TSceneManager *sceneManager, TMaterialInstance *instance)
// {
// ((SceneManager *)sceneManager)->destroy(reinterpret_cast<MaterialInstance *>(instance));
// }
EMSCRIPTEN_KEEPALIVE int SceneManager_removeFromScene(TSceneManager *sceneManager, EntityId entityId)
{
return ((SceneManager *)sceneManager)->removeFromScene(entityId);
}
// EMSCRIPTEN_KEEPALIVE int SceneManager_removeFromScene(TSceneManager *sceneManager, EntityId entityId)
// {
// return ((SceneManager *)sceneManager)->removeFromScene(entityId);
// }
EMSCRIPTEN_KEEPALIVE int SceneManager_addToScene(TSceneManager *sceneManager, EntityId entityId)
{
return ((SceneManager *)sceneManager)->addToScene(entityId);
}
// EMSCRIPTEN_KEEPALIVE int SceneManager_addToScene(TSceneManager *sceneManager, EntityId entityId)
// {
// return ((SceneManager *)sceneManager)->addToScene(entityId);
// }
EMSCRIPTEN_KEEPALIVE void SceneManager_transformToUnitCube(TSceneManager *sceneManager, EntityId entityId)
{
((SceneManager *)sceneManager)->transformToUnitCube(entityId);
}
// EMSCRIPTEN_KEEPALIVE void SceneManager_transformToUnitCube(TSceneManager *sceneManager, EntityId entityId)
// {
// ((SceneManager *)sceneManager)->transformToUnitCube(entityId);
// }
EMSCRIPTEN_KEEPALIVE TAnimationManager *SceneManager_getAnimationManager(TSceneManager *tSceneManager)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *animationManager = sceneManager->getAnimationManager();
return reinterpret_cast<TAnimationManager *>(animationManager);
}
// EMSCRIPTEN_KEEPALIVE TAnimationManager *SceneManager_getAnimationManager(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *animationManager = sceneManager->getAnimationManager();
// return reinterpret_cast<TAnimationManager *>(animationManager);
// }
EMSCRIPTEN_KEEPALIVE EntityId SceneManager_addLight(
TSceneManager *tSceneManager,
uint8_t type,
float colour,
float intensity,
float posX,
float posY,
float posZ,
float dirX,
float dirY,
float dirZ,
float falloffRadius,
float spotLightConeInner,
float spotLightConeOuter,
float sunAngularRadius,
float sunHaloSize,
float sunHaloFallof,
bool shadows)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto entity = sceneManager->addLight(
(LightManager::Type)type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, falloffRadius, spotLightConeInner, spotLightConeOuter, sunAngularRadius, sunHaloSize, sunHaloFallof, shadows);
return Entity::smuggle(entity);
}
// EMSCRIPTEN_KEEPALIVE EntityId SceneManager_addLight(
// TSceneManager *tSceneManager,
// uint8_t type,
// float colour,
// float intensity,
// float posX,
// float posY,
// float posZ,
// float dirX,
// float dirY,
// float dirZ,
// float falloffRadius,
// float spotLightConeInner,
// float spotLightConeOuter,
// float sunAngularRadius,
// float sunHaloSize,
// float sunHaloFallof,
// bool shadows)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto entity = sceneManager->addLight(
// (LightManager::Type)type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, falloffRadius, spotLightConeInner, spotLightConeOuter, sunAngularRadius, sunHaloSize, sunHaloFallof, shadows);
// return Entity::smuggle(entity);
// }
EMSCRIPTEN_KEEPALIVE void SceneManager_removeLight(TSceneManager *tSceneManager, EntityId entityId)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->removeLight(utils::Entity::import(entityId));
}
// EMSCRIPTEN_KEEPALIVE void SceneManager_removeLight(TSceneManager *tSceneManager, EntityId entityId)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->removeLight(utils::Entity::import(entityId));
// }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAll(TSceneManager *tSceneManager)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->destroyAll();
}
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAll(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->destroyAll();
// }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAsset(TSceneManager *tSceneManager, TSceneAsset *tSceneAsset)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *sceneAsset = reinterpret_cast<SceneAsset *>(tSceneAsset);
sceneManager->destroy(sceneAsset);
}
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAsset(TSceneManager *tSceneManager, TSceneAsset *tSceneAsset)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *sceneAsset = reinterpret_cast<SceneAsset *>(tSceneAsset);
// sceneManager->destroy(sceneAsset);
// }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyLights(TSceneManager *tSceneManager)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->destroyLights();
}
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyLights(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->destroyLights();
// }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssets(TSceneManager *tSceneManager)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->destroyAssets();
}
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssets(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->destroyAssets();
// }
EMSCRIPTEN_KEEPALIVE TNameComponentManager *SceneManager_getNameComponentManager(TSceneManager *tSceneManager)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return reinterpret_cast<TNameComponentManager *>(sceneManager->getNameComponentManager());
}
// EMSCRIPTEN_KEEPALIVE TNameComponentManager *SceneManager_getNameComponentManager(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return reinterpret_cast<TNameComponentManager *>(sceneManager->getNameComponentManager());
// }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGrid(TSceneManager *tSceneManager, TMaterial *tMaterial)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *material = reinterpret_cast<Material *>(tMaterial);
auto *grid = sceneManager->createGrid(material);
return reinterpret_cast<TSceneAsset *>(grid);
}
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGrid(TSceneManager *tSceneManager, TMaterial *tMaterial)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *material = reinterpret_cast<Material *>(tMaterial);
// auto *grid = sceneManager->createGrid(material);
// return reinterpret_cast<TSceneAsset *>(grid);
// }
EMSCRIPTEN_KEEPALIVE bool SceneManager_isGridEntity(TSceneManager *tSceneManager, EntityId entityId)
{
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return sceneManager->isGridEntity(utils::Entity::import(entityId));
}
}
// EMSCRIPTEN_KEEPALIVE bool SceneManager_isGridEntity(TSceneManager *tSceneManager, EntityId entityId)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return sceneManager->isGridEntity(utils::Entity::import(entityId));
// }
// }

2
thermion_dart/native/src/c_api/TTexture.cpp
View File

@@ -1,3 +1,5 @@
#include <vector>
#include "c_api/TTexture.h"
#include <filament/Engine.h>

11
thermion_dart/native/src/c_api/TView.cpp
View File

@@ -5,7 +5,6 @@
#include <filament/ColorGrading.h>
#include <filament/Camera.h>
#include "c_api/ThermionDartApi.h"
#include "c_api/TView.h"
#include "Log.hpp"
@@ -92,23 +91,23 @@ using namespace filament;
#endif
}
EMSCRIPTEN_KEEPALIVE void View_setToneMapping(TView *tView, TEngine *tEngine, ToneMapping toneMapping)
EMSCRIPTEN_KEEPALIVE void View_setToneMapping(TView *tView, TEngine *tEngine, TToneMapping tToneMapping)
{
auto view = reinterpret_cast<View *>(tView);
auto engine = reinterpret_cast<Engine *>(tEngine);
ToneMapper *tm;
switch (toneMapping)
switch (tToneMapping)
{
case ToneMapping::ACES:
case TToneMapping::ACES:
Log("Setting tone mapping to ACES");
tm = new ACESToneMapper();
break;
case ToneMapping::LINEAR:
case TToneMapping::LINEAR:
Log("Setting tone mapping to Linear");
tm = new LinearToneMapper();
break;
case ToneMapping::FILMIC:
case TToneMapping::FILMIC:
Log("Setting tone mapping to Filmic");
tm = new FilmicToneMapper();
break;

306
thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
View File

@@ -10,15 +10,15 @@
#include "c_api/TEngine.h"
#include "c_api/TGltfAssetLoader.h"
#include "c_api/TRenderer.h"
#include "c_api/TRenderTicker.h"
#include "c_api/TRenderTarget.h"
#include "c_api/TScene.h"
#include "c_api/TSceneAsset.h"
#include "c_api/TSceneManager.h"
#include "c_api/TTexture.h"
#include "c_api/TView.h"
#include "c_api/ThermionDartRenderThreadApi.h"
#include "RenderTicker.hpp"
#include "rendering/RenderLoop.hpp"
#include "Log.hpp"
@@ -50,12 +50,12 @@ extern "C"
}
}
EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete)) {
EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete)()) {
_rl->requestFrame(onComplete);
}
EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, , uint64_t frameTimeInNanos, void (*onComplete)()) {
EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, void (*onComplete)()) {
std::packaged_task<void()> lambda(
[=]() mutable
{
@@ -65,11 +65,17 @@ extern "C"
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void Engine_createRenderThread(TBackend backend, void (*onComplete)(TEngine *)) {
EMSCRIPTEN_KEEPALIVE void Engine_createRenderThread(
TBackend backend,
void* platform,
void* sharedContext,
uint8_t stereoscopicEyeCount,
bool disableHandleUseAfterFreeCheck,
void (*onComplete)(TEngine *)) {
std::packaged_task<void()> lambda(
[=]() mutable
{
auto engine = Engine_create(backend);
auto engine = Engine_create(backend, platform, sharedContext, stereoscopicEyeCount, disableHandleUseAfterFreeCheck);
onComplete(engine);
});
auto fut = _rl->add_task(lambda);
@@ -109,7 +115,7 @@ extern "C"
std::packaged_task<void()> lambda(
[=]() mutable
{
Engine_destroySwapChain(tEngine);
Engine_destroySwapChain(tEngine, tSwapChain);
onComplete();
});
auto fut = _rl->add_task(lambda);
@@ -324,74 +330,6 @@ extern "C"
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void Viewer_renderRenderThread(TViewer *viewer, TView *tView, TSwapChain *tSwapChain)
{
std::packaged_task<void()> lambda([=]() mutable
{ _rl->doRender(); });
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_createGridRenderThread(TSceneManager *tSceneManager, TMaterial *tMaterial, void (*callback)(TSceneAsset *))
{
std::packaged_task<void()> lambda([=]() mutable
{
auto *sceneAsset = SceneManager_createGrid(tSceneManager, tMaterial);
callback(sceneAsset); });
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_loadGltfRenderThread(TSceneManager *sceneManager,
const char *path,
const char *relativeResourcePath,
bool keepData,
void (*callback)(TSceneAsset *))
{
std::packaged_task<void()> lambda([=]() mutable
{
auto entity = SceneManager_loadGltf(sceneManager, path, relativeResourcePath, keepData);
callback(entity); });
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_loadGlbRenderThread(TSceneManager *sceneManager,
const char *path,
int numInstances,
bool keepData,
void (*callback)(TSceneAsset *))
{
std::packaged_task<void()> lambda(
[=]() mutable
{
auto asset = SceneManager_loadGlb(sceneManager, path, numInstances, keepData);
callback(asset);
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_createGeometryRenderThread(
TSceneManager *sceneManager,
float *vertices,
int numVertices,
float *normals,
int numNormals,
float *uvs,
int numUvs,
uint16_t *indices,
int numIndices,
int primitiveType,
TMaterialInstance **materialInstances,
int materialInstanceCount,
bool keepData,
void (*callback)(TSceneAsset *))
{
std::packaged_task<void()> lambda(
[=]
{
auto *asset = SceneManager_createGeometry(sceneManager, vertices, numVertices, normals, numNormals, uvs, numUvs, indices, numIndices, primitiveType, materialInstances, materialInstanceCount, keepData);
callback(asset);
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneAsset_createGeometryRenderThread(
TEngine *tEngine,
@@ -442,109 +380,7 @@ extern "C"
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstanceRenderThread(TSceneManager *tSceneManager, TMaterialInstance *tMaterialInstance, void (*callback)())
{
std::packaged_task<void()> lambda(
[=]
{
SceneManager_destroyMaterialInstance(tSceneManager, tMaterialInstance);
callback();
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_createUnlitMaterialInstanceRenderThread(TSceneManager *sceneManager, void (*callback)(TMaterialInstance *))
{
std::packaged_task<void()> lambda(
[=]() mutable
{
auto instance = SceneManager_createUnlitMaterialInstance(sceneManager);
callback(instance);
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_createUnlitFixedSizeMaterialInstanceRenderThread(TSceneManager *sceneManager, void (*callback)(TMaterialInstance *))
{
std::packaged_task<void()> lambda(
[=]() mutable
{
auto instance = SceneManager_createUnlitFixedSizeMaterialInstance(sceneManager);
callback(instance);
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_loadGlbFromBufferRenderThread(TSceneManager *sceneManager,
const uint8_t *const data,
size_t length,
int numInstances,
bool keepData,
int priority,
int layer,
bool loadResourcesAsync,
void (*callback)(TSceneAsset *))
{
std::packaged_task<void()> lambda(
[=]() mutable
{
auto *asset = SceneManager_loadGlbFromBuffer(sceneManager, data, length, numInstances, keepData, priority, layer, loadResourcesAsync);
callback(asset);
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void clear_background_image_render_thread(TViewer *viewer)
{
std::packaged_task<void()> lambda([=]
{ clear_background_image(viewer); });
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void set_background_image_render_thread(TViewer *viewer,
const char *path,
bool fillHeight, void (*callback)())
{
std::packaged_task<void()> lambda(
[=]
{
set_background_image(viewer, path, fillHeight);
callback();
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void set_background_image_position_render_thread(TViewer *viewer,
float x, float y,
bool clamp)
{
std::packaged_task<void()> lambda(
[=]
{ set_background_image_position(viewer, x, y, clamp); });
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void Viewer_loadSkyboxRenderThread(TViewer *viewer,
const char *skyboxPath,
void (*onComplete)())
{
std::packaged_task<void()> lambda([=]
{
Viewer_loadSkybox(viewer, skyboxPath);
onComplete(); });
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void Viewer_removeSkyboxRenderThread(TViewer *viewer, void (*onComplete)())
{
std::packaged_task<void()> lambda([=]
{
Viewer_removeSkybox(viewer);
onComplete(); });
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, thermion::ToneMapping toneMapping)
EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, TToneMapping toneMapping)
{
std::packaged_task<void()> lambda(
[=]
@@ -575,124 +411,12 @@ extern "C"
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAllRenderThread(TSceneManager *tSceneManager, void (*callback)())
{
std::packaged_task<void()> lambda(
[=]() mutable
{
SceneManager_destroyAll(tSceneManager);
callback();
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE TGizmo *SceneManager_createGizmoRenderThread(
TSceneManager *tSceneManager,
TView *tView,
TScene *tScene,
TGizmoType tGizmoType,
void (*onComplete)(TGizmo *))
{
std::packaged_task<void()> lambda(
[=]() mutable
{
auto *gizmo = SceneManager_createGizmo(tSceneManager, tView, tScene, tGizmoType);
onComplete(gizmo);
});
auto fut = _rl->add_task(lambda);
return nullptr;
}
EMSCRIPTEN_KEEPALIVE void SceneManager_addLightRenderThread(
TSceneManager *tSceneManager,
uint8_t type,
float colour,
float intensity,
float posX,
float posY,
float posZ,
float dirX,
float dirY,
float dirZ,
float falloffRadius,
float spotLightConeInner,
float spotLightConeOuter,
float sunAngularRadius,
float sunHaloSize,
float sunHaloFallof,
bool shadows,
void (*callback)(EntityId entityId))
{
std::packaged_task<void()> lambda(
[=]() mutable
{
auto light = SceneManager_addLight(tSceneManager, type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, falloffRadius, spotLightConeInner, spotLightConeOuter, sunAngularRadius, sunHaloSize, sunHaloFallof, shadows);
callback(light);
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_removeLightRenderThread(TSceneManager *tSceneManager, EntityId entityId, void (*callback)())
{
std::packaged_task<void()> lambda(
[=]() mutable
{
SceneManager_removeLight(tSceneManager, entityId);
callback();
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssetRenderThread(TSceneManager *tSceneManager, TSceneAsset *tSceneAsset, void (*callback)())
{
std::packaged_task<void()> lambda(
[=]() mutable
{
SceneManager_destroyAsset(tSceneManager, tSceneAsset);
callback();
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssetsRenderThread(TSceneManager *tSceneManager, void (*callback)())
{
std::packaged_task<void()> lambda(
[=]() mutable
{
SceneManager_destroyAssets(tSceneManager);
callback();
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyLightsRenderThread(TSceneManager *tSceneManager, void (*callback)())
{
std::packaged_task<void()> lambda(
[=]() mutable
{
SceneManager_destroyLights(tSceneManager);
callback();
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void SceneManager_createCameraRenderThread(TSceneManager *tSceneManager, void (*callback)(TCamera *))
{
std::packaged_task<void()> lambda(
[=]() mutable
{
auto *camera = SceneManager_createCamera(tSceneManager);
callback(reinterpret_cast<TCamera *>(camera));
});
auto fut = _rl->add_task(lambda);
}
EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *)) {
std::packaged_task<void()> lambda(
[=]() mutable
{
auto *animationManager = AnimationManager_create(tEngine, tScene);
callback(animationManager);
onComplete(animationManager);
});
auto fut = _rl->add_task(lambda);
}