From 63cfb817d763eba672d539f5d9fcc18bfba1a52e Mon Sep 17 00:00:00 2001 From: Philip Rideout Date: Wed, 11 May 2022 08:02:35 -0700 Subject: [PATCH] Use generated code for all "Options" JS bindings. (#5536) TypeScript bindings and Java are still TBD. --- filament/include/filament/Options.h | 6 +- tools/codegen-options/README.md | 1 + tools/codegen-options/javascript.go | 24 ++- tools/codegen-options/javascript.template | 16 +- tools/codegen-options/parser.go | 5 - web/filament-js/CMakeLists.txt | 5 +- web/filament-js/extensions.js | 113 ++------------ web/filament-js/extensions_generated.js | 181 ++++++++++++++++++++++ web/filament-js/jsbindings.cpp | 89 ----------- web/filament-js/jsbindings_generated.cpp | 147 ++++++++++++++++++ web/filament-js/jsenums.cpp | 23 --- web/filament-js/jsenums_generated.cpp | 53 +++++++ 12 files changed, 432 insertions(+), 231 deletions(-) create mode 100644 web/filament-js/extensions_generated.js create mode 100644 web/filament-js/jsbindings_generated.cpp create mode 100644 web/filament-js/jsenums_generated.cpp diff --git a/filament/include/filament/Options.h b/filament/include/filament/Options.h index cc061c1225..39074cee58 100644 --- a/filament/include/filament/Options.h +++ b/filament/include/filament/Options.h @@ -125,13 +125,13 @@ struct BloomOptions { ADD, //!< Bloom is modulated by the strength parameter and added to the scene INTERPOLATE //!< Bloom is interpolated with the scene using the strength parameter }; - Texture* dirt = nullptr; //!< user provided dirt texture %codegen_skip_json% - float dirtStrength = 0.2f; //!< strength of the dirt texture %codegen_skip_json% + Texture* dirt = nullptr; //!< user provided dirt texture %codegen_skip_json% %codegen_skip_javascript% + float dirtStrength = 0.2f; //!< strength of the dirt texture %codegen_skip_json% %codegen_skip_javascript% float strength = 0.10f; //!< bloom's strength between 0.0 and 1.0 uint32_t resolution = 360; //!< resolution of vertical axis (2^levels to 2048) float anamorphism = 1.0f; //!< bloom x/y aspect-ratio (1/32 to 32) uint8_t levels = 6; //!< number of blur levels (3 to 11) - BlendMode blendMode = BlendMode::ADD; //!< how the bloom effect is applied + BlendMode blendMode = BloomOptions::BlendMode::ADD; //!< how the bloom effect is applied bool threshold = true; //!< whether to threshold the source bool enabled = false; //!< enable or disable bloom float highlight = 1000.0f; //!< limit highlights to this value before bloom [10, +inf] diff --git a/tools/codegen-options/README.md b/tools/codegen-options/README.md index e86c51cdc9..b0f40fb315 100644 --- a/tools/codegen-options/README.md +++ b/tools/codegen-options/README.md @@ -28,6 +28,7 @@ include: - If the default value of a field is a vector, it must be in the form: `{ x, y, z }`. - The type of every struct field must be specified without any whitespace (e.g. `Texture*`). - There must be no string literals that contain keywords. +- Enum names must be disambiguated when they appear in a struct field default value. If the comment for a struct field contains the string `%codegen_skip_json%`, then the field is skipped when generating JSON serialization code. diff --git a/tools/codegen-options/javascript.go b/tools/codegen-options/javascript.go index 3b1735a93f..c909b46177 100644 --- a/tools/codegen-options/javascript.go +++ b/tools/codegen-options/javascript.go @@ -21,15 +21,31 @@ import ( "log" "os" "path/filepath" + "strings" "text/template" ) func EmitJavaScript(definitions []Scope, outputFolder string) { + // These template extensions are used to transmogrify C++ symbols and value literals into + // JavaScript. We mostly don't need to do anything since the parser has already done some + // massaging and verification (e.g. it removed the trailing "f" from floating point literals). + // However enums need some special care here. Emscripten bindings are flat, so our own + // convention is to use $ for the scoping delimiter, which is a legal symbol character in JS. + // However we still use . to separate the enum value from the enum type, because emscripten has + // first-class support for class enums. customExtensions := template.FuncMap{ - "jsify": func(cppvalue string) string { - // Values are already massaged in the parsing phase, which is a better place than - // here since the parser can report the line number for unexpected syntax. - return cppvalue + "qualifiedtype": func(typename string) string { + typename = strings.ReplaceAll(typename, "::", "$") + return typename + }, + "qualifiedvalue": func(name string) string { + count := strings.Count(name, "::") + if count > 0 { + name = "Filament.View$" + name + } + name = strings.Replace(name, "::", "$", count-1) + name = strings.Replace(name, "::", ".", 1) + return name }, } diff --git a/tools/codegen-options/javascript.template b/tools/codegen-options/javascript.template index 15936e3695..8a92eead53 100644 --- a/tools/codegen-options/javascript.template +++ b/tools/codegen-options/javascript.template @@ -3,6 +3,8 @@ #include #include +#include + using namespace emscripten; using namespace filament; @@ -11,9 +13,13 @@ EMSCRIPTEN_BINDINGS(jsbindings_generated) { {{define "JsBindingsStruct"}} {{- $struct_name := .QualifiedName }} -value_object("View${{ $struct_name }}") +value_object("View${{ qualifiedtype .QualifiedName }}") {{- range $index, $field := .Fields}} +{{- if $field.SkipJavaScript}} + // JavaScript binding for {{$field.Name}} is not yet supported, must use default value. +{{- else }} .field("{{ $field.Name }}", &View::{{ $struct_name }}::{{ $field.Name }}) +{{- end }} {{- end }} ; {{end}} @@ -29,6 +35,8 @@ value_object("View${{ $struct_name }}") #include #include +#include + using namespace emscripten; using namespace filament; @@ -37,9 +45,9 @@ EMSCRIPTEN_BINDINGS(jsenums_generated) { {{define "JsEnum"}} {{- $enum_name := .QualifiedName }} -enum_("View${{ $enum_name }}") +enum_("View${{ qualifiedtype .QualifiedName }}") {{- range .Values}} - .value("{{ . }}", &View::{{ $enum_name }}::{{ . }}) + .value("{{ . }}", View::{{ $enum_name }}::{{ . }}) {{- end }} ; {{end}} @@ -62,7 +70,7 @@ Filament.loadGeneratedExtensions = function() { {{- if $field.SkipJavaScript}} // JavaScript binding for {{$field.Name}} is not yet supported, must use default value. {{- else }} - {{$field.Name}}: {{jsify $field.DefaultValue}}, + {{$field.Name}}: {{qualifiedvalue $field.DefaultValue}}, {{- end }} {{- end }} }; diff --git a/tools/codegen-options/parser.go b/tools/codegen-options/parser.go index 48fc4694d1..eba0f152ce 100644 --- a/tools/codegen-options/parser.go +++ b/tools/codegen-options/parser.go @@ -123,11 +123,6 @@ func (context parserContext) distillValue(cppvalue string, lineNumber int) strin } } - // Assume it's a enum in the View scope if there's a qualifier. - if strings.Contains(cppvalue, "::") { - cppvalue = "Filament.View" + strings.ReplaceAll(cppvalue, "::", "$") - } - if len(cppvalue) == 0 { log.Fatalf("%d: empty value specified", lineNumber) } diff --git a/web/filament-js/CMakeLists.txt b/web/filament-js/CMakeLists.txt index 9ecb9fe128..3b3740d2ba 100644 --- a/web/filament-js/CMakeLists.txt +++ b/web/filament-js/CMakeLists.txt @@ -4,12 +4,15 @@ project(filament-js) set(EXTERN_POSTJS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/wasmloader.js + ${CMAKE_CURRENT_SOURCE_DIR}/extensions_generated.js ${CMAKE_CURRENT_SOURCE_DIR}/extensions.js ${CMAKE_CURRENT_SOURCE_DIR}/utilities.js) set(CPP_SRC jsenums.cpp - jsbindings.cpp) + jsenums_generated.cpp + jsbindings.cpp + jsbindings_generated.cpp) # The emcc options are not documented well, the best place to find them is the source: # https://github.com/kripken/emscripten/blob/main/src/settings.js diff --git a/web/filament-js/extensions.js b/web/filament-js/extensions.js index ee7afc5ecd..cb8f3bb717 100644 --- a/web/filament-js/extensions.js +++ b/web/filament-js/extensions.js @@ -55,6 +55,8 @@ Filament.shadowOptions = function(overrides) { Filament.loadClassExtensions = function() { + Filament.loadGeneratedExtensions(); + /// Engine ::core class:: /// create ::static method:: Creates an Engine instance for the given canvas. @@ -268,149 +270,56 @@ Filament.loadClassExtensions = function() { }; /// setAmbientOcclusionOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// radius, power, bias, resolution, intensity, quality. Filament.View.prototype.setAmbientOcclusionOptions = function(overrides) { - const options = { - radius: 0.3, - power: 1.0, - bias: 0.0005, - resolution: 0.5, - intensity: 1.0, - quality: Filament.View$QualityLevel.LOW - }; - Object.assign(options, overrides); + const options = this.setAmbientOcclusionOptionsDefaults(overrides); this._setAmbientOcclusionOptions(options); }; /// setDepthOfFieldOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// cocScale, maxApertureDiameter, enabled. Filament.View.prototype.setDepthOfFieldOptions = function(overrides) { - const options = { - cocScale: 1.0, - maxApertureDiameter: 0.01, - enabled: false - }; - Object.assign(options, overrides); + const options = this.setDepthOfFieldOptionsDefaults(overrides); this._setDepthOfFieldOptions(options); }; /// setMultiSampleAntiAliasingOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// enabled, sampleCount, customResolve. Filament.View.prototype.setMultiSampleAntiAliasingOptions = function(overrides) { - const options = { - enabled: false, - sampleCount: 4, - customResolve: false - }; - Object.assign(options, overrides); + const options = this.setMultiSampleAntiAliasingOptionsDefaults(overrides); this._setMultiSampleAntiAliasingOptions(options); }; /// setTemporalAntiAliasingOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// filterWidth, feedback, enabled. Filament.View.prototype.setTemporalAntiAliasingOptions = function(overrides) { - const options = { - filterWidth: 1.0, - feedback: 0.04, - enabled: false - }; - Object.assign(options, overrides); + const options = this.setTemporalAntiAliasingOptionsDefaults(overrides); this._setTemporalAntiAliasingOptions(options); }; /// setScreenSpaceReflectionsOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// thickness, bias, maxDistance, stride, enabled. Filament.View.prototype.setScreenSpaceReflectionsOptions = function(overrides) { - const options = { - thickness: 0.5, - bias: 0.01, - maxDistance: 3.0, - stride: 1.0, - enabled: false - }; - Object.assign(options, overrides); + const options = this.setScreenSpaceReflectionsOptionsDefaults(overrides); this._setScreenSpaceReflectionsOptions(options); }; /// setBloomOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// enabled, strength, resolution, anomorphism, levels, blendMode, threshold, highlight. - /// NOTE: dirt texture is not yet supported in the JavaScript API. Filament.View.prototype.setBloomOptions = function(overrides) { - const options = { - dirtStrength: 0.2, - strength: 0.10, - resolution: 360, - anamorphism: 1.0, - levels: 6, - blendMode: Filament.View$BloomOptions$BlendMode.ADD, - threshold: true, - enabled: false, - highlight: 1000.0, - lensFlare: false, - starburst: true, - chromaticAberration: 0.005, - ghostCount: 4, - ghostSpacing: 0.6, - ghostThreshold: 10.0, - haloThickness: 0.1, - haloRadius: 0.4, - haloThreshold: 10.0, - dirt: null - }; - Object.assign(options, overrides); + const options = this.setBloomOptionsDefaults(overrides); this._setBloomOptions(options); }; /// setFogOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// distance, maximumOpacity, height, heightFalloff, color, density, inScatteringStart, - /// inScatteringSize, fogColorFromIbl, enabled. Filament.View.prototype.setFogOptions = function(overrides) { - const options = { - distance: 0.0, - maximumOpacity: 1.0, - height: 0.0, - heightFalloff: 1.0, - color: .5, - density: 0.1, - inScatteringStart: 0.0, - inScatteringSize: -1.0, - fogColorFromIbl: false, - enabled: false - }; - Object.assign(options, overrides); + const options = this.setFogOptionsDefaults(overrides); this._setFogOptions(options); }; /// setVignetteOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// midPoint, roundness, feather, color, enabled. Filament.View.prototype.setVignetteOptions = function(overrides) { - const options = { - midPoint: 0.5, - roundness: 0.5, - feather: 0.5, - color: [0, 0, 0, 1], - enabled: false - }; - Object.assign(options, overrides); + const options = this.setVignetteOptionsDefaults(overrides); this._setVignetteOptions(options); }; /// setGuardBandOptions ::method:: - /// overrides ::argument:: Dictionary with one or more of the following properties: \ - /// enabled. Filament.View.prototype.setGuardBandOptions = function(overrides) { - const options = { - enabled: false - }; - Object.assign(options, overrides); + const options = this.setGuardBandOptionsDefaults(overrides); this._setGuardBandOptions(options); }; diff --git a/web/filament-js/extensions_generated.js b/web/filament-js/extensions_generated.js new file mode 100644 index 0000000000..c28f6a31b3 --- /dev/null +++ b/web/filament-js/extensions_generated.js @@ -0,0 +1,181 @@ +// This file has been generated by codegen-options + +Filament.loadGeneratedExtensions = function() { + + Filament.View.prototype.setDynamicResolutionOptionsDefaults = function(overrides) { + const options = { + minScale: [ 0.5, 0.5 ], + maxScale: [ 1.0, 1.0 ], + sharpness: 0.9, + enabled: false, + homogeneousScaling: false, + quality: Filament.View$QualityLevel.LOW, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setBloomOptionsDefaults = function(overrides) { + const options = { + // JavaScript binding for dirt is not yet supported, must use default value. + // JavaScript binding for dirtStrength is not yet supported, must use default value. + strength: 0.10, + resolution: 360, + anamorphism: 1.0, + levels: 6, + blendMode: Filament.View$BloomOptions$BlendMode.ADD, + threshold: true, + enabled: false, + highlight: 1000.0, + lensFlare: false, + starburst: true, + chromaticAberration: 0.005, + ghostCount: 4, + ghostSpacing: 0.6, + ghostThreshold: 10.0, + haloThickness: 0.1, + haloRadius: 0.4, + haloThreshold: 10.0, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setFogOptionsDefaults = function(overrides) { + const options = { + distance: 0.0, + maximumOpacity: 1.0, + height: 0.0, + heightFalloff: 1.0, + color: [ 0.5, 0.5, 0.5 ], + density: 0.1, + inScatteringStart: 0.0, + inScatteringSize: -1.0, + fogColorFromIbl: false, + enabled: false, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setDepthOfFieldOptionsDefaults = function(overrides) { + const options = { + cocScale: 1.0, + maxApertureDiameter: 0.01, + enabled: false, + filter: Filament.View$Filter.MEDIAN, + nativeResolution: false, + foregroundRingCount: 0, + backgroundRingCount: 0, + fastGatherRingCount: 0, + maxForegroundCOC: 0, + maxBackgroundCOC: 0, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setVignetteOptionsDefaults = function(overrides) { + const options = { + midPoint: 0.5, + roundness: 0.5, + feather: 0.5, + color: [ 0.0, 0.0, 0.0, 1.0 ], + enabled: false, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setRenderQualityDefaults = function(overrides) { + const options = { + hdrColorBuffer: Filament.View$QualityLevel.HIGH, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setSsctDefaults = function(overrides) { + const options = { + lightConeRad: 1.0, + shadowDistance: 0.3, + contactDistanceMax: 1.0, + intensity: 0.8, + lightDirection: [ 0, -1, 0 ], + depthBias: 0.01, + depthSlopeBias: 0.01, + sampleCount: 4, + rayCount: 1, + enabled: false, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setAmbientOcclusionOptionsDefaults = function(overrides) { + const options = { + radius: 0.3, + power: 1.0, + bias: 0.0005, + resolution: 0.5, + intensity: 1.0, + bilateralThreshold: 0.05, + quality: Filament.View$QualityLevel.LOW, + lowPassFilter: Filament.View$QualityLevel.MEDIUM, + upsampling: Filament.View$QualityLevel.LOW, + enabled: false, + bentNormals: false, + minHorizonAngleRad: 0.0, + // JavaScript binding for ssct is not yet supported, must use default value. + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setMultiSampleAntiAliasingOptionsDefaults = function(overrides) { + const options = { + enabled: false, + sampleCount: 4, + customResolve: false, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setTemporalAntiAliasingOptionsDefaults = function(overrides) { + const options = { + filterWidth: 1.0, + feedback: 0.04, + enabled: false, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setScreenSpaceReflectionsOptionsDefaults = function(overrides) { + const options = { + thickness: 0.1, + bias: 0.01, + maxDistance: 3.0, + stride: 2.0, + enabled: false, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setGuardBandOptionsDefaults = function(overrides) { + const options = { + enabled: false, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setVsmShadowOptionsDefaults = function(overrides) { + const options = { + anisotropy: 0, + mipmapping: false, + minVarianceScale: 0.5, + lightBleedReduction: 0.15, + }; + return Object.assign(options, overrides); + }; + + Filament.View.prototype.setSoftShadowOptionsDefaults = function(overrides) { + const options = { + penumbraScale: 1.0, + penumbraRatioScale: 1.0, + }; + return Object.assign(options, overrides); + }; + +}; diff --git a/web/filament-js/jsbindings.cpp b/web/filament-js/jsbindings.cpp index 3d68e9ff5f..5f5defaf11 100644 --- a/web/filament-js/jsbindings.cpp +++ b/web/filament-js/jsbindings.cpp @@ -361,95 +361,6 @@ value_object("Renderer$ClearOptions") .field("clear", &filament::Renderer::ClearOptions::clear) .field("discard", &filament::Renderer::ClearOptions::discard); -value_object("View$AmbientOcclusionOptions") - .field("radius", &filament::View::AmbientOcclusionOptions::radius) - .field("power", &filament::View::AmbientOcclusionOptions::power) - .field("bias", &filament::View::AmbientOcclusionOptions::bias) - .field("resolution", &filament::View::AmbientOcclusionOptions::resolution) - .field("intensity", &filament::View::AmbientOcclusionOptions::intensity) - .field("bilateralThreshold", &filament::View::AmbientOcclusionOptions::bilateralThreshold) - .field("quality", &filament::View::AmbientOcclusionOptions::quality) - .field("lowPassFilter", &filament::View::AmbientOcclusionOptions::lowPassFilter) - .field("upsampling", &filament::View::AmbientOcclusionOptions::upsampling) - .field("enabled", &filament::View::AmbientOcclusionOptions::enabled) - .field("bentNormals", &filament::View::AmbientOcclusionOptions::bentNormals) - .field("minHorizonAngleRad", &filament::View::AmbientOcclusionOptions::minHorizonAngleRad); - // TODO: ssct options - -value_object("View$DepthOfFieldOptions") - .field("cocScale", &filament::View::DepthOfFieldOptions::cocScale) - .field("maxApertureDiameter", &filament::View::DepthOfFieldOptions::maxApertureDiameter) - .field("enabled", &filament::View::DepthOfFieldOptions::enabled) - .field("filter", &filament::View::DepthOfFieldOptions::filter) - .field("nativeResolution", &filament::View::DepthOfFieldOptions::nativeResolution) - .field("foregroundRingCount", &filament::View::DepthOfFieldOptions::foregroundRingCount) - .field("backgroundRingCount", &filament::View::DepthOfFieldOptions::backgroundRingCount) - .field("fastGatherRingCount", &filament::View::DepthOfFieldOptions::fastGatherRingCount) - .field("maxForegroundCOC", &filament::View::DepthOfFieldOptions::maxForegroundCOC) - .field("maxBackgroundCOC", &filament::View::DepthOfFieldOptions::maxBackgroundCOC); - -value_object("View$MultiSampleAntiAliasingOptions") - .field("enabled", &filament::View::MultiSampleAntiAliasingOptions::enabled) - .field("sampleCount", &filament::View::MultiSampleAntiAliasingOptions::sampleCount) - .field("customResolve", &filament::View::MultiSampleAntiAliasingOptions::customResolve); - -value_object("View$TemporalAntiAliasingOptions") - .field("enabled", &filament::View::TemporalAntiAliasingOptions::enabled) - .field("filterWidth", &filament::View::TemporalAntiAliasingOptions::filterWidth) - .field("feedback", &filament::View::TemporalAntiAliasingOptions::feedback); - -value_object("View$ScreenSpaceReflectionsOptions") - .field("thickness", &filament::View::ScreenSpaceReflectionsOptions::thickness) - .field("bias", &filament::View::ScreenSpaceReflectionsOptions::bias) - .field("maxDistance", &filament::View::ScreenSpaceReflectionsOptions::maxDistance) - .field("stride", &filament::View::ScreenSpaceReflectionsOptions::stride) - .field("enabled", &filament::View::ScreenSpaceReflectionsOptions::enabled); - -value_object("View$BloomOptions") - .field("dirtStrength", &filament::View::BloomOptions::dirtStrength) - .field("strength", &filament::View::BloomOptions::strength) - .field("resolution", &filament::View::BloomOptions::resolution) - .field("anamorphism", &filament::View::BloomOptions::anamorphism) - .field("levels", &filament::View::BloomOptions::levels) - .field("threshold", &filament::View::BloomOptions::threshold) - .field("enabled", &filament::View::BloomOptions::enabled) - .field("blendMode", &filament::View::BloomOptions::blendMode) - .field("highlight", &filament::View::BloomOptions::highlight) - .field("lensFlare", &filament::View::BloomOptions::lensFlare) - .field("starburst", &filament::View::BloomOptions::starburst) - .field("chromaticAberration", &filament::View::BloomOptions::chromaticAberration) - .field("ghostCount", &filament::View::BloomOptions::ghostCount) - .field("ghostSpacing", &filament::View::BloomOptions::ghostSpacing) - .field("ghostThreshold", &filament::View::BloomOptions::ghostThreshold) - .field("haloThickness", &filament::View::BloomOptions::haloThickness) - .field("haloRadius", &filament::View::BloomOptions::haloRadius) - .field("haloThreshold", &filament::View::BloomOptions::haloThreshold); - -// TODO: add support for dirt texture in BloomOptions. -// Note that simply including the field in the above list causes binding errors for nullptr. - -value_object("View$FogOptions") - .field("distance", &filament::View::FogOptions::distance) - .field("maximumOpacity", &filament::View::FogOptions::maximumOpacity) - .field("height", &filament::View::FogOptions::height) - .field("heightFalloff", &filament::View::FogOptions::heightFalloff) - .field("color", &filament::View::FogOptions::color) - .field("density", &filament::View::FogOptions::density) - .field("inScatteringStart", &filament::View::FogOptions::inScatteringStart) - .field("inScatteringSize", &filament::View::FogOptions::inScatteringSize) - .field("fogColorFromIbl", &filament::View::FogOptions::fogColorFromIbl) - .field("enabled", &filament::View::FogOptions::enabled); - -value_object("View$VignetteOptions") - .field("midPoint", &filament::View::VignetteOptions::midPoint) - .field("roundness", &filament::View::VignetteOptions::roundness) - .field("feather", &filament::View::VignetteOptions::feather) - .field("color", &filament::View::VignetteOptions::color) - .field("enabled", &filament::View::VignetteOptions::enabled); - -value_object("View$GuardBandOptions") - .field("enabled", &filament::View::GuardBandOptions::enabled); - value_object("LightManager$ShadowOptions") .field("mapSize", &LightManager::ShadowOptions::mapSize) .field("shadowCascades", &LightManager::ShadowOptions::shadowCascades) diff --git a/web/filament-js/jsbindings_generated.cpp b/web/filament-js/jsbindings_generated.cpp new file mode 100644 index 0000000000..b60a6877e5 --- /dev/null +++ b/web/filament-js/jsbindings_generated.cpp @@ -0,0 +1,147 @@ +// This file has been generated by codegen-options + +#include +#include + +#include + +using namespace emscripten; +using namespace filament; + +EMSCRIPTEN_BINDINGS(jsbindings_generated) { + +value_object("View$DynamicResolutionOptions") + .field("minScale", &View::DynamicResolutionOptions::minScale) + .field("maxScale", &View::DynamicResolutionOptions::maxScale) + .field("sharpness", &View::DynamicResolutionOptions::sharpness) + .field("enabled", &View::DynamicResolutionOptions::enabled) + .field("homogeneousScaling", &View::DynamicResolutionOptions::homogeneousScaling) + .field("quality", &View::DynamicResolutionOptions::quality) + ; + +value_object("View$BloomOptions") + // JavaScript binding for dirt is not yet supported, must use default value. + // JavaScript binding for dirtStrength is not yet supported, must use default value. + .field("strength", &View::BloomOptions::strength) + .field("resolution", &View::BloomOptions::resolution) + .field("anamorphism", &View::BloomOptions::anamorphism) + .field("levels", &View::BloomOptions::levels) + .field("blendMode", &View::BloomOptions::blendMode) + .field("threshold", &View::BloomOptions::threshold) + .field("enabled", &View::BloomOptions::enabled) + .field("highlight", &View::BloomOptions::highlight) + .field("lensFlare", &View::BloomOptions::lensFlare) + .field("starburst", &View::BloomOptions::starburst) + .field("chromaticAberration", &View::BloomOptions::chromaticAberration) + .field("ghostCount", &View::BloomOptions::ghostCount) + .field("ghostSpacing", &View::BloomOptions::ghostSpacing) + .field("ghostThreshold", &View::BloomOptions::ghostThreshold) + .field("haloThickness", &View::BloomOptions::haloThickness) + .field("haloRadius", &View::BloomOptions::haloRadius) + .field("haloThreshold", &View::BloomOptions::haloThreshold) + ; + +value_object("View$FogOptions") + .field("distance", &View::FogOptions::distance) + .field("maximumOpacity", &View::FogOptions::maximumOpacity) + .field("height", &View::FogOptions::height) + .field("heightFalloff", &View::FogOptions::heightFalloff) + .field("color", &View::FogOptions::color) + .field("density", &View::FogOptions::density) + .field("inScatteringStart", &View::FogOptions::inScatteringStart) + .field("inScatteringSize", &View::FogOptions::inScatteringSize) + .field("fogColorFromIbl", &View::FogOptions::fogColorFromIbl) + .field("enabled", &View::FogOptions::enabled) + ; + +value_object("View$DepthOfFieldOptions") + .field("cocScale", &View::DepthOfFieldOptions::cocScale) + .field("maxApertureDiameter", &View::DepthOfFieldOptions::maxApertureDiameter) + .field("enabled", &View::DepthOfFieldOptions::enabled) + .field("filter", &View::DepthOfFieldOptions::filter) + .field("nativeResolution", &View::DepthOfFieldOptions::nativeResolution) + .field("foregroundRingCount", &View::DepthOfFieldOptions::foregroundRingCount) + .field("backgroundRingCount", &View::DepthOfFieldOptions::backgroundRingCount) + .field("fastGatherRingCount", &View::DepthOfFieldOptions::fastGatherRingCount) + .field("maxForegroundCOC", &View::DepthOfFieldOptions::maxForegroundCOC) + .field("maxBackgroundCOC", &View::DepthOfFieldOptions::maxBackgroundCOC) + ; + +value_object("View$VignetteOptions") + .field("midPoint", &View::VignetteOptions::midPoint) + .field("roundness", &View::VignetteOptions::roundness) + .field("feather", &View::VignetteOptions::feather) + .field("color", &View::VignetteOptions::color) + .field("enabled", &View::VignetteOptions::enabled) + ; + +value_object("View$RenderQuality") + .field("hdrColorBuffer", &View::RenderQuality::hdrColorBuffer) + ; + +value_object("View$AmbientOcclusionOptions$Ssct") + .field("lightConeRad", &View::AmbientOcclusionOptions::Ssct::lightConeRad) + .field("shadowDistance", &View::AmbientOcclusionOptions::Ssct::shadowDistance) + .field("contactDistanceMax", &View::AmbientOcclusionOptions::Ssct::contactDistanceMax) + .field("intensity", &View::AmbientOcclusionOptions::Ssct::intensity) + .field("lightDirection", &View::AmbientOcclusionOptions::Ssct::lightDirection) + .field("depthBias", &View::AmbientOcclusionOptions::Ssct::depthBias) + .field("depthSlopeBias", &View::AmbientOcclusionOptions::Ssct::depthSlopeBias) + .field("sampleCount", &View::AmbientOcclusionOptions::Ssct::sampleCount) + .field("rayCount", &View::AmbientOcclusionOptions::Ssct::rayCount) + .field("enabled", &View::AmbientOcclusionOptions::Ssct::enabled) + ; + +value_object("View$AmbientOcclusionOptions") + .field("radius", &View::AmbientOcclusionOptions::radius) + .field("power", &View::AmbientOcclusionOptions::power) + .field("bias", &View::AmbientOcclusionOptions::bias) + .field("resolution", &View::AmbientOcclusionOptions::resolution) + .field("intensity", &View::AmbientOcclusionOptions::intensity) + .field("bilateralThreshold", &View::AmbientOcclusionOptions::bilateralThreshold) + .field("quality", &View::AmbientOcclusionOptions::quality) + .field("lowPassFilter", &View::AmbientOcclusionOptions::lowPassFilter) + .field("upsampling", &View::AmbientOcclusionOptions::upsampling) + .field("enabled", &View::AmbientOcclusionOptions::enabled) + .field("bentNormals", &View::AmbientOcclusionOptions::bentNormals) + .field("minHorizonAngleRad", &View::AmbientOcclusionOptions::minHorizonAngleRad) + // JavaScript binding for ssct is not yet supported, must use default value. + ; + +value_object("View$MultiSampleAntiAliasingOptions") + .field("enabled", &View::MultiSampleAntiAliasingOptions::enabled) + .field("sampleCount", &View::MultiSampleAntiAliasingOptions::sampleCount) + .field("customResolve", &View::MultiSampleAntiAliasingOptions::customResolve) + ; + +value_object("View$TemporalAntiAliasingOptions") + .field("filterWidth", &View::TemporalAntiAliasingOptions::filterWidth) + .field("feedback", &View::TemporalAntiAliasingOptions::feedback) + .field("enabled", &View::TemporalAntiAliasingOptions::enabled) + ; + +value_object("View$ScreenSpaceReflectionsOptions") + .field("thickness", &View::ScreenSpaceReflectionsOptions::thickness) + .field("bias", &View::ScreenSpaceReflectionsOptions::bias) + .field("maxDistance", &View::ScreenSpaceReflectionsOptions::maxDistance) + .field("stride", &View::ScreenSpaceReflectionsOptions::stride) + .field("enabled", &View::ScreenSpaceReflectionsOptions::enabled) + ; + +value_object("View$GuardBandOptions") + .field("enabled", &View::GuardBandOptions::enabled) + ; + +value_object("View$VsmShadowOptions") + .field("anisotropy", &View::VsmShadowOptions::anisotropy) + .field("mipmapping", &View::VsmShadowOptions::mipmapping) + .field("minVarianceScale", &View::VsmShadowOptions::minVarianceScale) + .field("lightBleedReduction", &View::VsmShadowOptions::lightBleedReduction) + ; + +value_object("View$SoftShadowOptions") + .field("penumbraScale", &View::SoftShadowOptions::penumbraScale) + .field("penumbraRatioScale", &View::SoftShadowOptions::penumbraRatioScale) + ; + +} // EMSCRIPTEN_BINDINGS diff --git a/web/filament-js/jsenums.cpp b/web/filament-js/jsenums.cpp index 7b4ccf6382..7b62b0f303 100644 --- a/web/filament-js/jsenums.cpp +++ b/web/filament-js/jsenums.cpp @@ -123,33 +123,10 @@ enum_("RenderableManager$PrimitiveType") .value("TRIANGLE_STRIP", RenderableManager::PrimitiveType::TRIANGLE_STRIP) .value("NONE", RenderableManager::PrimitiveType::NONE); -enum_("View$QualityLevel") - .value("LOW", View::QualityLevel::LOW) - .value("MEDIUM", View::QualityLevel::MEDIUM) - .value("HIGH", View::QualityLevel::HIGH) - .value("ULTRA", View::QualityLevel::ULTRA); - enum_("View$AmbientOcclusion") .value("NONE", View::AmbientOcclusion::NONE) .value("SSAO", View::AmbientOcclusion::SSAO); -enum_("View$BlendMode") - .value("OPAQUE", View::BlendMode::OPAQUE) - .value("TRANSLUCENT", View::BlendMode::TRANSLUCENT); - -enum_("View$BloomOptions$BlendMode") - .value("ADD", View::BloomOptions::BlendMode::ADD) - .value("INTERPOLATE", View::BloomOptions::BlendMode::INTERPOLATE); - -enum_("View$AntiAliasing") - .value("NONE", View::AntiAliasing::NONE) - .value("FXAA", View::AntiAliasing::FXAA); - -enum_("View$DepthOfFieldOptions$Filter") - .value("NONE", View::DepthOfFieldOptions::Filter::NONE) - .value("UNUSED", View::DepthOfFieldOptions::Filter::UNUSED) - .value("MEDIAN", View::DepthOfFieldOptions::Filter::MEDIAN); - enum_("Camera$Fov") .value("VERTICAL", Camera::Fov::VERTICAL) .value("HORIZONTAL", Camera::Fov::HORIZONTAL); diff --git a/web/filament-js/jsenums_generated.cpp b/web/filament-js/jsenums_generated.cpp new file mode 100644 index 0000000000..4d326c465c --- /dev/null +++ b/web/filament-js/jsenums_generated.cpp @@ -0,0 +1,53 @@ +// This file has been generated by codegen-options + +#include +#include + +#include + +using namespace emscripten; +using namespace filament; + +EMSCRIPTEN_BINDINGS(jsenums_generated) { + +enum_("View$QualityLevel") + .value("LOW", View::QualityLevel::LOW) + .value("MEDIUM", View::QualityLevel::MEDIUM) + .value("HIGH", View::QualityLevel::HIGH) + .value("ULTRA", View::QualityLevel::ULTRA) + ; + +enum_("View$BlendMode") + .value("OPAQUE", View::BlendMode::OPAQUE) + .value("TRANSLUCENT", View::BlendMode::TRANSLUCENT) + ; + +enum_("View$BloomOptions$BlendMode") + .value("ADD", View::BloomOptions::BlendMode::ADD) + .value("INTERPOLATE", View::BloomOptions::BlendMode::INTERPOLATE) + ; + +enum_("View$DepthOfFieldOptions$Filter") + .value("NONE", View::DepthOfFieldOptions::Filter::NONE) + .value("UNUSED", View::DepthOfFieldOptions::Filter::UNUSED) + .value("MEDIAN", View::DepthOfFieldOptions::Filter::MEDIAN) + ; + +enum_("View$AntiAliasing") + .value("NONE", View::AntiAliasing::NONE) + .value("FXAA", View::AntiAliasing::FXAA) + ; + +enum_("View$Dithering") + .value("NONE", View::Dithering::NONE) + .value("TEMPORAL", View::Dithering::TEMPORAL) + ; + +enum_("View$ShadowType") + .value("PCF", View::ShadowType::PCF) + .value("VSM", View::ShadowType::VSM) + .value("DPCF", View::ShadowType::DPCF) + .value("PCSS", View::ShadowType::PCSS) + ; + +} // EMSCRIPTEN_BINDINGS