History

Merge remote-tracking branch 'overte/master' into application

HifiExperiments committed 1 year ago

Commit d6d9cff2 parents 343a8ac 09f8d07201 files · +4933 −2209Browse files

Showing the changes to interface/src/scripting/RenderScriptingInterface.cpp (1 of 201 files). Show all

Unified · Split

interface/src/scripting/RenderScriptingInterface.cpp+57−36
@@ -25,14 +25,14 @@ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){ · 24 unmodified lines
2525 auto scriptEngine = manager->engine().get();
2626
2727 scriptRegisterMetaType<RenderScriptingInterface::RenderMethod, scriptValueFromEnumClass<RenderScriptingInterface::RenderMethod>, scriptValueToEnumClass<RenderScriptingInterface::RenderMethod> >(scriptEngine, "RenderMethod");
28− scriptRegisterMetaType<AntialiasingConfig::Mode, scriptValueFromEnumClass<AntialiasingConfig::Mode>, scriptValueToEnumClass<AntialiasingConfig::Mode> >(scriptEngine, "Mode");
28+ scriptRegisterMetaType<AntialiasingSetupConfig::Mode, scriptValueFromEnumClass<AntialiasingSetupConfig::Mode>, scriptValueToEnumClass<AntialiasingSetupConfig::Mode> >(scriptEngine, "Mode");
2929 }));
3030
3131 STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
3232 auto scriptEngine = manager->engine().get();
3333
3434 scriptEngine->registerEnum("Render.RenderMethod",QMetaEnum::fromType<RenderScriptingInterface::RenderMethod>());
35− scriptEngine->registerEnum("AntialiasingMode",QMetaEnum::fromType<AntialiasingConfig::Mode>());
35+ scriptEngine->registerEnum("AntialiasingMode",QMetaEnum::fromType<AntialiasingSetupConfig::Mode>());
3636 });
3737
3838 RenderScriptingInterface* RenderScriptingInterface::getInstance() {
@@ -56,7 +56,7 @@ void RenderScriptingInterface::loadSettings() { · 17 unmodified lines
5656 _bloomEnabled = _bloomEnabledSetting.get();
5757 _ambientOcclusionEnabled = _ambientOcclusionEnabledSetting.get();
5858 _proceduralMaterialsEnabled = _proceduralMaterialsEnabledSetting.get();
59− _antialiasingMode = static_cast<AntialiasingConfig::Mode>(_antialiasingModeSetting.get());
59+ _antialiasingMode = static_cast<AntialiasingSetupConfig::Mode>(_antialiasingModeSetting.get());
6060 _viewportResolutionScale = _viewportResolutionScaleSetting.get();
6161 _fullScreenScreen = _fullScreenScreenSetting.get();
6262 });
@@ -95,9 +95,10 @@ void recursivelyUpdateMirrorRenderMethods(const QString& parentTaskName, int ren · 32 unmodified lines
9595 return;
9696 }
9797
98+ auto renderConfig = qApp->getRenderEngine()->getConfiguration();
9899 for (size_t mirrorIndex = 0; mirrorIndex < RenderMirrorTask::MAX_MIRRORS_PER_LEVEL; mirrorIndex++) {
99100 std::string mirrorTaskString = parentTaskName.toStdString() + ".RenderMirrorView" + std::to_string(mirrorIndex) + "Depth" + std::to_string(depth) + ".DeferredForwardSwitch";
100− auto mirrorConfig = dynamic_cast<render::SwitchConfig*>(qApp->getRenderEngine()->getConfiguration()->getConfig(QString::fromStdString(mirrorTaskString)));
101+ auto mirrorConfig = dynamic_cast<render::SwitchConfig*>(renderConfig->getConfig(QString::fromStdString(mirrorTaskString)));
101102 if (mirrorConfig) {
102103 mirrorConfig->setBranch((int)renderMethod);
103104 recursivelyUpdateMirrorRenderMethods(QString::fromStdString(mirrorTaskString) + (renderMethod == 1 ? ".RenderForwardTask" : ".RenderShadowsAndDeferredTask.RenderDeferredTask"),
@@ -111,14 +112,20 @@ void RenderScriptingInterface::forceRenderMethod(RenderMethod renderMethod) { · 7 unmodified lines
111112 _renderMethod = (int)renderMethod;
112113 _renderMethodSetting.set((int)renderMethod);
113114
115+ auto renderConfig = qApp->getRenderEngine()->getConfiguration();
114116 QString configName = "RenderMainView.DeferredForwardSwitch";
115− auto config = dynamic_cast<render::SwitchConfig*>(qApp->getRenderEngine()->getConfiguration()->getConfig(configName));
117+ auto config = dynamic_cast<render::SwitchConfig*>(renderConfig->getConfig(configName));
116118 if (config) {
117119 config->setBranch((int)renderMethod);
118120
119121 recursivelyUpdateMirrorRenderMethods(configName + (renderMethod == RenderMethod::FORWARD ? ".RenderForwardTask" : ".RenderShadowsAndDeferredTask.RenderDeferredTask"),
120122 (int)renderMethod, 0);
121123 }
124+
125+ auto secondaryConfig = dynamic_cast<render::SwitchConfig*>(renderConfig->getConfig("RenderSecondView.DeferredForwardSwitch"));
126+ if (secondaryConfig) {
127+ secondaryConfig->setBranch((int)renderMethod);
128+ }
122129 });
123130 }
124131
@@ -128,13 +135,14 @@ QStringList RenderScriptingInterface::getRenderMethodNames() const { · 3 unmodified lines
128135 }
129136
130137 void recursivelyUpdateLightingModel(const QString& parentTaskName, std::function<void(MakeLightingModelConfig *)> updateLambda, int depth = -1) {
138+ auto renderConfig = qApp->getRenderEngine()->getConfiguration();
131139 if (depth == -1) {
132− auto secondaryLightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<MakeLightingModel>("RenderSecondView.LightingModel");
140+ auto secondaryLightingModelConfig = renderConfig->getConfig<MakeLightingModel>("RenderSecondView.LightingModel");
133141 if (secondaryLightingModelConfig) {
134142 updateLambda(secondaryLightingModelConfig);
135143 }
136144
137− auto mainLightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
145+ auto mainLightingModelConfig = renderConfig->getConfig<MakeLightingModel>("RenderMainView.LightingModel");
138146 if (mainLightingModelConfig) {
139147 updateLambda(mainLightingModelConfig);
140148 }
@@ -146,7 +154,7 @@ void recursivelyUpdateLightingModel(const QString& parentTaskName, std::function · 5 unmodified lines
146154
147155 for (size_t mirrorIndex = 0; mirrorIndex < RenderMirrorTask::MAX_MIRRORS_PER_LEVEL; mirrorIndex++) {
148156 std::string mirrorTaskString = parentTaskName.toStdString() + ".RenderMirrorView" + std::to_string(mirrorIndex) + "Depth" + std::to_string(depth);
149− auto lightingModelConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<MakeLightingModel>(mirrorTaskString + ".LightingModel");
157+ auto lightingModelConfig = renderConfig->getConfig<MakeLightingModel>(mirrorTaskString + ".LightingModel");
150158 if (lightingModelConfig) {
151159 updateLambda(lightingModelConfig);
152160 recursivelyUpdateLightingModel(QString::fromStdString(mirrorTaskString), updateLambda, depth + 1);
@@ -169,7 +177,6 @@ void RenderScriptingInterface::forceShadowsEnabled(bool enabled) { · 16 unmodified lines
169177 _renderSettingLock.withWriteLock([&] {
170178 _shadowsEnabled = (enabled);
171179 _shadowsEnabledSetting.set(enabled);
172−
173180 Menu::getInstance()->setIsOptionChecked(MenuOption::Shadows, enabled);
174181
175182 recursivelyUpdateLightingModel("", [enabled] (MakeLightingModelConfig *config) { config->setShadow(enabled); });
@@ -231,7 +238,6 @@ void RenderScriptingInterface::forceAmbientOcclusionEnabled(bool enabled) { · 55 unmodified lines
231238 _renderSettingLock.withWriteLock([&] {
232239 _ambientOcclusionEnabled = (enabled);
233240 _ambientOcclusionEnabledSetting.set(enabled);
234−
235241 Menu::getInstance()->setIsOptionChecked(MenuOption::AmbientOcclusion, enabled);
236242
237243 recursivelyUpdateLightingModel("", [enabled] (MakeLightingModelConfig *config) { config->setAmbientOcclusion(enabled); });
@@ -259,52 +265,53 @@ void RenderScriptingInterface::forceProceduralMaterialsEnabled(bool enabled) { · 21 unmodified lines
259265 });
260266 }
261267
262−AntialiasingConfig::Mode RenderScriptingInterface::getAntialiasingMode() const {
268+AntialiasingSetupConfig::Mode RenderScriptingInterface::getAntialiasingMode() const {
263269 return _antialiasingMode;
264270 }
265271
266−void RenderScriptingInterface::setAntialiasingMode(AntialiasingConfig::Mode mode) {
272+void RenderScriptingInterface::setAntialiasingMode(AntialiasingSetupConfig::Mode mode) {
267273 if (_antialiasingMode != mode) {
268274 forceAntialiasingMode(mode);
269275 emit settingsChanged();
270276 }
271277 }
272278
273−void setAntialiasingModeForView(AntialiasingConfig::Mode mode, JitterSampleConfig *jitterCamConfig, AntialiasingConfig *antialiasingConfig) {
279+void setAntialiasingModeForView(AntialiasingSetupConfig::Mode mode, AntialiasingSetupConfig *antialiasingSetupConfig, AntialiasingConfig *antialiasingConfig) {
274280 switch (mode) {
275− case AntialiasingConfig::Mode::NONE:
276− jitterCamConfig->none();
281+ case AntialiasingSetupConfig::Mode::NONE:
282+ antialiasingSetupConfig->none();
277283 antialiasingConfig->blend = 1;
278284 antialiasingConfig->setDebugFXAA(false);
279285 break;
280− case AntialiasingConfig::Mode::TAA:
281− jitterCamConfig->play();
286+ case AntialiasingSetupConfig::Mode::TAA:
287+ antialiasingSetupConfig->play();
282288 antialiasingConfig->blend = 0.25;
283289 antialiasingConfig->setDebugFXAA(false);
284290 break;
285− case AntialiasingConfig::Mode::FXAA:
286− jitterCamConfig->none();
291+ case AntialiasingSetupConfig::Mode::FXAA:
292+ antialiasingSetupConfig->none();
287293 antialiasingConfig->blend = 0.25;
288294 antialiasingConfig->setDebugFXAA(true);
289295 break;
290296 default:
291− jitterCamConfig->none();
297+ antialiasingSetupConfig->none();
292298 antialiasingConfig->blend = 1;
293299 antialiasingConfig->setDebugFXAA(false);
294300 break;
295301 }
296302 }
297303
298−void recursivelyUpdateAntialiasingMode(const QString& parentTaskName, AntialiasingConfig::Mode mode, int depth = -1) {
304+void recursivelyUpdateAntialiasingMode(const QString& parentTaskName, AntialiasingSetupConfig::Mode mode, int depth = -1) {
305+ auto renderConfig = qApp->getRenderEngine()->getConfiguration();
299306 if (depth == -1) {
300− auto secondViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderSecondView.JitterCam");
301− auto secondViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderSecondView.Antialiasing");
307+ auto secondViewJitterCamConfig = renderConfig->getConfig<AntialiasingSetup>("RenderSecondView.AntialiasingSetup");
308+ auto secondViewAntialiasingConfig = renderConfig->getConfig<Antialiasing>("RenderSecondView.Antialiasing");
302309 if (secondViewJitterCamConfig && secondViewAntialiasingConfig) {
303310 setAntialiasingModeForView(mode, secondViewJitterCamConfig, secondViewAntialiasingConfig);
304311 }
305312
306− auto mainViewJitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>("RenderMainView.JitterCam");
307− auto mainViewAntialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>("RenderMainView.Antialiasing");
313+ auto mainViewJitterCamConfig = renderConfig->getConfig<AntialiasingSetup>("RenderMainView.AntialiasingSetup");
314+ auto mainViewAntialiasingConfig = renderConfig->getConfig<Antialiasing>("RenderMainView.Antialiasing");
308315 if (mainViewJitterCamConfig && mainViewAntialiasingConfig) {
309316 setAntialiasingModeForView( mode, mainViewJitterCamConfig, mainViewAntialiasingConfig);
310317 }
@@ -316,8 +323,8 @@ void recursivelyUpdateAntialiasingMode(const QString& parentTaskName, Antialiasi · 5 unmodified lines
316323
317324 for (size_t mirrorIndex = 0; mirrorIndex < RenderMirrorTask::MAX_MIRRORS_PER_LEVEL; mirrorIndex++) {
318325 std::string mirrorTaskString = parentTaskName.toStdString() + ".RenderMirrorView" + std::to_string(mirrorIndex) + "Depth" + std::to_string(depth);
319− auto jitterCamConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<JitterSample>(mirrorTaskString + ".JitterCam");
320− auto antialiasingConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<Antialiasing>(mirrorTaskString + ".Antialiasing");
326+ auto jitterCamConfig = renderConfig->getConfig<AntialiasingSetup>(mirrorTaskString + ".AntialiasingSetup");
327+ auto antialiasingConfig = renderConfig->getConfig<Antialiasing>(mirrorTaskString + ".Antialiasing");
321328 if (jitterCamConfig && antialiasingConfig) {
322329 setAntialiasingModeForView(mode, jitterCamConfig, antialiasingConfig);
323330 recursivelyUpdateAntialiasingMode(QString::fromStdString(mirrorTaskString), mode, depth + 1);
@@ -325,14 +332,14 @@ void recursivelyUpdateAntialiasingMode(const QString& parentTaskName, Antialiasi · 1 unmodified line
325332 }
326333 }
327334
328−void RenderScriptingInterface::forceAntialiasingMode(AntialiasingConfig::Mode mode) {
329− if ((int)mode < 0 || mode >= AntialiasingConfig::Mode::MODE_COUNT) {
330− mode = AntialiasingConfig::Mode::NONE;
335+void RenderScriptingInterface::forceAntialiasingMode(AntialiasingSetupConfig::Mode mode) {
336+ if ((int)mode < 0 || mode >= AntialiasingSetupConfig::Mode::MODE_COUNT) {
337+ mode = AntialiasingSetupConfig::Mode::NONE;
331338 }
332339
333340 _renderSettingLock.withWriteLock([&] {
334341 _antialiasingMode = mode;
335− _antialiasingModeSetting.set(_antialiasingMode);
342+ _antialiasingModeSetting.set((int)_antialiasingMode);
336343
337344 recursivelyUpdateAntialiasingMode("", _antialiasingMode);
338345 });
@@ -345,6 +352,13 @@ void RenderScriptingInterface::setVerticalFieldOfView(float fieldOfView) { · 6 unmodified lines
345352 }
346353 }
347354
355+void RenderScriptingInterface::setCameraClippingEnabled(bool enabled) {
356+ if (qApp->getCameraClippingEnabled() != enabled) {
357+ qApp->setCameraClippingEnabled(enabled);
358+ emit settingsChanged();
359+ }
360+}
361+
348362 QStringList RenderScriptingInterface::getScreens() const {
349363 QStringList screens;
350364
@@ -396,20 +410,27 @@ void RenderScriptingInterface::forceViewportResolutionScale(float scale) { · 45 unmodified lines
396410 return;
397411 }
398412 _renderSettingLock.withWriteLock([&] {
399− _viewportResolutionScale = (scale);
413+ _viewportResolutionScale = scale;
400414 _viewportResolutionScaleSetting.set(scale);
401415
402416 auto renderConfig = qApp->getRenderEngine()->getConfiguration();
403417 assert(renderConfig);
404418 auto deferredView = renderConfig->getConfig("RenderMainView.RenderDeferredTask");
405− // mainView can be null if we're rendering in forward mode
406419 if (deferredView) {
407− deferredView->setProperty("resolutionScale", _viewportResolutionScale);
420+ deferredView->setProperty("resolutionScale", scale);
408421 }
409422 auto forwardView = renderConfig->getConfig("RenderMainView.RenderForwardTask");
410− // mainView can be null if we're rendering in forward mode
411423 if (forwardView) {
412− forwardView->setProperty("resolutionScale", _viewportResolutionScale);
424+ forwardView->setProperty("resolutionScale", scale);
425+ }
426+
427+ auto deferredSecondView = renderConfig->getConfig("RenderSecondView.RenderDeferredTask");
428+ if (deferredSecondView) {
429+ deferredSecondView->setProperty("resolutionScale", scale);
430+ }
431+ auto forwardSecondView = renderConfig->getConfig("RenderSecondView.RenderForwardTask");
432+ if (forwardSecondView) {
433+ forwardSecondView->setProperty("resolutionScale", scale);
413434 }
414435 });
415436 }