244 lines
8.4 KiB
C++
244 lines
8.4 KiB
C++
#include <filament/View.h>
|
|
#include <filament/Viewport.h>
|
|
#include <filament/Engine.h>
|
|
#include <filament/ToneMapper.h>
|
|
#include <filament/ColorGrading.h>
|
|
#include <filament/Camera.h>
|
|
|
|
#include "c_api/TView.h"
|
|
#include "Log.hpp"
|
|
|
|
#ifdef __cplusplus
|
|
namespace thermion {
|
|
extern "C"
|
|
{
|
|
using namespace filament;
|
|
|
|
#endif
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setBlendMode(TView *tView, TBlendMode tBlendMode) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
view->setBlendMode(static_cast<filament::View::BlendMode>(tBlendMode));
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE TViewport View_getViewport(TView *tView)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
auto & vp = view->getViewport();
|
|
TViewport tvp;
|
|
tvp.left = vp.left;
|
|
tvp.bottom = vp.bottom;
|
|
tvp.width = vp.width;
|
|
tvp.height = vp.height;
|
|
return tvp;
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setViewport(TView *tView, uint32_t width, uint32_t height)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
view->setViewport({0, 0, width, height});
|
|
TRACE("Set viewport to %dx%d", width, height);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE TRenderTarget *View_getRenderTarget(TView *tView) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
auto tRenderTarget = reinterpret_cast<TRenderTarget *>(view->getRenderTarget());
|
|
return tRenderTarget;
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setRenderTarget(TView *tView, TRenderTarget *tRenderTarget)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
auto renderTarget = reinterpret_cast<RenderTarget *>(tRenderTarget);
|
|
view->setRenderTarget(renderTarget);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setFrustumCullingEnabled(TView *tView, bool enabled)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
view->setFrustumCullingEnabled(enabled);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setPostProcessing(TView *tView, bool enabled)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
view->setPostProcessingEnabled(enabled);
|
|
TRACE("Set postprocessing enabled : %d", enabled);
|
|
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setShadowsEnabled(TView *tView, bool enabled)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
view->setShadowingEnabled(enabled);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setShadowType(TView *tView, int shadowType)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
view->setShadowType((ShadowType)shadowType);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setSoftShadowOptions(TView *tView, float penumbraScale, float penumbraRatioScale)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
SoftShadowOptions opts;
|
|
opts.penumbraRatioScale = penumbraRatioScale;
|
|
opts.penumbraScale = penumbraScale;
|
|
view->setSoftShadowOptions(opts);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setBloom(TView *tView, bool enabled, float strength)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
#ifndef __EMSCRIPTEN__
|
|
decltype(view->getBloomOptions()) opts;
|
|
opts.enabled = enabled;
|
|
opts.strength = strength;
|
|
TRACE("Setting bloom options {.enabled = %d, strength = %f}", enabled, strength);
|
|
view->setBloomOptions(opts);
|
|
#endif
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setColorGrading(TView *tView, TColorGrading *tColorGrading) {
|
|
auto *view = reinterpret_cast<View*>(tView);
|
|
auto *colorGrading = reinterpret_cast<ColorGrading *>(tColorGrading);
|
|
view->setColorGrading(colorGrading);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE TColorGrading *ColorGrading_create(TEngine* tEngine, TToneMapping tToneMapping) {
|
|
auto engine = reinterpret_cast<Engine *>(tEngine);
|
|
|
|
ToneMapper *tm;
|
|
switch (tToneMapping)
|
|
{
|
|
case TToneMapping::ACES:
|
|
TRACE("Setting tone mapping to ACES");
|
|
tm = new ACESToneMapper();
|
|
break;
|
|
case TToneMapping::LINEAR:
|
|
TRACE("Setting tone mapping to Linear");
|
|
tm = new LinearToneMapper();
|
|
break;
|
|
case TToneMapping::FILMIC:
|
|
TRACE("Setting tone mapping to Filmic");
|
|
tm = new FilmicToneMapper();
|
|
break;
|
|
default:
|
|
TRACE("ERROR: Unsupported tone mapping");
|
|
return nullptr;
|
|
}
|
|
auto colorGrading = ColorGrading::Builder().toneMapper(tm).build(*engine);
|
|
|
|
delete tm;
|
|
return reinterpret_cast<TColorGrading *>(colorGrading);
|
|
}
|
|
|
|
void View_setAntiAliasing(TView *tView, bool msaa, bool fxaa, bool taa)
|
|
{
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
View::MultiSampleAntiAliasingOptions multiSampleAntiAliasingOptions;
|
|
multiSampleAntiAliasingOptions.enabled = msaa;
|
|
multiSampleAntiAliasingOptions.sampleCount = 2;
|
|
view->setMultiSampleAntiAliasingOptions(multiSampleAntiAliasingOptions);
|
|
|
|
TemporalAntiAliasingOptions taaOpts;
|
|
taaOpts.enabled = taa;
|
|
|
|
view->setTemporalAntiAliasingOptions(taaOpts);
|
|
view->setAntiAliasing(fxaa ? AntiAliasing::FXAA : AntiAliasing::NONE);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setLayerEnabled(TView* tView, int layer, bool enabled) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
view->setLayerEnabled(layer, enabled);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setCamera(TView *tView, TCamera *tCamera) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
auto *camera = reinterpret_cast<Camera *>(tCamera);
|
|
view->setCamera(camera);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE TScene* View_getScene(TView* tView) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
return reinterpret_cast<TScene*>(view->getScene());
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE TCamera* View_getCamera(TView *tView) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
return reinterpret_cast<TCamera*>(&(view->getCamera()));
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setStencilBufferEnabled(TView *tView, bool enabled) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
view->setStencilBufferEnabled(enabled);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE bool View_isStencilBufferEnabled(TView *tView) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
return view->isStencilBufferEnabled();
|
|
}
|
|
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_pick(TView *tView, uint32_t requestId, uint32_t x, uint32_t y, PickCallback callback)
|
|
{
|
|
auto *view = reinterpret_cast<View *>(tView);
|
|
view->pick(x, y, [=](filament::View::PickingQueryResult const &result) {
|
|
callback(requestId, utils::Entity::smuggle(result.renderable), result.depth, result.fragCoords.x, result.fragCoords.y, result.fragCoords.z);
|
|
});
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setDitheringEnabled(TView *tView, bool enabled) {
|
|
auto *view = reinterpret_cast<View *>(tView);
|
|
if(enabled) {
|
|
view->setDithering(Dithering::TEMPORAL);
|
|
} else {
|
|
view->setDithering(Dithering::NONE);
|
|
}
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE bool View_isDitheringEnabled(TView *tView) {
|
|
auto *view = reinterpret_cast<View *>(tView);
|
|
return view->getDithering() == Dithering::TEMPORAL;
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setRenderQuality(TView *tView, TQualityLevel qualityLevel) {
|
|
auto view = reinterpret_cast<View *>(tView);
|
|
RenderQuality rq;
|
|
rq.hdrColorBuffer = (filament::QualityLevel)qualityLevel;
|
|
switch(rq.hdrColorBuffer) {
|
|
case filament::QualityLevel::LOW:
|
|
TRACE("Render Quality: LOW");
|
|
break;
|
|
case filament::QualityLevel::MEDIUM:
|
|
TRACE("Render Quality: MEDIUM");
|
|
break;
|
|
case filament::QualityLevel::HIGH:
|
|
TRACE("Render Quality: HIGH");
|
|
break;
|
|
case filament::QualityLevel::ULTRA:
|
|
TRACE("Render Quality: ULTRA");
|
|
break;
|
|
}
|
|
|
|
view->setRenderQuality(rq);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setScene(TView *tView, TScene *tScene) {
|
|
auto *view = reinterpret_cast<View*>(tView);
|
|
auto *scene = reinterpret_cast<Scene*>(tScene);
|
|
view->setScene(scene);
|
|
}
|
|
|
|
EMSCRIPTEN_KEEPALIVE void View_setFrontFaceWindingInverted(TView *tView, bool inverted) {
|
|
auto *view = reinterpret_cast<View*>(tView);
|
|
view->setFrontFaceWindingInverted(inverted);
|
|
}
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
}
|
|
#endif
|