--- /dev/null
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali-scene3d/dali-scene3d.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+#include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
+#include <dali/devel-api/actors/actor-devel.h>
+
+// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/file-stream.h>
+
+using namespace Dali;
+using namespace Toolkit;
+using namespace Scene3D;
+
+namespace
+{
+const char* CUBEMAP_SKY_BOX_URL = DEMO_IMAGE_DIR "veste_oberhaus_cubemap.png";
+const char* CUBEMAP_IRRADIANCE_URL = DEMO_IMAGE_DIR "veste_oberhaus_irradiance.png";
+const char* CAMERA_NAME("MyCamera");
+
+const char* MODEL_URL = DEMO_MODEL_DIR "SphereMetallic.gltf";
+constexpr Vector3 MODEL_SIZE(300.0f, 300.0f, 300.0f);
+const char* SUB_MODEL_URL = DEMO_MODEL_DIR "Duck.gltf";
+constexpr Vector3 SUB_MODEL_SIZE(300.0f, 300.0f, 300.0f);
+constexpr Vector3 SUB_MODEL_SCALE(1.2f, 0.6f, 1.0f);
+
+constexpr Vector4 ORIGINAL_BASE_COLOR_FACTOR(0.6039215686274509f, 0.6039215686274509f, 0.6039215686274509f, 1.0f);
+constexpr Vector3 ORIGINAL_EMISSIVE_FACTOR(0.0f, 0.0f, 0.0f);
+constexpr float ORIGINAL_METALLIC_FACTOR(1.0f);
+constexpr float ORIGINAL_ROUGHNESS_FACTOR(0.0f);
+
+constexpr Vector4 ORIGINAL_SUB_BASE_COLOR_FACTOR(1.0f, 1.0f, 1.0f, 1.0f);
+constexpr Vector3 ORIGINAL_SUB_EMISSIVE_FACTOR(0.0f, 0.0f, 0.0f);
+constexpr float ORIGINAL_SUB_METALLIC_FACTOR(0.0f);
+constexpr float ORIGINAL_SUB_ROUGHNESS_FACTOR(1.0f);
+
+constexpr Vector4 FOCUSED_BASE_COLOR_FACTOR(1.0f, 1.0f, 1.0f, 1.0f);
+constexpr Vector3 FOCUSED_EMISSIVE_FACTOR(0.1f, 0.0f, 0.0f);
+constexpr float FOCUSED_METALLIC_FACTOR(0.2f);
+constexpr float FOCUSED_ROUGHNESS_FACTOR(0.5f);
+
+constexpr uint8_t FRAMEBUFFER_MULTI_SAMPLING_LEVEL = 4u;
+
+constexpr uint32_t MAX_BACKLOG_COUNT = 10;
+
+constexpr float RESOLUTION_RATE_DOWNSCALED = 0.25f;
+constexpr float RESOLUTION_RATE_UPSCALED = 1.5f;
+constexpr float RESOLUTION_RATE_OVER_DOWNSCALED = 0.1f;
+constexpr float RESOLUTION_RATE_OVER_UPSCALED = 2.5f;
+
+const Quaternion MODEL_ROTATION(Degree(360.f), Vector3(0.1f, 1.0f, -0.1f));
+
+enum ResolutionType
+{
+ DEFAULT = 0,
+ DOWNSCALED,
+ UPSCALED,
+
+ OVER_DOWNSCALED,
+ OVER_UPSCALED,
+
+ MAX,
+};
+
+void ApplyAllMaterialPropertyRecursively(Scene3D::ModelNode modelNode, const std::vector<KeyValuePair>& materialPropertyValues)
+{
+ if(!modelNode)
+ {
+ return;
+ }
+
+ for(uint32_t primitiveIndex = 0u; primitiveIndex < modelNode.GetModelPrimitiveCount(); ++primitiveIndex)
+ {
+ Scene3D::ModelPrimitive primitive = modelNode.GetModelPrimitive(primitiveIndex);
+ if(primitive)
+ {
+ Scene3D::Material material = primitive.GetMaterial();
+ if(material)
+ {
+ for(const auto& keyValuePair : materialPropertyValues)
+ {
+ if(keyValuePair.first.type == Property::Key::Type::INDEX)
+ {
+ material.SetProperty(keyValuePair.first.indexKey, keyValuePair.second);
+ }
+ }
+ }
+ }
+ }
+
+ for(uint32_t childIndex = 0u; childIndex < modelNode.GetChildCount(); ++childIndex)
+ {
+ Scene3D::ModelNode childNode = Scene3D::ModelNode::DownCast(modelNode.GetChildAt(childIndex));
+ ApplyAllMaterialPropertyRecursively(childNode, materialPropertyValues);
+ }
+}
+
+} // namespace
+
+class SceneViewExample : public ConnectionTracker
+{
+public:
+ SceneViewExample(Application& application)
+ : mApplication(application)
+ {
+ // Connect to the Application's Init signal
+ mApplication.InitSignal().Connect(this, &SceneViewExample::Create);
+ }
+
+ ~SceneViewExample() = default;
+
+private:
+ // The Init signal is received once (only) during the Application lifetime
+ void Create(Application& application)
+ {
+ // Get a handle to the window
+ mWindow = application.GetWindow();
+ const Vector2 windowSize = mWindow.GetSize();
+
+ // Create a SceneView and set the Skybox
+ mSceneView = Handle::New<SceneView>({{Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER},
+ {Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER},
+ {Actor::Property::SIZE, windowSize}});
+ mSceneView.SetSkybox(CUBEMAP_SKY_BOX_URL);
+ mWindow.Add(mSceneView);
+
+ // Load the model and set IBL
+ mMainModel = Model::New(MODEL_URL);
+ mMainModel.SetProperties({
+ {Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER},
+ {Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER},
+ {Actor::Property::POSITION, Vector3::ZERO},
+ {Actor::Property::SIZE, MODEL_SIZE},
+ {Actor::Property::NAME, "MainModel"},
+ {Actor::Property::KEYBOARD_FOCUSABLE, true},
+ {DevelActor::Property::TOUCH_FOCUSABLE, true},
+ });
+ mMainModel.SetImageBasedLightSource(CUBEMAP_IRRADIANCE_URL, CUBEMAP_SKY_BOX_URL);
+ mSceneView.Add(mMainModel);
+
+ mSubModel = Model::New(SUB_MODEL_URL);
+ mSubModel.SetProperties({
+ {Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER},
+ {Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER},
+ {Actor::Property::POSITION, Vector3(MODEL_SIZE.x, MODEL_SIZE.y * 0.5f, 0.0f)},
+ {Actor::Property::SIZE, SUB_MODEL_SIZE},
+ {Actor::Property::SCALE, SUB_MODEL_SCALE},
+ {Actor::Property::NAME, "SubModel"},
+ {Actor::Property::KEYBOARD_FOCUSABLE, true},
+ {DevelActor::Property::TOUCH_FOCUSABLE, true},
+ });
+ mSubModel.SetImageBasedLightSource(CUBEMAP_IRRADIANCE_URL, CUBEMAP_SKY_BOX_URL, 0.25f);
+ mSceneView.Add(mSubModel);
+
+ // Create a new camera and reparent as we want to rotate the camera around the origin
+ CameraActor cameraActor = Handle::New<CameraActor>({{Actor::Property::NAME, CAMERA_NAME}});
+ mSceneView.AddCamera(cameraActor);
+ mSceneView.SelectCamera(CAMERA_NAME);
+ cameraActor.SetType(Camera::LOOK_AT_TARGET);
+ cameraActor.SetTargetPosition(Vector3::ZERO);
+ cameraActor.Unparent();
+ Actor rotatingActor = Handle::New<Actor>({{Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER},
+ {Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER}});
+ rotatingActor.Add(cameraActor);
+ mSceneView.Add(rotatingActor);
+
+ mCameraRotateAnimation = Animation::New(10.0f);
+ mCameraRotateAnimation.SetLooping(true);
+ mCameraRotateAnimation.AnimateBy(Property(rotatingActor, Actor::Property::ORIENTATION), MODEL_ROTATION);
+ if(mRotateCamera)
+ {
+ mCameraRotateAnimation.Play();
+ }
+
+ // Respond to key events
+ mWindow.KeyEventSignal().Connect(this, &SceneViewExample::OnKeyEvent);
+ mWindow.ResizeSignal().Connect(this, &SceneViewExample::OnWindowResize);
+
+ DevelKeyboardFocusManager::EnableDefaultAlgorithm(KeyboardFocusManager::Get(), true);
+
+ mMainModel.KeyInputFocusGainedSignal().Connect(this, &SceneViewExample::OnFocusGained);
+ mMainModel.KeyInputFocusLostSignal().Connect(this, &SceneViewExample::OnFocusLost);
+ mSubModel.KeyInputFocusGainedSignal().Connect(this, &SceneViewExample::OnFocusGained);
+ mSubModel.KeyInputFocusLostSignal().Connect(this, &SceneViewExample::OnFocusLost);
+ KeyboardFocusManager::Get().FocusChangedSignal().Connect(this, &SceneViewExample::OnFocusChanged);
+
+ mScreenExtentTimer = Timer::New(16);
+ mScreenExtentTimer.TickSignal().Connect(this, &SceneViewExample::OnTick);
+ if(mShowScreenExtent)
+ {
+ mScreenExtentTimer.Start();
+ }
+
+ ApplyDebugLog();
+ }
+
+ /**
+ * @brief Called when any key event is received
+ *
+ * Will use this to quit the application if Back or the Escape key is received
+ * @param[in] event The key event information
+ */
+ void OnKeyEvent(const KeyEvent& event)
+ {
+ if(event.GetState() == KeyEvent::DOWN)
+ {
+ if(IsKey(event, Dali::DALI_KEY_ESCAPE) || IsKey(event, Dali::DALI_KEY_BACK))
+ {
+ if(KeyboardFocusManager::Get().GetCurrentFocusActor())
+ {
+ KeyboardFocusManager::Get().ClearFocus();
+ }
+ else
+ {
+ mApplication.Quit();
+ }
+ }
+
+ if(event.GetKeyName() == "1")
+ {
+ mShowDebugLabel ^= 1;
+ }
+ else if(event.GetKeyName() == "2")
+ {
+ mUseFrameBuffer ^= 1;
+ if(mSceneView)
+ {
+ mSceneView.UseFramebuffer(mUseFrameBuffer);
+ }
+ }
+ else if(event.GetKeyName() == "3")
+ {
+ mUseFrameBufferMultiSample ^= 1;
+ if(mSceneView)
+ {
+ mSceneView.SetFramebufferMultiSamplingLevel(mUseFrameBufferMultiSample ? FRAMEBUFFER_MULTI_SAMPLING_LEVEL : 0);
+ }
+ }
+ else if(event.GetKeyName() == "4")
+ {
+ mResolutionType = static_cast<ResolutionType>(static_cast<int>(mResolutionType + 1) % ResolutionType::MAX);
+ ApplyResolution();
+ }
+ else if(event.GetKeyName() == "5")
+ {
+ mRotateCamera ^= true;
+ if(mCameraRotateAnimation)
+ {
+ if(!mRotateCamera && mCameraRotateAnimation.GetState() == Animation::PLAYING)
+ {
+ mCameraRotateAnimation.Stop();
+ }
+ else if(mRotateCamera && mCameraRotateAnimation.GetState() != Animation::PLAYING)
+ {
+ mCameraRotateAnimation.Play();
+ }
+ }
+ }
+ else if(event.GetKeyName() == "6")
+ {
+ mShowScreenExtent ^= true;
+ if(mScreenExtentTimer)
+ {
+ if(!mShowScreenExtent && mScreenExtentTimer.IsRunning())
+ {
+ mScreenExtentTimer.Stop();
+ }
+ else if(mShowScreenExtent && !mScreenExtentTimer.IsRunning())
+ {
+ mScreenExtentTimer.Start();
+ }
+ }
+ if(mMainModelAABB)
+ {
+ mMainModelAABB[Actor::Property::VISIBLE] = mShowScreenExtent;
+ }
+ if(mSubModelAABB)
+ {
+ mSubModelAABB[Actor::Property::VISIBLE] = mShowScreenExtent;
+ }
+ }
+ ApplyDebugLog();
+ }
+ }
+
+ void OnWindowResize(Window window, Window::WindowSize newSize)
+ {
+ if(mSceneView)
+ {
+ mSceneView[Actor::Property::SIZE_WIDTH] = newSize.GetWidth();
+ mSceneView[Actor::Property::SIZE_HEIGHT] = newSize.GetHeight();
+ ApplyResolution();
+ }
+ }
+
+ void OnFocusChanged(Actor from, Actor to)
+ {
+ if(!from && !to)
+ {
+ return;
+ }
+ std::ostringstream oss;
+ oss << "Focus changed from : [";
+ oss << (from ? from.GetProperty<std::string>(Actor::Property::NAME) : "(nil)");
+ oss << "] -> [";
+ oss << (to ? to.GetProperty<std::string>(Actor::Property::NAME) : "(nil)");
+ oss << "]";
+ ApplyBackLog(oss.str());
+ }
+
+ void OnFocusGained(Control control)
+ {
+ std::ostringstream oss;
+ oss << "Focus gained : [";
+ oss << (control ? control.GetProperty<std::string>(Actor::Property::NAME) : "(nil)");
+ oss << "]";
+ ApplyBackLog(oss.str());
+
+ Model model = Model::DownCast(control);
+ if(model)
+ {
+ ApplyAllMaterialPropertyRecursively(
+ model.GetModelRoot(),
+ {
+ {Material::Property::BASE_COLOR_FACTOR, FOCUSED_BASE_COLOR_FACTOR},
+ {Material::Property::EMISSIVE_FACTOR, FOCUSED_EMISSIVE_FACTOR},
+ {Material::Property::METALLIC_FACTOR, FOCUSED_METALLIC_FACTOR},
+ {Material::Property::ROUGHNESS_FACTOR, FOCUSED_ROUGHNESS_FACTOR},
+ });
+ }
+ }
+
+ void OnFocusLost(Control control)
+ {
+ std::ostringstream oss;
+ oss << "Focus lost : [";
+ oss << (control ? control.GetProperty<std::string>(Actor::Property::NAME) : "(nil)");
+ oss << "]";
+ ApplyBackLog(oss.str());
+
+ Model model = Model::DownCast(control);
+ if(model)
+ {
+ bool isSubModel = model.GetProperty<std::string>(Actor::Property::NAME) == "SubModel";
+ ApplyAllMaterialPropertyRecursively(
+ model.GetModelRoot(),
+ {
+ {Material::Property::BASE_COLOR_FACTOR, isSubModel ? ORIGINAL_SUB_BASE_COLOR_FACTOR : ORIGINAL_BASE_COLOR_FACTOR},
+ {Material::Property::EMISSIVE_FACTOR, isSubModel ? ORIGINAL_SUB_EMISSIVE_FACTOR : ORIGINAL_EMISSIVE_FACTOR},
+ {Material::Property::METALLIC_FACTOR, isSubModel ? ORIGINAL_SUB_METALLIC_FACTOR : ORIGINAL_METALLIC_FACTOR},
+ {Material::Property::ROUGHNESS_FACTOR, isSubModel ? ORIGINAL_SUB_ROUGHNESS_FACTOR : ORIGINAL_ROUGHNESS_FACTOR},
+ });
+ }
+ }
+
+ bool OnTick()
+ {
+ if(mShowScreenExtent)
+ {
+ RecalculateScreenExtent();
+ }
+ return true;
+ }
+
+private:
+ void ApplyResolution()
+ {
+ if(mWindow && mSceneView)
+ {
+ Window::WindowSize windowSize = mWindow.GetSize();
+ switch(mResolutionType)
+ {
+ case ResolutionType::DEFAULT:
+ default:
+ {
+ mResolutionRate = 0.0f;
+ break;
+ }
+ case ResolutionType::DOWNSCALED:
+ {
+ mResolutionRate = RESOLUTION_RATE_DOWNSCALED;
+ break;
+ }
+ case ResolutionType::UPSCALED:
+ {
+ mResolutionRate = RESOLUTION_RATE_UPSCALED;
+ break;
+ }
+ case ResolutionType::OVER_DOWNSCALED:
+ {
+ mResolutionRate = RESOLUTION_RATE_OVER_DOWNSCALED;
+ break;
+ }
+ case ResolutionType::OVER_UPSCALED:
+ {
+ mResolutionRate = RESOLUTION_RATE_OVER_UPSCALED;
+ break;
+ }
+ }
+
+ if(Dali::EqualsZero(mResolutionRate))
+ {
+ mSceneView.ResetResolution();
+ }
+ else
+ {
+ mSceneView.SetResolution(static_cast<uint32_t>(windowSize.GetWidth() * mResolutionRate), static_cast<uint32_t>(windowSize.GetHeight() * mResolutionRate));
+ }
+ }
+ }
+
+ void ApplyDebugLog()
+ {
+ if(!mDebugLabel)
+ {
+ mDebugLabel = TextLabel::New();
+ mDebugLabel[Actor::Property::PARENT_ORIGIN] = ParentOrigin::TOP_LEFT;
+ mDebugLabel[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ mDebugLabel[TextLabel::Property::MULTI_LINE] = true;
+ mDebugLabel[Control::Property::BACKGROUND] = Vector4(1.0f, 1.0f, 1.0f, 0.2f);
+ }
+
+ if(mShowDebugLabel)
+ {
+ if(mWindow && mDebugLabel && !mDebugLabel.GetParent())
+ {
+ mWindow.GetOverlayLayer().Add(mDebugLabel);
+ }
+ std::ostringstream oss;
+ oss << "Key 1 : Toggle to show debug log\n";
+ oss << "Key 2 : Toggle to use Framebuffer. Currently " << (mUseFrameBuffer ? "ON" : "OFF") << "\n";
+ oss << "Key 3 : Toggle to use FramebufferMultiSampling. Currently " << (mUseFrameBufferMultiSample ? FRAMEBUFFER_MULTI_SAMPLING_LEVEL : 0) << "\n";
+ oss << "Key 4 : Toggle to use SetResolution. Currently ";
+ oss << (mResolutionType == ResolutionType::DEFAULT ? "DEFAULT" : mResolutionType == ResolutionType::DOWNSCALED ? "DOWNSCALED"
+ : mResolutionType == ResolutionType::UPSCALED ? "UPSCALED"
+ : mResolutionType == ResolutionType::OVER_DOWNSCALED ? "OVER_DOWNSCALED"
+ : mResolutionType == ResolutionType::OVER_UPSCALED ? "OVER_UPSCALED"
+ : "ERROR")
+ << " (Scale rate : " << mResolutionRate << ")\n";
+ oss << "Key 5 : Toggle to Rotate camera. Currently " << (mRotateCamera ? "ON" : "OFF") << "\n";
+ oss << "Key 6 : Toggle to show Model ScreenExtent. Currently " << (mShowScreenExtent ? "ON" : "OFF") << "\n";
+
+ for(const auto& log : mBackLog)
+ {
+ oss << log;
+ if(log.length() == 0 || log.back() != '\n')
+ {
+ oss << "\n";
+ }
+ }
+
+ mDebugLabel[TextLabel::Property::TEXT] = oss.str();
+ }
+ else
+ {
+ if(mDebugLabel)
+ {
+ mDebugLabel.Unparent();
+ }
+ }
+ }
+
+ void ApplyBackLog(std::string message)
+ {
+ if(mBackLog.size() == MAX_BACKLOG_COUNT)
+ {
+ mBackLog.clear();
+ }
+ mBackLog.push_back(message);
+
+ ApplyDebugLog();
+ }
+
+ void ApplyModelScreenExtent(Control aabb, Model model)
+ {
+ Rect<float> screenExtent = Dali::DevelActor::CalculateCurrentScreenExtents(model);
+
+ aabb[Actor::Property::POSITION_X] = screenExtent.x;
+ aabb[Actor::Property::POSITION_Y] = screenExtent.y;
+ aabb[Actor::Property::SIZE_WIDTH] = screenExtent.width;
+ aabb[Actor::Property::SIZE_HEIGHT] = screenExtent.height;
+ }
+
+private:
+ void RecalculateScreenExtent()
+ {
+ if(mWindow && !mMainModelAABB)
+ {
+ mMainModelAABB = Control::New();
+ mMainModelAABB.SetProperties({
+ {Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT},
+ {Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT},
+ {Control::Property::BACKGROUND, Vector4(0.0f, 0.0f, 1.0f, 0.2f)},
+ });
+ mWindow.GetOverlayLayer().Add(mMainModelAABB);
+ }
+ if(mWindow && !mSubModelAABB)
+ {
+ mSubModelAABB = Control::New();
+ mSubModelAABB.SetProperties({
+ {Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT},
+ {Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT},
+ {Control::Property::BACKGROUND, Vector4(1.0f, 0.0f, 0.0f, 0.2f)},
+ });
+ mWindow.GetOverlayLayer().Add(mSubModelAABB);
+ }
+
+ ApplyModelScreenExtent(mMainModelAABB, mMainModel);
+ ApplyModelScreenExtent(mSubModelAABB, mSubModel);
+ }
+
+private:
+ Application& mApplication;
+ Window mWindow;
+ SceneView mSceneView;
+
+ Model mMainModel;
+ Model mSubModel;
+
+ Animation mCameraRotateAnimation;
+
+ // State of demo
+ TextLabel mDebugLabel;
+ bool mShowDebugLabel{true};
+
+ std::vector<std::string> mBackLog;
+
+ Timer mScreenExtentTimer;
+ Control mMainModelAABB;
+ Control mSubModelAABB;
+
+ bool mUseFrameBuffer{false};
+ bool mUseFrameBufferMultiSample{false};
+ bool mRotateCamera{true};
+ bool mShowScreenExtent{false};
+
+ ResolutionType mResolutionType{ResolutionType::DEFAULT};
+ float mResolutionRate{0.0f};
+};
+
+int DALI_EXPORT_API main(int argc, char** argv)
+{
+ Application application = Application::New(&argc, &argv);
+ SceneViewExample test(application);
+ application.MainLoop();
+ return 0;
+}
projects / platform / core / uifw / dali-demo.git / commitdiff
