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(filament::Renderer *renderer) : mRenderer(renderer) { }
~RenderTicker(); ~RenderTicker();
/// @brief
/// @param frameTimeInNanos
void render( void render(
uint64_t frameTimeInNanos uint64_t frameTimeInNanos
); );
/// @brief
/// @param swapChain
/// @param view
/// @param numViews
void setRenderable(filament::SwapChain *swapChain, filament::View **view, uint8_t numViews); void setRenderable(filament::SwapChain *swapChain, filament::View **view, uint8_t numViews);
/// @brief
/// @param animationManager
void addAnimationManager(AnimationManager* animationManager); void addAnimationManager(AnimationManager* animationManager);
/// @brief
/// @param animationManager
void removeAnimationManager(AnimationManager* animationManager); void removeAnimationManager(AnimationManager* animationManager);

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

@@ -8,7 +8,7 @@ extern "C"
{ {
#endif #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); 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 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 TRenderer *Engine_createRenderer(TEngine *tEngine);
EMSCRIPTEN_KEEPALIVE TSwapChain *Engine_createSwapChain(TEngine *tEngine, void *window, uint64_t flags); 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); 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_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 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_destroyLight(TLightManager *tLightManager, EntityId entity);
EMSCRIPTEN_KEEPALIVE void LightManager_setColor(TLightManager *tLightManager, EntityId entity, float colorTemperature); EMSCRIPTEN_KEEPALIVE void LightManager_setColor(TLightManager *tLightManager, EntityId entity, float colorTemperature);
EMSCRIPTEN_KEEPALIVE void LightManager_setIntensity(TLightManager *tLightManager, EntityId entity, double intensity); 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_create();
EMSCRIPTEN_KEEPALIVE void RenderLoop_destroy(); EMSCRIPTEN_KEEPALIVE void RenderLoop_destroy();
EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete)); 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 RenderLoop_addTask(TRenderLoop* tRenderLoop, void (*task)());
EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *)); 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 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_setBloomRenderThread(TView *tView, bool enabled, double strength);
EMSCRIPTEN_KEEPALIVE void View_setCameraRenderThread(TView *tView, TCamera *tCamera, void (*callback)()); 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); 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 SceneAsset *getInstanceByEntity(utils::Entity entity) override
{ {
for (auto &instance : _instances) for (auto &instance : _instances)

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

@@ -19,7 +19,6 @@
#include <filament/IndexBuffer.h> #include <filament/IndexBuffer.h>
#include <filament/InstanceBuffer.h> #include <filament/InstanceBuffer.h>
#include "c_api/ThermionDartApi.h"
#include "scene/SceneAsset.hpp" #include "scene/SceneAsset.hpp"
namespace thermion namespace thermion
@@ -106,14 +105,6 @@ namespace thermion
return utils::Entity::import(0); 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 highlight(Gizmo::Axis axis);
void unhighlight(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(); 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 { const filament::Aabb getBoundingBox() const override {
return _instance->getBoundingBox(); 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) { void RenderTicker::setRenderable(SwapChain *swapChain, View **views, uint8_t numViews) {
std::lock_guard lock(mMutex); std::lock_guard lock(mMutex);
// Find if this swapChain already exists in our collection
auto it = std::find_if(mRenderable.begin(), mRenderable.end(), auto it = std::find_if(mRenderable.begin(), mRenderable.end(),
[swapChain](const auto& pair) { return pair.first == swapChain; }); [swapChain](const auto& pair) { return pair.first == swapChain; });
// Prepare the vector of views
std::vector<View*> swapChainViews; std::vector<View*> swapChainViews;
for(int i = 0; i < numViews; i++) { for(int i = 0; i < numViews; i++) {
swapChainViews.push_back(views[i]); swapChainViews.push_back(views[i]);
} }
if (it != mRenderable.end()) { if (it != mRenderable.end()) {
// Update existing entry
it->second = swapChainViews; it->second = swapChainViews;
} else { } else {
// Add new entry
mRenderable.emplace_back(swapChain, swapChainViews); 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 <utils/NameComponentManager.h>
#include "Log.hpp" #include "Log.hpp"
#include "MathUtils.hpp"
#ifdef __cplusplus #ifdef __cplusplus
namespace thermion 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) { EMSCRIPTEN_KEEPALIVE TMaterialProvider *GltfAssetLoader_getMaterialProvider(TGltfAssetLoader *tAssetLoader) {
auto *assetLoader = reinterpret_cast<gltfio::AssetLoader>(tAssetLoader); auto *assetLoader = reinterpret_cast<gltfio::AssetLoader *>(tAssetLoader);
auto materialProvider = assetLoader->getMaterialProvider(); auto &materialProvider = assetLoader->getMaterialProvider();
return reinterpret_cast<TMaterialProvider *>(&materialProvider); 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); filament::LightManager::Builder builder(lightType);
auto entity = utils::EntityManager::create(); auto entity = utils::EntityManager::create();
auto result = builder.build(*engine, utils::Entity::import(entity)); 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"); Log("Failed to create light");
} }
return entity; return entity;

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

@@ -1,22 +1,23 @@
#ifdef _WIN32 #ifdef _WIN32
#include "ThermionWin32.h" #include "ThermionWin32.h"
#endif #endif
#ifdef __EMSCRIPTEN__
#include <emscripten/emscripten.h>
#endif
#include <thread> #include <thread>
#include <functional> #include <functional>
#ifdef __EMSCRIPTEN__ #include <filament/LightManager.h>
#include <emscripten/emscripten.h>
#endif
#include "filament/LightManager.h"
#include "Log.hpp" #include "Log.hpp"
#include "RenderTicker.hpp"
using namespace thermion; using namespace thermion;
extern "C" extern "C"
{ {
#include "c_api/TRenderTicker.hpp" #include "c_api/TRenderTicker.h"
EMSCRIPTEN_KEEPALIVE TRenderTicker *RenderTicker_create(TRenderer *tRenderer) { EMSCRIPTEN_KEEPALIVE TRenderTicker *RenderTicker_create(TRenderer *tRenderer) {
auto *renderer = reinterpret_cast<filament::Renderer *>(tRenderer); auto *renderer = reinterpret_cast<filament::Renderer *>(tRenderer);
@@ -24,7 +25,7 @@ EMSCRIPTEN_KEEPALIVE TRenderTicker *RenderTicker_create(TRenderer *tRenderer) {
return reinterpret_cast<TRenderTicker *>(renderTicker); 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); auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
delete renderTicker; delete renderTicker;
} }
@@ -42,12 +43,14 @@ EMSCRIPTEN_KEEPALIVE void RenderTicker_removeAnimationManager(TRenderTicker *tRe
} }
EMSCRIPTEN_KEEPALIVE void RenderTicker_render(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos) { EMSCRIPTEN_KEEPALIVE void RenderTicker_render(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos) {
auto *renderTicker = reinterpret_cast<RenderTicker *> auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
renderTicker->render(frameTimeInNanos); renderTicker->render(frameTimeInNanos);
} }
EMSCRIPTEN_KEEPALIVE void RenderTicker_setRenderable(TRenderTicker *tRenderTicker, TSwapChain *swapChain, TView **views, uint8_t numViews) { EMSCRIPTEN_KEEPALIVE void RenderTicker_setRenderable(TRenderTicker *tRenderTicker, TSwapChain *tSwapChain, TView **tViews, uint8_t numViews) {
auto *renderTicker = reinterpret_cast<RenderTicker *> auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
auto *swapChain = reinterpret_cast<filament::SwapChain *>(tSwapChain);
auto *views = reinterpret_cast<View **>(tViews);
renderTicker->setRenderable(swapChain, views, numViews); 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); const auto &entity = utils::Entity::import(entityId);
auto renderableInstance = renderableManager->getInstance(entity); auto renderableInstance = renderableManager->getInstance(entity);
if (!renderableInstance.isValid()) { 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}; 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) { EMSCRIPTEN_KEEPALIVE void RenderableManager_setVisibilityLayer(TRenderableManager *tRenderableManager, EntityId entityId, uint8_t layer) {
auto *renderableManager = reinterpret_cast<filament::RenderableManager *>(tRenderableManager); auto *renderableManager = reinterpret_cast<filament::RenderableManager *>(tRenderableManager);
const auto &entity = utils::Entity::import(entityId); const auto &entity = utils::Entity::import(entityId);
if (!renderableManager.hasComponent(entity)) { if (!renderableManager->hasComponent(entity)) {
Log("Not renderable"); Log("Not renderable");
return; return;
} }
@@ -140,12 +140,12 @@ namespace thermion
auto *renderableManager = reinterpret_cast<filament::RenderableManager *>(tRenderableManager); auto *renderableManager = reinterpret_cast<filament::RenderableManager *>(tRenderableManager);
const auto &entity = utils::Entity::import(entityId); const auto &entity = utils::Entity::import(entityId);
if (!renderableManager.hasComponent(entity)) { if (!renderableManager->hasComponent(entity)) {
Log("Not renderable"); Log("Not renderable");
return; return;
} }
auto renderableInstance = renderableManager->getInstance(entity); 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 #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) { 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); 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) { EMSCRIPTEN_KEEPALIVE void Scene_removeEntity(TScene* tScene, EntityId entityId) {
auto *scene = reinterpret_cast<Scene *>(tScene); 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) { 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 "c_api/APIExport.h"
#include "ResourceBuffer.hpp" // #include "ResourceBuffer.hpp"
#include "FilamentViewer.hpp" // #include "FilamentViewer.hpp"
#include "Log.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) // EMSCRIPTEN_KEEPALIVE TScene *SceneManager_getScene(TSceneManager *tSceneManager)
{ // {
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return reinterpret_cast<TScene *>(sceneManager->getScene()); // return reinterpret_cast<TScene *>(sceneManager->getScene());
} // }
EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUnlitMaterialProvider(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUnlitMaterialProvider(TSceneManager *tSceneManager)
{ // {
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto provider = sceneManager->getUnlitMaterialProvider(); // auto provider = sceneManager->getUnlitMaterialProvider();
return reinterpret_cast<TMaterialProvider *>(provider); // return reinterpret_cast<TMaterialProvider *>(provider);
} // }
EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUbershaderMaterialProvider(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUbershaderMaterialProvider(TSceneManager *tSceneManager)
{ // {
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto provider = sceneManager->getUbershaderMaterialProvider(); // auto provider = sceneManager->getUbershaderMaterialProvider();
return reinterpret_cast<TMaterialProvider *>(provider); // return reinterpret_cast<TMaterialProvider *>(provider);
} // }
EMSCRIPTEN_KEEPALIVE TGizmo *SceneManager_createGizmo(TSceneManager *tSceneManager, TView *tView, TScene *tScene, TGizmoType tGizmoType) // EMSCRIPTEN_KEEPALIVE TGizmo *SceneManager_createGizmo(TSceneManager *tSceneManager, TView *tView, TScene *tScene, TGizmoType tGizmoType)
{ // {
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *scene = reinterpret_cast<Scene *>(tScene); // auto *scene = reinterpret_cast<Scene *>(tScene);
auto *view = reinterpret_cast<View *>(tView); // auto *view = reinterpret_cast<View *>(tView);
auto gizmo = sceneManager->createGizmo(view, scene, static_cast<SceneManager::GizmoType>(tGizmoType)); // auto gizmo = sceneManager->createGizmo(view, scene, static_cast<SceneManager::GizmoType>(tGizmoType));
return reinterpret_cast<TGizmo *>(gizmo); // return reinterpret_cast<TGizmo *>(gizmo);
} // }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlb(TSceneManager *tSceneManager, const char *assetPath, int numInstances, bool keepData) // EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlb(TSceneManager *tSceneManager, const char *assetPath, int numInstances, bool keepData)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *asset = sceneManager->loadGlb(assetPath, numInstances, keepData); // auto *asset = sceneManager->loadGlb(assetPath, numInstances, keepData);
return reinterpret_cast<TSceneAsset *>(asset); // return reinterpret_cast<TSceneAsset *>(asset);
} // }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGltf(TSceneManager *tSceneManager, // EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGltf(TSceneManager *tSceneManager,
const char *assetPath, // const char *assetPath,
const char *relativeResourcePath, // const char *relativeResourcePath,
bool keepData) // bool keepData)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *asset = sceneManager->loadGltf(assetPath, relativeResourcePath, 1, keepData); // auto *asset = sceneManager->loadGltf(assetPath, relativeResourcePath, 1, keepData);
return reinterpret_cast<TSceneAsset *>(asset); // 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) // 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 *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *asset = sceneManager->loadGlbFromBuffer((const uint8_t *)data, length, numInstances, keepData, priority, layer, loadResourcesAsync); // auto *asset = sceneManager->loadGlbFromBuffer((const uint8_t *)data, length, numInstances, keepData, priority, layer, loadResourcesAsync);
return reinterpret_cast<TSceneAsset *>(asset); // return reinterpret_cast<TSceneAsset *>(asset);
} // }
EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraByName(TSceneManager *tSceneManager, EntityId entityId, const char *name) // EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraByName(TSceneManager *tSceneManager, EntityId entityId, const char *name)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return nullptr; // return nullptr;
} // }
EMSCRIPTEN_KEEPALIVE Aabb3 SceneManager_getRenderableBoundingBox(TSceneManager *tSceneManager, EntityId entity) // EMSCRIPTEN_KEEPALIVE Aabb3 SceneManager_getRenderableBoundingBox(TSceneManager *tSceneManager, EntityId entity)
{ // {
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return sceneManager->getRenderableBoundingBox(entity); // return sceneManager->getRenderableBoundingBox(entity);
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_setVisibilityLayer(TSceneManager *tSceneManager, EntityId entity, int layer) // EMSCRIPTEN_KEEPALIVE void SceneManager_setVisibilityLayer(TSceneManager *tSceneManager, EntityId entity, int layer)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->setVisibilityLayer(entity, layer); // sceneManager->setVisibilityLayer(entity, layer);
} // }
EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitMaterialInstance(TSceneManager *sceneManager) // EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitMaterialInstance(TSceneManager *sceneManager)
{ // {
auto *instance = ((SceneManager *)sceneManager)->createUnlitMaterialInstance(); // auto *instance = ((SceneManager *)sceneManager)->createUnlitMaterialInstance();
return reinterpret_cast<TMaterialInstance *>(instance); // return reinterpret_cast<TMaterialInstance *>(instance);
} // }
EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitFixedSizeMaterialInstance(TSceneManager *sceneManager) // EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitFixedSizeMaterialInstance(TSceneManager *sceneManager)
{ // {
auto *instance = ((SceneManager *)sceneManager)->createUnlitFixedSizeMaterialInstance(); // auto *instance = ((SceneManager *)sceneManager)->createUnlitFixedSizeMaterialInstance();
return reinterpret_cast<TMaterialInstance *>(instance); // return reinterpret_cast<TMaterialInstance *>(instance);
} // }
EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_createCamera(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_createCamera(TSceneManager *tSceneManager)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return reinterpret_cast<TCamera *>(sceneManager->createCamera()); // return reinterpret_cast<TCamera *>(sceneManager->createCamera());
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyCamera(TSceneManager *tSceneManager, TCamera *tCamera) // EMSCRIPTEN_KEEPALIVE void SceneManager_destroyCamera(TSceneManager *tSceneManager, TCamera *tCamera)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *camera = reinterpret_cast<Camera *>(tCamera); // auto *camera = reinterpret_cast<Camera *>(tCamera);
sceneManager->destroyCamera(camera); // sceneManager->destroyCamera(camera);
} // }
EMSCRIPTEN_KEEPALIVE size_t SceneManager_getCameraCount(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE size_t SceneManager_getCameraCount(TSceneManager *tSceneManager)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return sceneManager->getCameraCount(); // return sceneManager->getCameraCount();
} // }
EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraAt(TSceneManager *tSceneManager, size_t index) // EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraAt(TSceneManager *tSceneManager, size_t index)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *camera = sceneManager->getCameraAt(index); // auto *camera = sceneManager->getCameraAt(index);
return reinterpret_cast<TCamera *>(camera); // return reinterpret_cast<TCamera *>(camera);
} // }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGeometry( // EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGeometry(
TSceneManager *tSceneManager, // TSceneManager *tSceneManager,
float *vertices, // float *vertices,
int numVertices, // int numVertices,
float *normals, // float *normals,
int numNormals, // int numNormals,
float *uvs, // float *uvs,
int numUvs, // int numUvs,
uint16_t *indices, // uint16_t *indices,
int numIndices, // int numIndices,
int primitiveType, // int primitiveType,
TMaterialInstance **tMaterialInstances, // TMaterialInstance **tMaterialInstances,
int materialInstanceCount, // int materialInstanceCount,
bool keepData) // bool keepData)
{ // {
auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto castedNumVertices = static_cast<uint32_t>(numVertices); // auto castedNumVertices = static_cast<uint32_t>(numVertices);
auto castedNumNormals = static_cast<uint32_t>(numNormals); // auto castedNumNormals = static_cast<uint32_t>(numNormals);
auto castedNumUvs = static_cast<uint32_t>(numUvs); // auto castedNumUvs = static_cast<uint32_t>(numUvs);
auto castedNumIndices = static_cast<uint32_t>(numIndices); // auto castedNumIndices = static_cast<uint32_t>(numIndices);
auto castedPrimitiveType = static_cast<filament::RenderableManager::PrimitiveType>(primitiveType); // auto castedPrimitiveType = static_cast<filament::RenderableManager::PrimitiveType>(primitiveType);
auto materialInstances = reinterpret_cast<MaterialInstance **>(tMaterialInstances); // auto materialInstances = reinterpret_cast<MaterialInstance **>(tMaterialInstances);
auto *asset = sceneManager->createGeometry( // auto *asset = sceneManager->createGeometry(
vertices, // vertices,
castedNumVertices, // castedNumVertices,
normals, // normals,
castedNumNormals, // castedNumNormals,
uvs, // uvs,
castedNumUvs, // castedNumUvs,
indices, // indices,
castedNumIndices, // castedNumIndices,
castedPrimitiveType, // castedPrimitiveType,
materialInstances, // materialInstances,
materialInstanceCount, // materialInstanceCount,
keepData); // keepData);
return reinterpret_cast<TSceneAsset *>(asset); // return reinterpret_cast<TSceneAsset *>(asset);
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstance(TSceneManager *sceneManager, TMaterialInstance *instance) // EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstance(TSceneManager *sceneManager, TMaterialInstance *instance)
{ // {
((SceneManager *)sceneManager)->destroy(reinterpret_cast<MaterialInstance *>(instance)); // ((SceneManager *)sceneManager)->destroy(reinterpret_cast<MaterialInstance *>(instance));
} // }
EMSCRIPTEN_KEEPALIVE int SceneManager_removeFromScene(TSceneManager *sceneManager, EntityId entityId) // EMSCRIPTEN_KEEPALIVE int SceneManager_removeFromScene(TSceneManager *sceneManager, EntityId entityId)
{ // {
return ((SceneManager *)sceneManager)->removeFromScene(entityId); // return ((SceneManager *)sceneManager)->removeFromScene(entityId);
} // }
EMSCRIPTEN_KEEPALIVE int SceneManager_addToScene(TSceneManager *sceneManager, EntityId entityId) // EMSCRIPTEN_KEEPALIVE int SceneManager_addToScene(TSceneManager *sceneManager, EntityId entityId)
{ // {
return ((SceneManager *)sceneManager)->addToScene(entityId); // return ((SceneManager *)sceneManager)->addToScene(entityId);
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_transformToUnitCube(TSceneManager *sceneManager, EntityId entityId) // EMSCRIPTEN_KEEPALIVE void SceneManager_transformToUnitCube(TSceneManager *sceneManager, EntityId entityId)
{ // {
((SceneManager *)sceneManager)->transformToUnitCube(entityId); // ((SceneManager *)sceneManager)->transformToUnitCube(entityId);
} // }
EMSCRIPTEN_KEEPALIVE TAnimationManager *SceneManager_getAnimationManager(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE TAnimationManager *SceneManager_getAnimationManager(TSceneManager *tSceneManager)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *animationManager = sceneManager->getAnimationManager(); // auto *animationManager = sceneManager->getAnimationManager();
return reinterpret_cast<TAnimationManager *>(animationManager); // return reinterpret_cast<TAnimationManager *>(animationManager);
} // }
EMSCRIPTEN_KEEPALIVE EntityId SceneManager_addLight( // EMSCRIPTEN_KEEPALIVE EntityId SceneManager_addLight(
TSceneManager *tSceneManager, // TSceneManager *tSceneManager,
uint8_t type, // uint8_t type,
float colour, // float colour,
float intensity, // float intensity,
float posX, // float posX,
float posY, // float posY,
float posZ, // float posZ,
float dirX, // float dirX,
float dirY, // float dirY,
float dirZ, // float dirZ,
float falloffRadius, // float falloffRadius,
float spotLightConeInner, // float spotLightConeInner,
float spotLightConeOuter, // float spotLightConeOuter,
float sunAngularRadius, // float sunAngularRadius,
float sunHaloSize, // float sunHaloSize,
float sunHaloFallof, // float sunHaloFallof,
bool shadows) // bool shadows)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto entity = sceneManager->addLight( // auto entity = sceneManager->addLight(
(LightManager::Type)type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, falloffRadius, spotLightConeInner, spotLightConeOuter, sunAngularRadius, sunHaloSize, sunHaloFallof, shadows); // (LightManager::Type)type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, falloffRadius, spotLightConeInner, spotLightConeOuter, sunAngularRadius, sunHaloSize, sunHaloFallof, shadows);
return Entity::smuggle(entity); // return Entity::smuggle(entity);
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_removeLight(TSceneManager *tSceneManager, EntityId entityId) // EMSCRIPTEN_KEEPALIVE void SceneManager_removeLight(TSceneManager *tSceneManager, EntityId entityId)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->removeLight(utils::Entity::import(entityId)); // sceneManager->removeLight(utils::Entity::import(entityId));
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAll(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAll(TSceneManager *tSceneManager)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->destroyAll(); // sceneManager->destroyAll();
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAsset(TSceneManager *tSceneManager, TSceneAsset *tSceneAsset) // EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAsset(TSceneManager *tSceneManager, TSceneAsset *tSceneAsset)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *sceneAsset = reinterpret_cast<SceneAsset *>(tSceneAsset); // auto *sceneAsset = reinterpret_cast<SceneAsset *>(tSceneAsset);
sceneManager->destroy(sceneAsset); // sceneManager->destroy(sceneAsset);
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyLights(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE void SceneManager_destroyLights(TSceneManager *tSceneManager)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->destroyLights(); // sceneManager->destroyLights();
} // }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssets(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssets(TSceneManager *tSceneManager)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
sceneManager->destroyAssets(); // sceneManager->destroyAssets();
} // }
EMSCRIPTEN_KEEPALIVE TNameComponentManager *SceneManager_getNameComponentManager(TSceneManager *tSceneManager) // EMSCRIPTEN_KEEPALIVE TNameComponentManager *SceneManager_getNameComponentManager(TSceneManager *tSceneManager)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return reinterpret_cast<TNameComponentManager *>(sceneManager->getNameComponentManager()); // return reinterpret_cast<TNameComponentManager *>(sceneManager->getNameComponentManager());
} // }
EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGrid(TSceneManager *tSceneManager, TMaterial *tMaterial) // EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGrid(TSceneManager *tSceneManager, TMaterial *tMaterial)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
auto *material = reinterpret_cast<Material *>(tMaterial); // auto *material = reinterpret_cast<Material *>(tMaterial);
auto *grid = sceneManager->createGrid(material); // auto *grid = sceneManager->createGrid(material);
return reinterpret_cast<TSceneAsset *>(grid); // return reinterpret_cast<TSceneAsset *>(grid);
} // }
EMSCRIPTEN_KEEPALIVE bool SceneManager_isGridEntity(TSceneManager *tSceneManager, EntityId entityId) // EMSCRIPTEN_KEEPALIVE bool SceneManager_isGridEntity(TSceneManager *tSceneManager, EntityId entityId)
{ // {
auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager); // auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
return sceneManager->isGridEntity(utils::Entity::import(entityId)); // 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 "c_api/TTexture.h"
#include <filament/Engine.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/ColorGrading.h>
#include <filament/Camera.h> #include <filament/Camera.h>
#include "c_api/ThermionDartApi.h"
#include "c_api/TView.h" #include "c_api/TView.h"
#include "Log.hpp" #include "Log.hpp"
@@ -92,23 +91,23 @@ using namespace filament;
#endif #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 view = reinterpret_cast<View *>(tView);
auto engine = reinterpret_cast<Engine *>(tEngine); auto engine = reinterpret_cast<Engine *>(tEngine);
ToneMapper *tm; ToneMapper *tm;
switch (toneMapping) switch (tToneMapping)
{ {
case ToneMapping::ACES: case TToneMapping::ACES:
Log("Setting tone mapping to ACES"); Log("Setting tone mapping to ACES");
tm = new ACESToneMapper(); tm = new ACESToneMapper();
break; break;
case ToneMapping::LINEAR: case TToneMapping::LINEAR:
Log("Setting tone mapping to Linear"); Log("Setting tone mapping to Linear");
tm = new LinearToneMapper(); tm = new LinearToneMapper();
break; break;
case ToneMapping::FILMIC: case TToneMapping::FILMIC:
Log("Setting tone mapping to Filmic"); Log("Setting tone mapping to Filmic");
tm = new FilmicToneMapper(); tm = new FilmicToneMapper();
break; break;

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

@@ -10,15 +10,15 @@
#include "c_api/TEngine.h" #include "c_api/TEngine.h"
#include "c_api/TGltfAssetLoader.h" #include "c_api/TGltfAssetLoader.h"
#include "c_api/TRenderer.h" #include "c_api/TRenderer.h"
#include "c_api/TRenderTicker.h"
#include "c_api/TRenderTarget.h" #include "c_api/TRenderTarget.h"
#include "c_api/TScene.h" #include "c_api/TScene.h"
#include "c_api/TSceneAsset.h" #include "c_api/TSceneAsset.h"
#include "c_api/TSceneManager.h"
#include "c_api/TTexture.h" #include "c_api/TTexture.h"
#include "c_api/TView.h" #include "c_api/TView.h"
#include "c_api/ThermionDartRenderThreadApi.h" #include "c_api/ThermionDartRenderThreadApi.h"
#include "RenderTicker.hpp"
#include "rendering/RenderLoop.hpp" #include "rendering/RenderLoop.hpp"
#include "Log.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); _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( std::packaged_task<void()> lambda(
[=]() mutable [=]() mutable
{ {
@@ -65,11 +65,17 @@ extern "C"
auto fut = _rl->add_task(lambda); 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( std::packaged_task<void()> lambda(
[=]() mutable [=]() mutable
{ {
auto engine = Engine_create(backend); auto engine = Engine_create(backend, platform, sharedContext, stereoscopicEyeCount, disableHandleUseAfterFreeCheck);
onComplete(engine); onComplete(engine);
}); });
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
@@ -109,7 +115,7 @@ extern "C"
std::packaged_task<void()> lambda( std::packaged_task<void()> lambda(
[=]() mutable [=]() mutable
{ {
Engine_destroySwapChain(tEngine); Engine_destroySwapChain(tEngine, tSwapChain);
onComplete(); onComplete();
}); });
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
@@ -324,74 +330,6 @@ extern "C"
auto fut = _rl->add_task(lambda); 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( EMSCRIPTEN_KEEPALIVE void SceneAsset_createGeometryRenderThread(
TEngine *tEngine, TEngine *tEngine,
@@ -442,109 +380,7 @@ extern "C"
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }
EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstanceRenderThread(TSceneManager *tSceneManager, TMaterialInstance *tMaterialInstance, void (*callback)()) EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, TToneMapping toneMapping)
{
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)
{ {
std::packaged_task<void()> lambda( std::packaged_task<void()> lambda(
[=] [=]
@@ -575,124 +411,12 @@ extern "C"
auto fut = _rl->add_task(lambda); 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 *)) { EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *)) {
std::packaged_task<void()> lambda( std::packaged_task<void()> lambda(
[=]() mutable [=]() mutable
{ {
auto *animationManager = AnimationManager_create(tEngine, tScene); auto *animationManager = AnimationManager_create(tEngine, tScene);
callback(animationManager); onComplete(animationManager);
}); });
auto fut = _rl->add_task(lambda); auto fut = _rl->add_task(lambda);
} }