diff options
Diffstat (limited to 'src/Authoring/Studio/Render/StudioRendererTranslation.cpp')
| -rw-r--r-- | src/Authoring/Studio/Render/StudioRendererTranslation.cpp | 4083 |
1 files changed, 0 insertions, 4083 deletions
diff --git a/src/Authoring/Studio/Render/StudioRendererTranslation.cpp b/src/Authoring/Studio/Render/StudioRendererTranslation.cpp deleted file mode 100644 index 82678986..00000000 --- a/src/Authoring/Studio/Render/StudioRendererTranslation.cpp +++ /dev/null @@ -1,4083 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2006 NVIDIA Corporation. -** Copyright (C) 2017 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of Qt 3D Studio. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ -#include "Qt3DSCommonPrecompile.h" -#include "StudioRendererImpl.h" -#include "StudioRendererTranslation.h" -#include "Qt3DSRenderEffectSystem.h" -#include "foundation/StrConvertUTF.h" -#include "Qt3DSFileTools.h" -#include "Qt3DSRenderUIPLoader.h" -#include "Qt3DSRenderWidgets.h" -#include "foundation/Qt3DSBounds3.h" -#include "Qt3DSRenderResourceManager.h" -#include "render/Qt3DSRenderFrameBuffer.h" -#include "Qt3DSRenderCamera.h" -#include "foundation/Qt3DSPlane.h" -#include "Qt3DSRenderRotationHelper.h" -#include "Qt3DSRenderPluginGraphObject.h" -#include "Qt3DSRenderPlugin.h" -#include "StudioCoreSystem.h" -#include "Qt3DSDMDataCore.h" -#include "Qt3DSRenderPluginPropertyValue.h" -#include "Qt3DSRenderEffectSystem.h" -#include "render/Qt3DSRenderShaderProgram.h" -#include "Qt3DSRenderMaterialHelpers.h" -#include "Qt3DSRenderDynamicObjectSystem.h" -#include "Qt3DSRenderCustomMaterialSystem.h" -#include "Qt3DSRenderReferencedMaterial.h" -#include "Qt3DSRenderPixelGraphicsTypes.h" -#include "Qt3DSRenderPixelGraphicsRenderer.h" -#include "Qt3DSRenderPathManager.h" - -#include "PathWidget.h" -#include "Qt3DSRenderLightmaps.h" -#include "StudioPreferences.h" -#include "HotKeys.h" -#include "Qt3DSRenderCamera.h" -#include "Qt3DSRenderLight.h" - -#pragma warning(disable : 4100) // unreferenced formal parameter - -using namespace qt3ds::studio; -QT3DSU32 qt3ds::studio::g_GraphObjectTranslatorTag; -using qt3ds::render::SPGGraphObject; -using qt3ds::render::SPGRect; -using qt3ds::render::SPGVertLine; -using qt3ds::render::SPGHorzLine; -using qt3ds::render::NVRenderRectF; -using qt3ds::render::NVRenderRect; - -namespace { -using namespace qt3dsdm; - -struct STranslatorDataModelParser -{ - STranslation &m_Context; - Qt3DSDMInstanceHandle m_InstanceHandle; - STranslatorDataModelParser(STranslation &inContext, Qt3DSDMInstanceHandle inInstance) - : m_Context(inContext) - , m_InstanceHandle(inInstance) - { - } - Qt3DSDMInstanceHandle GetInstanceHandle() { return m_InstanceHandle; } - - template <typename TDataType> - inline Option<TDataType> GetPropertyValue(qt3dsdm::Qt3DSDMPropertyHandle inProperty) - { - Option<SValue> theValue = - m_Context.m_Reader.GetRawInstancePropertyValue(GetInstanceHandle(), inProperty); - if (theValue.hasValue()) - return qt3dsdm::get<TDataType>(*theValue); - return Empty(); - } - - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, QT3DSF32 &outValue) - { - Option<float> theValue = GetPropertyValue<float>(inProperty); - if (theValue.hasValue()) { - outValue = theValue.getValue(); - return true; - } - return false; - } - - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, QT3DSU32 &outValue) - { - auto theValue = GetPropertyValue<qt3ds::QT3DSI32>(inProperty); - if (theValue.hasValue()) { - outValue = qMax(theValue.getValue(), 0); - return true; - } - return false; - } - - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, QT3DSI32 &outValue) - { - auto theValue = GetPropertyValue<qt3ds::QT3DSI32>(inProperty); - if (theValue.hasValue()) { - outValue = *theValue; - return true; - } - return false; - } - - bool ParseRadianProperty(Qt3DSDMPropertyHandle inProperty, QT3DSF32 &outValue) - { - if (ParseProperty(inProperty, outValue)) { - TORAD(outValue); - return true; - } - return false; - } - bool ParseRadianProperty(Qt3DSDMPropertyHandle inProperty, QT3DSVec3 &outValue) - { - if (ParseProperty(inProperty, outValue)) { - TORAD(outValue.x); - TORAD(outValue.y); - TORAD(outValue.z); - return true; - } - return false; - } - bool ParseOpacityProperty(Qt3DSDMPropertyHandle inProperty, QT3DSF32 &outValue) - { - if (ParseProperty(inProperty, outValue)) { - outValue = (1.0f / 100.0f) * outValue; - return true; - } - return false; - } - bool ParseRotationOrder(Qt3DSDMPropertyHandle inProperty, QT3DSU32 &outValue) - { - qt3ds::render::CRegisteredString temp; - if (ParseProperty(inProperty, temp)) { - outValue = qt3ds::render::MapRotationOrder(temp); - return true; - } - return false; - } - bool ParseOrientation(Qt3DSDMPropertyHandle inProperty, qt3ds::render::NodeFlags &outValue) - { - qt3ds::render::CRegisteredString temp; - if (ParseProperty(inProperty, temp)) { - bool isLeftHanded = strcmp(temp.c_str(), "Left Handed") == 0; - outValue.SetLeftHanded(isLeftHanded); - return true; - } - return false; - } - - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, bool &outValue) - { - Option<bool> theValue = GetPropertyValue<bool>(inProperty); - if (theValue.hasValue()) { - outValue = theValue.getValue(); - return true; - } - return false; - } - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, QT3DSVec2 &outValue) - { - Option<qt3dsdm::SFloat2> theValue = GetPropertyValue<qt3dsdm::SFloat2>(inProperty); - if (theValue.hasValue()) { - outValue = QT3DSVec2(theValue->m_Floats[0], theValue->m_Floats[1]); - return true; - } - return false; - } - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, QT3DSVec3 &outValue) - { - Option<SFloat3> theValue = GetPropertyValue<SFloat3>(inProperty); - if (theValue.hasValue()) { - outValue = QT3DSVec3(theValue->m_Floats[0], theValue->m_Floats[1], theValue->m_Floats[2]); - return true; - } - return false; - } - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, QT3DSVec4 &outValue) - { - Option<SFloat4> theValue = GetPropertyValue<SFloat4>(inProperty); - if (theValue.hasValue()) { - outValue = QT3DSVec4(theValue->m_Floats[0], theValue->m_Floats[1], - theValue->m_Floats[2], theValue->m_Floats[3]); - return true; - } - return false; - } - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, qt3ds::render::CRegisteredString &outValue) - { - Option<qt3dsdm::TDataStrPtr> theValue = GetPropertyValue<qt3dsdm::TDataStrPtr>(inProperty); - if (theValue.hasValue() && *theValue) { - qt3ds::render::IStringTable &theStrTable(m_Context.m_Context.GetStringTable()); - outValue = theStrTable.RegisterStr((*theValue)->GetData()); - return true; - } - return false; - } - - bool ParseAndResolveSourcePath(qt3dsdm::Qt3DSDMPropertyHandle inProperty, - qt3ds::render::CRegisteredString &outValue) - { - if (ParseProperty(inProperty, outValue)) { - if (outValue.IsValid() && outValue.c_str()[0] != '#') { - Q3DStudio::CFilePath theDirectory = m_Context.m_Doc.GetDocumentDirectory(); - Q3DStudio::CFilePath theResolvedPath = - Q3DStudio::CFilePath::CombineBaseAndRelative(theDirectory, outValue.c_str()); - if (theResolvedPath.exists()) { - outValue = m_Context.m_Context.GetStringTable() - .RegisterStr(theResolvedPath.toCString()); - } - } - return true; - } - return false; - } - - template <typename TEnumType> - bool ParseEnumProperty(qt3dsdm::Qt3DSDMPropertyHandle inProperty, TEnumType &ioValue) - { - qt3ds::render::CRegisteredString temp; - if (ParseProperty(inProperty, temp)) { - qt3ds::render::SEnumNameMap *theNameMap(qt3ds::render::SEnumParseMap<TEnumType>::GetMap()); - for (qt3ds::render::SEnumNameMap *theIter = theNameMap; - theIter->m_Name && *theIter->m_Name; ++theIter) { - // hack to match advanced overlay types, whose name start with a '*' - const char8_t *p = temp; - if (*p == '*') - ++p; - if (strcmp(p, theIter->m_Name) == 0) { - ioValue = (TEnumType)theIter->m_Enum; - return true; - } - } - } - return false; - } - - bool ParseNodeFlagsProperty(qt3dsdm::Qt3DSDMPropertyHandle inProperty, - qt3ds::render::NodeFlags &outValue, - qt3ds::render::NodeFlagValues::Enum theFlag) - { - bool temp = false; - if (ParseProperty(inProperty, temp)) { - outValue.ClearOrSet(temp, theFlag); - return true; - } - return false; - } - bool ParseNodeFlagsInverseProperty(qt3dsdm::Qt3DSDMPropertyHandle inProperty, - qt3ds::render::NodeFlags &outValue, - qt3ds::render::NodeFlagValues::Enum theFlag) - { - bool temp = false; - if (ParseProperty(inProperty, temp)) { - outValue.ClearOrSet(!temp, theFlag); - return true; - } - return false; - } - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, qt3ds::render::SImage *&ioImage) - { - Option<SLong4> theData = GetPropertyValue<SLong4>(inProperty); - if (theData.hasValue()) { - qt3dsdm::Qt3DSDMInstanceHandle theInstance( - m_Context.m_Reader.GetInstanceForGuid(*theData)); - SGraphObjectTranslator *imageTranslator = m_Context.GetOrCreateTranslator(theInstance); - if (imageTranslator - && imageTranslator->GetGraphObject().m_Type - == qt3ds::render::GraphObjectTypes::Image) { - SImage *theNewImage = static_cast<SImage *>(&imageTranslator->GetGraphObject()); - ioImage = theNewImage; - } else - ioImage = nullptr; - return true; - } - return false; - } - - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, qt3ds::render::SGraphObject *&ioObjRef) - { - Option<SObjectRefType> theData = GetPropertyValue<SObjectRefType>(inProperty); - if (theData.hasValue()) { - qt3dsdm::Qt3DSDMInstanceHandle theInstance( - m_Context.m_Reader.GetInstanceForObjectRef(m_InstanceHandle, *theData)); - SGraphObjectTranslator *theItemTranslator = - m_Context.GetOrCreateTranslator(theInstance); - if (theItemTranslator) - ioObjRef = &theItemTranslator->GetGraphObject(); - } - return true; - } - - bool ParseProperty(Qt3DSDMPropertyHandle inProperty, qt3ds::render::SNode *&ioNodePtr) - { - Option<SObjectRefType> theData = GetPropertyValue<SObjectRefType>(inProperty); - SNode *theNewNodePtr = nullptr; - if (theData.hasValue()) { - qt3dsdm::Qt3DSDMInstanceHandle theInstance( - m_Context.m_Reader.GetInstanceForObjectRef(m_InstanceHandle, *theData)); - SGraphObjectTranslator *theItemTranslator = - m_Context.GetOrCreateTranslator(theInstance); - if (theItemTranslator) { - SGraphObject &theObject = theItemTranslator->GetGraphObject(); - if (GraphObjectTypes::IsNodeType(theObject.m_Type)) - theNewNodePtr = &static_cast<SNode &>(theObject); - } - } - ioNodePtr = theNewNodePtr; - return true; - } -}; - -// Define parse tables -#define Scene_ClearColor m_Scene.m_BackgroundColor -#define Scene_UseClearColor m_Scene.m_BgColorEnable -#define Node_Rotation m_Node.m_Rotation -#define Node_Position m_Node.m_Position -#define Node_Scale m_Node.m_Scale -#define Node_Pivot m_Node.m_Pivot -#define Node_LocalOpacity m_Node.m_Opacity -#define Node_RotationOrder m_Node.m_RotationOrder -#define Node_LeftHanded m_Node.m_Orientation -#define Layer_TemporalAAEnabled m_Layer.m_TemporalAA -#define Layer_LayerEnableDepthTest m_Layer.m_DisableDepthTest -#define Layer_LayerEnableDepthPrePass m_Layer.m_DisableDepthPrepass -#define Layer_ClearColor m_Layer.m_BackgroundColor -#define Layer_Background m_Layer.m_Background -#define Layer_BlendType m_Layer.m_BlendType -#define Layer_Size m_Layer.m_Size -#define Layer_Location m_Layer.m_Location -#define Layer_ProgressiveAAMode m_Layer.m_ProgressiveAA -#define Layer_MultisampleAAMode m_Layer.m_MultisampleAA -#define Layer_HorizontalFieldValues m_Layer.m_HorizontalFieldValues -#define Layer_Left m_Layer.m_Left -#define Layer_LeftUnits m_Layer.m_LeftUnits -#define Layer_Width m_Layer.m_Width -#define Layer_WidthUnits m_Layer.m_WidthUnits -#define Layer_Right m_Layer.m_Right -#define Layer_RightUnits m_Layer.m_RightUnits -#define Layer_VerticalFieldValues m_Layer.m_VerticalFieldValues -#define Layer_Top m_Layer.m_Top -#define Layer_TopUnits m_Layer.m_TopUnits -#define Layer_Height m_Layer.m_Height -#define Layer_HeightUnits m_Layer.m_HeightUnits -#define Layer_Bottom m_Layer.m_Bottom -#define Layer_BottomUnits m_Layer.m_BottomUnits -#define Layer_AoStrength m_Layer.m_AoStrength -#define Layer_AoDistance m_Layer.m_AoDistance -#define Layer_AoSoftness m_Layer.m_AoSoftness -#define Layer_AoBias m_Layer.m_AoBias -#define Layer_AoSamplerate m_Layer.m_AoSamplerate -#define Layer_AoDither m_Layer.m_AoDither -#define Layer_ShadowStrength m_Layer.m_ShadowStrength -#define Layer_ShadowDist m_Layer.m_ShadowDist -#define Layer_ShadowSoftness m_Layer.m_ShadowSoftness -#define Layer_ShadowBias m_Layer.m_ShadowBias -#define Layer_LightProbe m_Layer.m_LightProbe -#define Layer_ProbeBright m_Layer.m_ProbeBright -#define Layer_FastIbl m_Layer.m_FastIbl -#define Layer_ProbeHorizon m_Layer.m_ProbeHorizon -#define Layer_ProbeFov m_Layer.m_ProbeFov -#define Layer_LightProbe2 m_Layer.m_LightProbe2 -#define Layer_Probe2Fade m_Layer.m_Probe2Fade -#define Layer_Probe2Window m_Layer.m_Probe2Window -#define Layer_Probe2Pos m_Layer.m_Probe2Pos -#define Layer_TexturePath m_Asset.m_SourcePath -#define Camera_ClipNear m_Camera.m_ClipNear -#define Camera_ClipFar m_Camera.m_ClipFar -#define Camera_FOV m_Camera.m_Fov -#define Camera_FOVHorizontal m_Camera.m_FovHorizontal -#define Camera_Orthographic m_Camera.m_Orthographic -#define Camera_ScaleMode m_Camera.m_ScaleMode -#define Camera_ScaleAnchor m_Camera.m_ScaleAnchor -#define Light_LightType m_Light.m_LightType -#define Light_Scope m_Light.m_Scope -#define Light_DiffuseColor m_Light.m_LightColor -#define Light_SpecularColor m_Light.m_SpecularColor -#define Light_AmbientColor m_Light.m_AmbientColor -#define Light_Brightness m_Light.m_Brightness -#define Light_LinearFade m_Light.m_LinearFade -#define Light_ExponentialFade m_Light.m_ExpFade -#define Light_AreaWidth m_Light.m_AreaWidth -#define Light_AreaHeight m_Light.m_AreaHeight -#define Light_CastShadow m_Light.m_CastShadow -#define Light_ShadowBias m_Light.m_ShadowBias -#define Light_ShadowFactor m_Light.m_ShadowFactor -#define Light_ShadowMapRes m_Light.m_ShadowMapRes -#define Light_ShadowMapFar m_Light.m_ShadowMapFar -#define Light_ShadowMapFov m_Light.m_ShadowMapFov -#define Light_ShadowFilter m_Light.m_ShadowFilter -#define Model_MeshPath m_Asset.m_SourcePath -#define Model_ShadowCaster m_Model.m_ShadowCaster -#define Model_TessellationMode m_Model.m_Tessellation -#define Model_EdgeTess m_Model.m_EdgeTess -#define Model_InnerTess m_Model.m_InnerTess -#define Lightmaps_LightmapIndirect m_Lightmaps.m_LightmapIndirect -#define Lightmaps_LightmapRadiosity m_Lightmaps.m_LightmapRadiosity -#define Lightmaps_LightmapShadow m_Lightmaps.m_LightmapShadow -#define MaterialBase_IblProbe m_MaterialBase.m_IblProbe -#define Material_Lighting m_Material.m_ShaderLighting -#define Material_BlendMode m_Material.m_BlendMode -#define Material_DiffuseColor m_Material.m_DiffuseColor -#define Material_DiffuseMaps_0 m_Material.m_DiffuseMap1 -#define Material_DiffuseMaps_1 m_Material.m_DiffuseMap2 -#define Material_DiffuseMaps_2 m_Material.m_DiffuseMap3 -#define Material_EmissivePower m_Material.m_EmissivePower -#define Material_EmissiveColor m_Material.m_EmissiveColor -#define Material_EmissiveMap m_Material.m_EmissiveMap -#define Material_EmissiveMap2 m_Material.m_EmissiveMap2 -#define Material_SpecularReflection m_Material.m_SpecularReflection -#define Material_SpecularMap m_Material.m_SpecularMap -#define Material_SpecularModel m_Material.m_SpecularModel -#define Material_SpecularTint m_Material.m_SpecularTint -#define Material_IOR m_Material.m_IOR -#define Material_FresnelPower m_Material.m_FresnelPower -#define Material_SpecularAmount m_Material.m_SpecularAmount -#define Material_SpecularRoughness m_Material.m_SpecularRoughness -#define Material_RoughnessMap m_Material.m_RoughnessMap -#define Material_Opacity m_Material.m_Opacity -#define Material_OpacityMap m_Material.m_OpacityMap -#define Material_BumpMap m_Material.m_BumpMap -#define Material_BumpAmount m_Material.m_BumpAmount -#define Material_NormalMap m_Material.m_NormalMap -#define Material_DisplacementMap m_Material.m_DisplacementMap -#define Material_DisplaceAmount m_Material.m_DisplaceAmount -#define Material_TranslucencyMap m_Material.m_TranslucencyMap -#define Material_TranslucentFalloff m_Material.m_TranslucentFalloff -#define Material_DiffuseLightWrap m_Material.m_DiffuseLightWrap -#define Material_ReferencedMaterial m_ReferencedMaterial.m_ReferencedMaterial -#define Material_VertexColors m_Material.m_VertexColors -#define Image_ImagePath m_Asset.m_SourcePath -#define Image_OffscreenRendererId m_Image.m_SubPresentation -#define Image_Scale_X m_Image.m_RepeatU -#define Image_Scale_Y m_Image.m_RepeatV -#define Image_Pivot_X m_Image.m_PivotU -#define Image_Pivot_Y m_Image.m_PivotV -#define Image_Rotation m_Image.m_RotationUV -#define Image_Position_X m_Image.m_PositionU -#define Image_Position_Y m_Image.m_PositionV -#define Image_MappingMode m_Image.m_TextureMapping -#define Image_HorizontalTilingMode m_Image.m_TilingU -#define Image_VerticalTilingMode m_Image.m_TilingV -#define Text_Text m_Text.m_TextString -#define Text_Font m_Text.m_Font -#define Text_FontSize m_Text.m_Size -#define Text_HorizontalAlignment m_Text.m_HorzAlign -#define Text_VerticalAlignment m_Text.m_VertAlign -#define Text_Leading m_Text.m_Leading -#define Text_Tracking m_Text.m_Tracking -#define Text_DropShadow m_Text.m_DropShadow -#define Text_DropShadowStrength m_Text.m_DropShadowStrength -#define Text_DropShadowOffsetX m_Text.m_DropShadowOffsetX -#define Text_DropShadowOffsetY m_Text.m_DropShadowOffsetY -#define Text_WordWrap m_Text.m_WordWrap -#define Text_BoundingBox m_Text.m_BoundingBox -#define Text_Elide m_Text.m_Elide -#define Text_TextColor m_Text.m_TextColor -#define Text_EnableAcceleratedFont m_Text.m_EnableAcceleratedFont -#define Path_Width m_Path.m_Width -#define Path_LinearError m_Path.m_LinearError -#define Path_InnerTessAmount m_Path.m_InnerTessAmount -#define Path_EdgeTessAmount m_Path.m_EdgeTessAmount -#define Path_Opacity m_Path.m_Opacity -#define Path_BeginCapping m_Path.m_BeginCap -#define Path_BeginCapOffset m_Path.m_BeginCapOffset -#define Path_BeginCapOpacity m_Path.m_BeginCapOpacity -#define Path_BeginCapWidth m_Path.m_BeginCapWidth -#define Path_EndCapping m_Path.m_EndCap -#define Path_EndCapOffset m_Path.m_EndCapOffset -#define Path_EndCapOpacity m_Path.m_EndCapOpacity -#define Path_EndCapWidth m_Path.m_EndCapWidth -#define Path_PathType m_Path.m_PathType -#define Path_PaintStyle m_Path.m_PaintStyle -#define Path_PathBuffer m_Asset.m_SourcePath -#define SubPath_Closed m_SubPath.m_Closed - -// Fill in implementations for the actual parse tables. -#define HANDLE_QT3DS_RENDER_PROPERTY(type, name, dirty) \ - theParser.ParseProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_RENDER_VEC3_PROPERTY(type, name, dirty) \ - theParser.ParseProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_RENDER_REAL_VEC2_PROPERTY(type, name, dirty) \ - theParser.ParseProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_RENDER_COLOR_PROPERTY(type, name, dirty) \ - theParser.ParseProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_RENDER_RADIAN_PROPERTY(type, name, dirty) \ - theParser.ParseRadianProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_RENDER_VEC3_RADIAN_PROPERTY(type, name, dirty) \ - theParser.ParseRadianProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_RENDER_OPACITY_PROPERTY(type, name, dirty) \ - theParser.ParseOpacityProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_ROTATION_ORDER_PROPERTY(type, name, dirty) \ - theParser.ParseRotationOrder(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_NODE_ORIENTATION_PROPERTY(type, name, dirty) \ - theParser.ParseOrientation(inContext.m_ObjectDefinitions.type##_##name, theItem.m_Flags); -#define HANDLE_QT3DS_RENDER_DEPTH_TEST_PROPERTY(type, name, dirty) \ - if (theParser.ParseProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name)) \ - theItem.m_##name = !theItem.m_##name; -#define HANDLE_QT3DS_NODE_FLAGS_PROPERTY(type, name, dirty) \ - theParser.ParseNodeFlagsProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_Flags, \ - qt3ds::render::NodeFlagValues::name); -#define HANDLE_QT3DS_NODE_FLAGS_INVERSE_PROPERTY(type, name, dirty) \ - theParser.ParseNodeFlagsInverseProperty(inContext.m_ObjectDefinitions.type##_##name, \ - theItem.m_Flags, qt3ds::render::NodeFlagValues::name); -#define HANDLE_QT3DS_RENDER_ENUM_PROPERTY(type, name, dirty) \ - theParser.ParseEnumProperty(inContext.m_ObjectDefinitions.type##_##name, theItem.m_##name); -#define HANDLE_QT3DS_RENDER_SOURCEPATH_PROPERTY(type, name, dirty) \ - theParser.ParseAndResolveSourcePath(inContext.m_ObjectDefinitions.type##_##name, \ - theItem.m_##name); -#define HANDLE_QT3DS_RENDER_ARRAY_PROPERTY(type, name, index, dirty) \ - theParser.ParseProperty(inContext.m_ObjectDefinitions.type##_##name##_##index, \ - theItem.m_##name[index]); -#define HANDLE_QT3DS_RENDER_VEC2_PROPERTY(type, name, dirty) \ - theParser.ParseProperty(inContext.m_ObjectDefinitions.type##_##name##_##X, \ - theItem.m_##name.x); \ - theParser.ParseProperty(inContext.m_ObjectDefinitions.type##_##name##_##Y, theItem.m_##name.y); -#define HANDLE_QT3DS_RENDER_COLOR_VEC3_PROPERTY( \ - type, name, dirty) // noop by intention already handled by HANDLE_QT3DS_RENDER_COLOR_PROPERTY -#define HANDLE_QT3DS_RENDER_TRANSFORM_VEC3_PROPERTY( \ - type, name, dirty) // noop by intention already handled by HANDLE_QT3DS_RENDER_VEC3_PROPERTY - -struct SSceneTranslator : public SGraphObjectTranslator -{ - SSceneTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SGraphObjectTranslator(inInstance, *QT3DS_NEW(inAlloc, SScene)()) - { - } - - void PushTranslation(STranslation &inContext) override - { - SScene &theItem = static_cast<SScene &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_SCENE_PROPERTIES - SLayer *theCurrentLayer = nullptr; - theItem.m_FirstChild = nullptr; - for (long idx = 0, end = inContext.m_AssetGraph.GetChildCount(GetInstanceHandle()); - idx < end; ++idx) { - SGraphObjectTranslator::PushTranslation(inContext); - qt3dsdm::Qt3DSDMInstanceHandle theLayer = - inContext.m_AssetGraph.GetChild(GetInstanceHandle(), idx); - SGraphObjectTranslator *theTranslator = inContext.GetOrCreateTranslator(theLayer); - if (theTranslator && theTranslator->GetGraphObject().m_Type == - qt3ds::render::GraphObjectTypes::Layer) { - SLayer *theLayerObj = static_cast<SLayer *>(&theTranslator->GetGraphObject()); - theLayerObj->m_NextSibling = nullptr; - if (theItem.m_FirstChild == nullptr) - theItem.m_FirstChild = theLayerObj; - else - theCurrentLayer->m_NextSibling = theLayerObj; - theCurrentLayer = theLayerObj; - } - } - } - void ClearChildren() override - { - SScene &theItem = static_cast<SScene &>(GetGraphObject()); - SLayer *theLastChild = nullptr; - - for (SLayer *theChild = theItem.m_FirstChild; theChild; - theChild = static_cast<SLayer *>(theChild->m_NextSibling)) { - if (theLastChild) - theLastChild->m_NextSibling = nullptr; - theChild->m_Parent = nullptr; - theLastChild = theChild; - } - theItem.m_FirstChild = nullptr; - } - void AppendChild(SGraphObject &inChild) override - { - if (inChild.m_Type != GraphObjectTypes::Layer) - return; - SScene &theItem = static_cast<SScene &>(GetGraphObject()); - SLayer &theLayer = static_cast<SLayer &>(inChild); - theItem.AddChild(theLayer); - } - void SetActive(bool /*inActive*/) override - { - // How could we not be active? - } -}; - -struct SNodeTranslator : public SGraphObjectTranslator -{ - SNodeTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SGraphObjectTranslator(inInstance, *QT3DS_NEW(inAlloc, SNode)()) - { - Initialize(); - } - SNodeTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, SNode &inNode) - : SGraphObjectTranslator(inInstance, inNode) - { - Initialize(); - } - void Initialize() - { - SNode &theNode = static_cast<SNode &>(GetGraphObject()); - // Ensure the global transform is valid because we use this before we render sometimes. - theNode.m_GlobalTransform = QT3DSMat44::createIdentity(); - } - static inline bool IsNodeType(qt3ds::render::GraphObjectTypes::Enum inType) - { - return qt3ds::render::GraphObjectTypes::IsNodeType(inType); - } - void PushTranslation(STranslation &inContext) override - { - SGraphObjectTranslator::PushTranslation(inContext); - SNode &theItem = static_cast<SNode &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_NODE_PROPERTIES - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Node.m_BoneId, - theItem.m_SkeletonId); - bool ignoresParent = false; - if (theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Node.m_IgnoresParent, - ignoresParent)) - theItem.m_Flags.SetIgnoreParentTransform(ignoresParent); - } - void AppendChild(SGraphObject &inChild) override - { - if (GraphObjectTypes::IsNodeType(inChild.m_Type) == false) { - QT3DS_ASSERT(false); - return; - } - - SNode &theItem = static_cast<SNode &>(GetGraphObject()); - SNode &theChild = static_cast<SNode &>(inChild); - theItem.AddChild(theChild); - theItem.MarkDirty(qt3ds::render::NodeTransformDirtyFlag::TransformIsDirty); - theChild.MarkDirty(qt3ds::render::NodeTransformDirtyFlag::TransformIsDirty); - } - void ClearChildren() override - { - SNode &theItem = static_cast<SNode &>(GetGraphObject()); - SNode *theLastChild = nullptr; - for (SNode *theChild = theItem.m_FirstChild; theChild; theChild = theChild->m_NextSibling) { - if (theLastChild) - theLastChild->m_NextSibling = nullptr; - theLastChild = theChild; - theChild->m_Parent = nullptr; - } - theItem.m_FirstChild = nullptr; - } - - void SetActive(bool inActive) override - { - SNode &theNode = static_cast<SNode &>(GetGraphObject()); - if (inActive != theNode.m_Flags.IsActive()) { - theNode.m_Flags.SetActive(inActive); - theNode.MarkDirty(qt3ds::render::NodeTransformDirtyFlag::TransformIsDirty); - } - } -}; - -struct SLayerTranslator : public SNodeTranslator -{ - SLayerTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SNodeTranslator(inInstance, *QT3DS_NEW(inAlloc, SLayer)()) - { - } - void PushTranslation(STranslation &inContext) override - { - SNodeTranslator::PushTranslation(inContext); - SLayer &theItem = static_cast<SLayer &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_LAYER_PROPERTIES - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Layer.m_AoSamplerate, - theItem.m_AoSamplerate); - } - void AppendChild(SGraphObject &inChild) override - { - if (GraphObjectTypes::IsNodeType(inChild.m_Type)) { - SNodeTranslator::AppendChild(inChild); - } else if (inChild.m_Type == GraphObjectTypes::Effect) { - SLayer &theItem = static_cast<SLayer &>(GetGraphObject()); - theItem.AddEffect(static_cast<SEffect &>(inChild)); - } else if (inChild.m_Type == GraphObjectTypes::RenderPlugin) { - SLayer &theItem = static_cast<SLayer &>(GetGraphObject()); - theItem.m_RenderPlugin = &static_cast<qt3ds::render::SRenderPlugin &>(inChild); - } - } - void ClearChildren() override - { - SNodeTranslator::ClearChildren(); - SLayer &theItem = static_cast<SLayer &>(GetGraphObject()); - SEffect *theLastChild = nullptr; - for (SEffect *theChild = theItem.m_FirstEffect; theChild; - theChild = theChild->m_NextEffect) { - if (theLastChild) - theLastChild->m_NextEffect = nullptr; - theLastChild = theChild; - theChild->m_Layer = nullptr; - } - theItem.m_FirstEffect = nullptr; - theItem.m_RenderPlugin = nullptr; - // Don't clear the light probe properties because those are added/removed as part of the - // normal - // property scan, they aren't added as generic children. - } -}; -struct SLightTranslator : public SNodeTranslator -{ - SLightTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SNodeTranslator(inInstance, *QT3DS_NEW(inAlloc, SLight)()) - { - } - void PushTranslation(STranslation &inContext) override - { - SNodeTranslator::PushTranslation(inContext); - SLight &theItem = static_cast<SLight &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_LIGHT_PROPERTIES - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Light.m_ShadowMapRes, - theItem.m_ShadowMapRes); - } - void AppendChild(SGraphObject &inChild) override { SNodeTranslator::AppendChild(inChild); } - void ClearChildren() override { SNodeTranslator::ClearChildren(); } -}; -struct SCameraTranslator : public SNodeTranslator -{ - SCameraTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SNodeTranslator(inInstance, *QT3DS_NEW(inAlloc, SCamera)()) - { - } - void PushTranslation(STranslation &inContext) override - { - SNodeTranslator::PushTranslation(inContext); - SCamera &theItem = static_cast<SCamera &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_CAMERA_PROPERTIES - } -}; -struct SModelTranslator : public SNodeTranslator -{ - SModelTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SNodeTranslator(inInstance, *QT3DS_NEW(inAlloc, SModel)()) - { - } - void PushTranslation(STranslation &inContext) override - { - SNodeTranslator::PushTranslation(inContext); - SModel &theItem = static_cast<SModel &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_MODEL_PROPERTIES - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Model.m_PoseRoot, - theItem.m_SkeletonRoot); - - theItem.m_FirstMaterial = nullptr; - for (long idx = 0, end = inContext.m_AssetGraph.GetChildCount(GetInstanceHandle()); - idx < end; ++idx) { - qt3dsdm::Qt3DSDMInstanceHandle theItemHandle = - inContext.m_AssetGraph.GetChild(GetInstanceHandle(), idx); - SGraphObjectTranslator *theTranslator = inContext.GetOrCreateTranslator(theItemHandle); - if (theTranslator && IsMaterial(theTranslator->GetGraphObject())) { - SGraphObject *theMaterial = &theTranslator->GetGraphObject(); - SetNextMaterialSibling(*theMaterial, nullptr); - theItem.AddMaterial(*theMaterial); - } - } - } - void AppendChild(SGraphObject &inChild) override - { - if (GraphObjectTypes::IsNodeType(inChild.m_Type)) { - SNodeTranslator::AppendChild(inChild); - } else if (IsMaterial(inChild)) { - SModel &theItem = static_cast<SModel &>(GetGraphObject()); - theItem.AddMaterial(inChild); - } else { - QT3DS_ASSERT(false); - } - } - void ClearChildren() override - { - SModel &theItem = static_cast<SModel &>(GetGraphObject()); - SNodeTranslator::ClearChildren(); - - SGraphObject *theLastMaterial = nullptr; - for (SGraphObject *theMaterial = theItem.m_FirstMaterial; theMaterial; - theMaterial = qt3ds::render::GetNextMaterialSibling(theMaterial)) { - if (theLastMaterial) - qt3ds::render::SetNextMaterialSibling(*theLastMaterial, nullptr); - theLastMaterial = theMaterial; - } - theItem.m_FirstMaterial = nullptr; - } -}; - -static SFloat2 ToFloat2(const Option<SValue> &inValue) -{ - if (inValue.hasValue()) - return inValue->getData<SFloat2>(); - return SFloat2(); -} - -static float ToFloat(const Option<SValue> &inValue) -{ - if (inValue.hasValue()) - return inValue->getData<QT3DSF32>(); - return 0.0f; -} - -struct SPathSubPathTranslator : public SGraphObjectTranslator -{ - eastl::vector<qt3ds::render::SPathAnchorPoint> m_PathBuffer; - SPathSubPathTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SGraphObjectTranslator(inInstance, *QT3DS_NEW(inAlloc, SPathSubPath)()) - { - } - - void PushTranslation(STranslation &inContext) override - { - SPathSubPath &theItem = static_cast<SPathSubPath &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_PATH_SUBPATH_PROPERTIES - m_PathBuffer.clear(); - Q3DStudio::IDocumentReader &theReader(inContext.m_Doc.GetDocumentReader()); - QT3DSU32 anchorCount = 0; - for (QT3DSI32 idx = 0, end = inContext.m_AssetGraph.GetChildCount(GetInstanceHandle()); - idx < end; ++idx) { - qt3dsdm::Qt3DSDMInstanceHandle theAnchor = - inContext.m_AssetGraph.GetChild(GetInstanceHandle(), idx); - if (theReader.GetObjectTypeName(theAnchor) == L"PathAnchorPoint") - ++anchorCount; - } - QT3DSU32 anchorIdx = 0; - for (QT3DSI32 idx = 0, end = inContext.m_AssetGraph.GetChildCount(GetInstanceHandle()); - idx < end; ++idx) { - qt3dsdm::Qt3DSDMInstanceHandle theAnchor = - inContext.m_AssetGraph.GetChild(GetInstanceHandle(), idx); - if (theReader.GetObjectTypeName(theAnchor) == L"PathAnchorPoint") { - SFloat2 theAnchorPos = ToFloat2(theReader.GetInstancePropertyValue( - theAnchor, - inContext.m_ObjectDefinitions.m_PathAnchorPoint.m_Position.m_Property)); - float theIncomingAngle = ToFloat(theReader.GetInstancePropertyValue( - theAnchor, - inContext.m_ObjectDefinitions.m_PathAnchorPoint.m_IncomingAngle.m_Property)); - float theIncomingDistance = ToFloat(theReader.GetInstancePropertyValue( - theAnchor, - inContext.m_ObjectDefinitions.m_PathAnchorPoint.m_IncomingDistance.m_Property)); - float theOutgoingDistance = ToFloat(theReader.GetInstancePropertyValue( - theAnchor, - inContext.m_ObjectDefinitions.m_PathAnchorPoint.m_OutgoingDistance.m_Property)); - qt3ds::render::SPathAnchorPoint thePoint(QT3DSVec2(theAnchorPos[0], theAnchorPos[1]), - theIncomingAngle, theIncomingAngle + 180.0f, - theIncomingDistance, theOutgoingDistance); - m_PathBuffer.push_back(thePoint); - ++anchorIdx; - } - } - inContext.m_Context.GetPathManager().SetPathSubPathData( - theItem, - qt3ds::foundation::toConstDataRef(m_PathBuffer.begin(), (QT3DSU32)m_PathBuffer.size())); - } - - void AppendChild(SGraphObject &) override {} - - void ClearChildren() override {} - - void SetActive(bool /*inActive*/) override {} -}; - -struct SPathTranslator : public SNodeTranslator -{ - SPathTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SNodeTranslator(inInstance, *QT3DS_NEW(inAlloc, SPath)()) - { - } - void AppendChild(SGraphObject &inChild) override - { - if (GraphObjectTypes::IsMaterialType(inChild.m_Type)) { - SPath &theItem = static_cast<SPath &>(GetGraphObject()); - theItem.AddMaterial(&inChild); - theItem.m_Flags.SetDirty(true); - } else if (inChild.m_Type == GraphObjectTypes::PathSubPath) { - SPath &theItem = static_cast<SPath &>(GetGraphObject()); - theItem.AddSubPath(static_cast<SPathSubPath &>(inChild)); - theItem.m_Flags.SetDirty(true); - } else { - SNodeTranslator::AppendChild(inChild); - } - } - - void ClearChildren() override - { - SNodeTranslator::ClearChildren(); - SPath &theItem = static_cast<SPath &>(GetGraphObject()); - theItem.ClearMaterials(); - theItem.ClearSubPaths(); - } - - void PushTranslation(STranslation &inContext) override - { - SNodeTranslator::PushTranslation(inContext); - SPath &theItem = static_cast<SPath &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_PATH_PROPERTIES - } -}; - -struct SDefaultMaterialTranslator : public SGraphObjectTranslator -{ - SDefaultMaterialTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, - qt3ds::NVAllocatorCallback &inAlloc) - : SGraphObjectTranslator(inInstance, *QT3DS_NEW(inAlloc, SDefaultMaterial)()) - { - } - - void PushTranslation(STranslation &inContext) override - { - SGraphObjectTranslator::PushTranslation(inContext); - SDefaultMaterial &theItem = static_cast<SDefaultMaterial &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_MATERIAL_PROPERTIES - - // qt3dsdm::Qt3DSDMInstanceHandle parent = inContext.m_AssetGraph.GetParent( - // GetInstanceHandle() ); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapIndirect, - theItem.m_Lightmaps.m_LightmapIndirect); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapRadiosity, - theItem.m_Lightmaps.m_LightmapRadiosity); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapShadow, - theItem.m_Lightmaps.m_LightmapShadow); - } - - void AppendChild(SGraphObject &) override {} - void ClearChildren() override {} - - void SetActive(bool /*inActive*/) override {} -}; - -struct SImageTranslator : public SGraphObjectTranslator -{ - SImageTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SGraphObjectTranslator(inInstance, *QT3DS_NEW(inAlloc, SImage)()) - { - } - - void PushTranslation(STranslation &inContext) override - { - SGraphObjectTranslator::PushTranslation(inContext); - SImage &theItem = static_cast<SImage &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_IMAGE_PROPERTIES - - theItem.m_Flags.SetDirty(true); - theItem.m_Flags.SetTransformDirty(true); - } - void AppendChild(SGraphObject &child) override - { - SImage &theItem = static_cast<SImage &>(GetGraphObject()); - if (child.m_Type == GraphObjectTypes::RenderPlugin) - theItem.m_RenderPlugin = &static_cast<qt3ds::render::SRenderPlugin &>(child); - } - void ClearChildren() override - { - SImage &theItem = static_cast<SImage &>(GetGraphObject()); - theItem.m_RenderPlugin = nullptr; - } - - void SetActive(bool /*inActive*/) override {} -}; - -struct STextTranslator : public SNodeTranslator -{ - STextTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SNodeTranslator(inInstance, *QT3DS_NEW(inAlloc, SText)()) - { - } - - void PushTranslation(STranslation &inContext) override - { - SNodeTranslator::PushTranslation(inContext); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - SText &theItem = static_cast<SText &>(GetGraphObject()); - ITERATE_QT3DS_RENDER_TEXT_PROPERTIES - theItem.m_Flags.SetTextDirty(true); - } -}; - -inline qt3ds::QT3DSVec2 ToRenderType(const qt3dsdm::SFloat2 &inType) -{ - return qt3ds::QT3DSVec2(inType.m_Floats[0], inType.m_Floats[1]); -} -inline qt3ds::QT3DSVec3 ToRenderType(const qt3dsdm::SFloat3 &inType) -{ - return qt3ds::QT3DSVec3(inType.m_Floats[0], inType.m_Floats[1], inType.m_Floats[2]); -} -inline qt3ds::QT3DSVec4 ToRenderType(const qt3dsdm::SFloat4 &inType) -{ - return qt3ds::QT3DSVec4(inType.m_Floats[0], inType.m_Floats[1], inType.m_Floats[2], - inType.m_Floats[3]); -} - -struct SDynamicObjectTranslator : public SGraphObjectTranslator -{ - typedef eastl::vector<eastl::pair<QT3DSU32, int>> TIdxToPropertyMap; - eastl::basic_string<qt3ds::foundation::TWCharEASTLConverter::TCharType> m_ConvertStr; - TIdxToPropertyMap m_PropertyMap; - - SDynamicObjectTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &, - SDynamicObject &inObject) - : SGraphObjectTranslator(inInstance, inObject) - { - } - - void PushTranslation(STranslation &inContext) override - { - SDynamicObject &theItem = static_cast<SDynamicObject &>(GetGraphObject()); - IDynamicObjectSystem &theSystem = inContext.m_Context.GetDynamicObjectSystem(); - using namespace qt3ds::render::dynamic; - using qt3ds::foundation::NVConstDataRef; - NVConstDataRef<SPropertyDefinition> theProperties = - theSystem.GetProperties(theItem.m_ClassName); - if (m_PropertyMap.size() == 0) { - for (QT3DSU32 idx = 0, end = theProperties.size(); idx < end; ++idx) { - const SPropertyDefinition &theDefinition(theProperties[idx]); - qt3ds::foundation::ConvertUTF(theDefinition.m_Name.c_str(), 0, m_ConvertStr); - const wchar_t *thePropName = - reinterpret_cast<const wchar_t *>(m_ConvertStr.c_str()); - qt3dsdm::Qt3DSDMPropertyHandle theProperty = - inContext.m_Reader.FindProperty(GetInstanceHandle(), thePropName); - if (theProperty.Valid()) - m_PropertyMap.push_back(eastl::make_pair(idx, theProperty.GetHandleValue())); - } - } - std::shared_ptr<IDataCore> theDataCore = - inContext.m_StudioSystem.GetFullSystem()->GetCoreSystem()->GetDataCore(); - for (TIdxToPropertyMap::iterator theIter = m_PropertyMap.begin(), end = m_PropertyMap.end(); - theIter != end; ++theIter) { - const SPropertyDefinition &theDefinition(theProperties[theIter->first]); - qt3dsdm::Qt3DSDMPropertyHandle theProperty = theIter->second; - // Sometimes it is possible to have dirty properties that no longer exist, e.g. - // when undoing standard material -> custom material change. We just ignore changes - // to such properties. - if (theDataCore->IsProperty(theProperty)) { - Option<qt3dsdm::SValue> theValueOpt = - inContext.m_Reader.GetInstancePropertyValue(GetInstanceHandle(), theProperty); - if (theValueOpt.hasValue()) { - qt3dsdm::SValue &theValue(*theValueOpt); - switch (qt3dsdm::GetValueType(theValue)) { - case qt3dsdm::DataModelDataType::Long: - if (theDefinition.m_DataType - == qt3ds::render::NVRenderShaderDataTypes::QT3DSI32) { - theItem.SetPropertyValue(theDefinition, - qt3dsdm::get<qt3ds::QT3DSI32>(theValue)); - } else { - QT3DS_ASSERT(false); - } - break; - case qt3dsdm::DataModelDataType::Bool: - if (theDefinition.m_DataType - == qt3ds::render::NVRenderShaderDataTypes::QT3DSRenderBool) { - theItem.SetPropertyValue(theDefinition, qt3dsdm::get<bool>(theValue)); - } else { - QT3DS_ASSERT(false); - } - break; - case qt3dsdm::DataModelDataType::Float: - if (theDefinition.m_DataType - == qt3ds::render::NVRenderShaderDataTypes::QT3DSF32) { - theItem.SetPropertyValue(theDefinition, qt3dsdm::get<float>(theValue)); - } else { - QT3DS_ASSERT(false); - } - break; - case qt3dsdm::DataModelDataType::Float2: - if (theDefinition.m_DataType - == qt3ds::render::NVRenderShaderDataTypes::QT3DSVec2) { - theItem.SetPropertyValue( - theDefinition, ToRenderType(qt3dsdm::get<qt3dsdm::SFloat2>(theValue))); - } else { - QT3DS_ASSERT(false); - } - break; - case qt3dsdm::DataModelDataType::Float3: - if (theDefinition.m_DataType - == qt3ds::render::NVRenderShaderDataTypes::QT3DSVec3) { - theItem.SetPropertyValue( - theDefinition, ToRenderType(qt3dsdm::get<qt3dsdm::SFloat3>(theValue))); - } else { - QT3DS_ASSERT(false); - } - break; - case qt3dsdm::DataModelDataType::Float4: - if (theDefinition.m_DataType - == qt3ds::render::NVRenderShaderDataTypes::QT3DSVec4) { - theItem.SetPropertyValue( - theDefinition, ToRenderType(qt3dsdm::get<qt3dsdm::SFloat4>(theValue))); - } else { - QT3DS_ASSERT(false); - } - break; - // Could be either an enum or a texture. - case qt3dsdm::DataModelDataType::String: { - qt3dsdm::TDataStrPtr theData = qt3dsdm::get<qt3dsdm::TDataStrPtr>(theValue); - if (theData) { - eastl::string theStr; - qt3ds::render::ConvertWideUTF(theData->GetData(), 0, theStr); - eastl::string theWorkspace; - theItem.SetPropertyValue( - theDefinition, theStr.c_str(), - inContext.m_Doc.GetCore()->getProjectFile() - .getProjectPath().toLocal8Bit().constData(), - theWorkspace, inContext.m_Context.GetStringTable()); - } - } break; - default: - QT3DS_ASSERT(false); - } - } - } - } - } - - void AppendChild(SGraphObject &) override {} - void ClearChildren() override {} -}; - -struct SEffectTranslator : public SDynamicObjectTranslator -{ - // TODO - move this map to inContext and have it looked up by name. - IEffectSystem *m_EffectSystem; - - SEffectTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc, - SEffect &inEffect) - : SDynamicObjectTranslator(inInstance, inAlloc, inEffect) - , m_EffectSystem(nullptr) - { - } - void PushTranslation(STranslation &inContext) override - { - m_EffectSystem = &inContext.m_Context.GetEffectSystem(); - SDynamicObjectTranslator::PushTranslation(inContext); - } - - void SetActive(bool inActive) override - { - SEffect &theItem = static_cast<SEffect &>(GetGraphObject()); - if (m_EffectSystem) - theItem.SetActive(inActive, *m_EffectSystem); - else - theItem.m_Flags.SetActive(inActive); - } - - void ResetEffect() override - { - SEffect &theItem = static_cast<SEffect &>(GetGraphObject()); - if (m_EffectSystem) - theItem.Reset(*m_EffectSystem); - } -}; -struct SCustomMaterialTranslator : public SDynamicObjectTranslator -{ - ICustomMaterialSystem *m_MaterialSystem; - - SCustomMaterialTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, - qt3ds::NVAllocatorCallback &inAlloc, SCustomMaterial &inMaterial) - : SDynamicObjectTranslator(inInstance, inAlloc, inMaterial) - , m_MaterialSystem(nullptr) - { - } - - void PushTranslation(STranslation &inContext) override - { - SDynamicObjectTranslator::PushTranslation(inContext); - SCustomMaterial &theItem = static_cast<SCustomMaterial &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_CUSTOM_MATERIAL_PROPERTIES - - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapIndirect, - theItem.m_Lightmaps.m_LightmapIndirect); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapRadiosity, - theItem.m_Lightmaps.m_LightmapRadiosity); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapShadow, - theItem.m_Lightmaps.m_LightmapShadow); - } - - void SetActive(bool inActive) override - { - if (m_MaterialSystem) { - SCustomMaterial &theItem = static_cast<SCustomMaterial &>(GetGraphObject()); - if (inActive != theItem.m_Flags.IsActive()) { - theItem.m_Flags.SetActive(inActive); - m_MaterialSystem->OnMaterialActivationChange(theItem, inActive); - } - } - } -}; -struct SReferencedMaterialTranslator : public SGraphObjectTranslator -{ - SReferencedMaterialTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, - qt3ds::NVAllocatorCallback &inAlloc) - : SGraphObjectTranslator(inInstance, *QT3DS_NEW(inAlloc, SReferencedMaterial)()) - { - } - void PushTranslation(STranslation &inContext) override - { - SGraphObjectTranslator::PushTranslation(inContext); - SReferencedMaterial &theItem = static_cast<SReferencedMaterial &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - ITERATE_QT3DS_RENDER_REFERENCED_MATERIAL_PROPERTIES - - theItem.m_Dirty.SetDirty(); - if (theItem.m_ReferencedMaterial == &theItem) { - qCCritical(qt3ds::INVALID_OPERATION, - "Referenced material is referencing itself."); - } else if (theItem.m_ReferencedMaterial - && theItem.m_ReferencedMaterial->m_Type == GraphObjectTypes::DefaultMaterial) { - SDefaultMaterial *theDefaultItem = - static_cast<SDefaultMaterial *>(theItem.m_ReferencedMaterial); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapIndirect, - theDefaultItem->m_Lightmaps.m_LightmapIndirect); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapRadiosity, - theDefaultItem->m_Lightmaps.m_LightmapRadiosity); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapShadow, - theDefaultItem->m_Lightmaps.m_LightmapShadow); - } else if (theItem.m_ReferencedMaterial - && theItem.m_ReferencedMaterial->m_Type == GraphObjectTypes::CustomMaterial) { - SCustomMaterial *theDefaultItem = - static_cast<SCustomMaterial *>(theItem.m_ReferencedMaterial); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapIndirect, - theDefaultItem->m_Lightmaps.m_LightmapIndirect); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapRadiosity, - theDefaultItem->m_Lightmaps.m_LightmapRadiosity); - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Lightmaps.m_LightmapShadow, - theDefaultItem->m_Lightmaps.m_LightmapShadow); - } - } - - void AppendChild(SGraphObject &) override {} - - void ClearChildren() override {} - - void SetActive(bool /*inActive*/) override {} -}; -using qt3ds::render::SRenderPlugin; -using qt3ds::render::SRenderPropertyValueUpdate; -using qt3ds::render::IRenderPluginClass; -using qt3ds::render::SRenderPluginPropertyDeclaration; -struct SRenderPluginPropertyUpdateFactory -{ - static void Add(eastl::vector<SRenderPropertyValueUpdate> &ioUpdates, float value, - const SRenderPluginPropertyDeclaration &theDec, IRenderPluginClass &) - { - ioUpdates.push_back(SRenderPropertyValueUpdate(theDec.m_Name, value)); - } - static void Add(eastl::vector<SRenderPropertyValueUpdate> &ioUpdates, qt3ds::QT3DSI32 value, - const SRenderPluginPropertyDeclaration &theDec, IRenderPluginClass &) - { - ioUpdates.push_back(SRenderPropertyValueUpdate(theDec.m_Name, value)); - } - static void Add(eastl::vector<SRenderPropertyValueUpdate> &ioUpdates, bool value, - const SRenderPluginPropertyDeclaration &theDec, IRenderPluginClass &) - { - ioUpdates.push_back(SRenderPropertyValueUpdate(theDec.m_Name, value)); - } - static void Add(eastl::vector<SRenderPropertyValueUpdate> &ioUpdates, qt3dsdm::TDataStrPtr value, - const SRenderPluginPropertyDeclaration &theDec, IRenderPluginClass &, - qt3ds::foundation::IStringTable &strTable) - { - if (value) { - ioUpdates.push_back( - SRenderPropertyValueUpdate(theDec.m_Name, strTable.RegisterStr(value->GetData()))); - } - } - static void Add(eastl::vector<SRenderPropertyValueUpdate> &ioUpdates, qt3dsdm::SStringRef value, - const SRenderPluginPropertyDeclaration &theDec, IRenderPluginClass &, - qt3ds::foundation::IStringTable &strTable) - { - ioUpdates.push_back( - SRenderPropertyValueUpdate(theDec.m_Name, strTable.RegisterStr(value.m_Id))); - } - static void Add(eastl::vector<SRenderPropertyValueUpdate> &ioUpdates, - const qt3dsdm::SFloat2 &value, const SRenderPluginPropertyDeclaration &theDec, - IRenderPluginClass &inClass) - { - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset).first, value.m_Floats[0])); - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset + 1).first, value.m_Floats[1])); - } - - static void Add(eastl::vector<SRenderPropertyValueUpdate> &ioUpdates, - const qt3dsdm::SFloat3 &value, const SRenderPluginPropertyDeclaration &theDec, - IRenderPluginClass &inClass) - { - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset).first, value.m_Floats[0])); - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset + 1).first, value.m_Floats[1])); - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset + 2).first, value.m_Floats[2])); - } - - static void Add(eastl::vector<SRenderPropertyValueUpdate> &ioUpdates, - const qt3dsdm::SFloat4 &value, const SRenderPluginPropertyDeclaration &theDec, - IRenderPluginClass &inClass) - { - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset).first, value.m_Floats[0])); - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset + 1).first, value.m_Floats[1])); - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset + 2).first, value.m_Floats[2])); - ioUpdates.push_back(SRenderPropertyValueUpdate( - inClass.GetPropertyValueInfo(theDec.m_StartOffset + 3).first, value.m_Floats[3])); - } -}; -struct SRenderPluginTranslator : public SGraphObjectTranslator -{ - eastl::vector<SRenderPropertyValueUpdate> m_PropertyUpdates; - - SRenderPluginTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, - qt3ds::NVAllocatorCallback &inAlloc) - : SGraphObjectTranslator(inInstance, *QT3DS_NEW(inAlloc, SRenderPlugin)()) - { - } - - void PushTranslation(STranslation &inContext) override - { - SRenderPlugin &theItem = static_cast<SRenderPlugin &>(GetGraphObject()); - // First, get the instance via resolving the source path. - Qt3DSDMPropertyHandle sourcepath = - inContext.m_Reader.FindProperty(GetInstanceHandle(), L"sourcepath"); - Option<SValue> theSourcePath = - inContext.m_Reader.GetInstancePropertyValue(GetInstanceHandle(), sourcepath); - qt3dsdm::TDataStrPtr theData = theSourcePath->getData<qt3dsdm::TDataStrPtr>(); - if (!theData) - return; - - Q3DStudio::CFilePath theFullPath = inContext.m_Doc.GetResolvedPathToDoc(theData->GetData()); - qt3ds::foundation::IStringTable &theStrTable = inContext.m_Context.GetStringTable(); - theItem.m_PluginPath = theStrTable.RegisterStr(theFullPath.toCString()); - qt3ds::render::IRenderPluginInstance *theInstance = - inContext.m_Context.GetRenderPluginManager().GetOrCreateRenderPluginInstance( - theItem.m_PluginPath, &theItem); - - // Couldn't load the instance, so we can't render the instance. - if (theInstance == nullptr) - return; - // Grab the instance's parent and get the properties that are specific to just that - // instance. - TInstanceHandleList derivationParents; - std::shared_ptr<IDataCore> theDataCore = - inContext.m_StudioSystem.GetFullSystem()->GetCoreSystem()->GetDataCore(); - theDataCore->GetInstanceParents(GetInstanceHandle(), derivationParents); - if (derivationParents.size() == 0) - return; - TPropertyHandleList theSpecificProperties; - theDataCore->GetInstanceProperties(derivationParents[0], theSpecificProperties); - eastl::string propStem; - eastl::string propname; - m_PropertyUpdates.clear(); - qt3ds::render::IRenderPluginClass &theClass = theInstance->GetPluginClass(); - using qt3ds::render::SRenderPluginPropertyDeclaration; - if (theClass.GetRegisteredProperties().size() == 0) { - for (size_t idx = 0, end = theSpecificProperties.size(); idx < end; ++idx) { - Qt3DSDMPropertyDefinition theProperty = - theDataCore->GetProperty(theSpecificProperties[idx]); - qt3dsdm::AdditionalMetaDataType::Value theMetaType = - inContext.m_StudioSystem.GetActionMetaData()->GetAdditionalMetaDataType( - GetInstanceHandle(), theSpecificProperties[idx]); - CRegisteredString thePropName(theStrTable.RegisterStr(theProperty.m_Name.c_str())); - switch (theProperty.m_Type) { - case DataModelDataType::Float: - theClass.RegisterProperty(SRenderPluginPropertyDeclaration( - thePropName, qt3ds::render::SRenderPluginPropertyTypes::Float)); - break; - case DataModelDataType::Float2: - theClass.RegisterProperty(SRenderPluginPropertyDeclaration( - thePropName, qt3ds::render::SRenderPluginPropertyTypes::Vector2)); - break; - case DataModelDataType::Float3: - if (theMetaType != AdditionalMetaDataType::Color) { - theClass.RegisterProperty(SRenderPluginPropertyDeclaration( - thePropName, qt3ds::render::SRenderPluginPropertyTypes::Vector3)); - } else { - theClass.RegisterProperty(SRenderPluginPropertyDeclaration( - thePropName, qt3ds::render::SRenderPluginPropertyTypes::Color)); - } - break; - case DataModelDataType::Float4: - if (theMetaType == AdditionalMetaDataType::Color) { - theClass.RegisterProperty(SRenderPluginPropertyDeclaration( - thePropName, qt3ds::render::SRenderPluginPropertyTypes::Color)); - } - break; - case DataModelDataType::Long: - theClass.RegisterProperty(SRenderPluginPropertyDeclaration( - thePropName, qt3ds::render::SRenderPluginPropertyTypes::Long)); - break; - case DataModelDataType::String: - case DataModelDataType::StringRef: - theClass.RegisterProperty(SRenderPluginPropertyDeclaration( - thePropName, qt3ds::render::SRenderPluginPropertyTypes::String)); - break; - case DataModelDataType::Bool: - theClass.RegisterProperty(SRenderPluginPropertyDeclaration( - thePropName, qt3ds::render::SRenderPluginPropertyTypes::Boolean)); - break; - default: - // Unsupported plugin property. - QT3DS_ASSERT(false); - break; - } - } - } - for (size_t idx = 0, end = theSpecificProperties.size(); idx < end; ++idx) { - Option<SValue> thePropValueOpt = inContext.m_Reader.GetInstancePropertyValue( - GetInstanceHandle(), theSpecificProperties[idx]); - if (thePropValueOpt.hasValue()) { - SValue &thePropValue = thePropValueOpt.getValue(); - Qt3DSDMPropertyDefinition theProperty = - theDataCore->GetProperty(theSpecificProperties[idx]); - SRenderPluginPropertyDeclaration theDeclaration(theClass.GetPropertyDeclaration( - theStrTable.RegisterStr(theProperty.m_Name.c_str()))); - - switch (thePropValue.getType()) { - case DataModelDataType::None: - QT3DS_ASSERT(false); - break; - case DataModelDataType::Float: - SRenderPluginPropertyUpdateFactory::Add( - m_PropertyUpdates, thePropValue.getData<float>(), theDeclaration, theClass); - break; - case DataModelDataType::Float2: - SRenderPluginPropertyUpdateFactory::Add(m_PropertyUpdates, - thePropValue.getData<SFloat2>(), - theDeclaration, theClass); - break; - case DataModelDataType::Float3: - SRenderPluginPropertyUpdateFactory::Add(m_PropertyUpdates, - thePropValue.getData<SFloat3>(), - theDeclaration, theClass); - break; - case DataModelDataType::Float4: - SRenderPluginPropertyUpdateFactory::Add(m_PropertyUpdates, - thePropValue.getData<SFloat4>(), - theDeclaration, theClass); - break; - case DataModelDataType::Long: - SRenderPluginPropertyUpdateFactory::Add( - m_PropertyUpdates, thePropValue.getData<qt3ds::QT3DSI32>(), theDeclaration, theClass); - break; - case DataModelDataType::String: - SRenderPluginPropertyUpdateFactory::Add(m_PropertyUpdates, - thePropValue.getData<TDataStrPtr>(), - theDeclaration, theClass, theStrTable); - break; - case DataModelDataType::Bool: - SRenderPluginPropertyUpdateFactory::Add( - m_PropertyUpdates, thePropValue.getData<bool>(), theDeclaration, theClass); - break; - case DataModelDataType::StringRef: - SRenderPluginPropertyUpdateFactory::Add(m_PropertyUpdates, - thePropValue.getData<SStringRef>(), - theDeclaration, theClass, theStrTable); - break; - default: - QT3DS_ASSERT(false); - break; - } - } - } - theInstance->Update(NVConstDataRef<SRenderPropertyValueUpdate>(m_PropertyUpdates.data(), - m_PropertyUpdates.size())); - } - void AppendChild(SGraphObject &) override {} - void ClearChildren() override {} - void SetActive(bool inActive) override - { - SRenderPlugin &theItem = static_cast<SRenderPlugin &>(GetGraphObject()); - theItem.m_Flags.SetActive(inActive); - } -}; - -struct SAliasTranslator : public SGraphObjectTranslator -{ - SGraphObjectTranslator *m_ReferenceTree; - Qt3DSDMInstanceHandle m_ReferencedInstance; - SAliasTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, qt3ds::NVAllocatorCallback &inAlloc) - : SGraphObjectTranslator(inInstance, *QT3DS_NEW(inAlloc, SNode)()) - , m_ReferenceTree(nullptr) - { - } - void RecurseAndCreateTranslators(STranslation &inContext, - qt3dsdm::Qt3DSDMInstanceHandle inInstance) - { - for (QT3DSI32 idx = 0, end = inContext.m_AssetGraph.GetChildCount(inInstance); idx < end; - ++idx) { - qt3dsdm::Qt3DSDMInstanceHandle theChild = inContext.m_AssetGraph.GetChild(inInstance, idx); - inContext.GetOrCreateTranslator(theChild, m_InstanceHandle); - RecurseAndCreateTranslators(inContext, theChild); - } - } - void PushTranslation(STranslation &inContext) override - { - STranslatorDataModelParser theParser(inContext, GetInstanceHandle()); - Option<SObjectRefType> theData = theParser.GetPropertyValue<SObjectRefType>( - inContext.m_ObjectDefinitions.m_Alias.m_ReferencedNode); - m_ReferencedInstance = Qt3DSDMInstanceHandle(); - m_ReferenceTree = nullptr; - ((SNode *)m_GraphObject)->m_Flags.SetDirty(true); - if (theData.hasValue()) { - m_ReferencedInstance = - inContext.m_Reader.GetInstanceForObjectRef(GetInstanceHandle(), *theData); - if (inContext.m_Reader.IsInstance(m_ReferencedInstance)) { - m_ReferenceTree = - inContext.GetOrCreateTranslator(m_ReferencedInstance, m_InstanceHandle); - if (m_ReferenceTree - && !GraphObjectTypes::IsNodeType(m_ReferenceTree->GetGraphObject().m_Type)) { - QT3DS_ASSERT(false); - m_ReferenceTree = nullptr; - m_ReferencedInstance = Qt3DSDMInstanceHandle(); - } else { - RecurseAndCreateTranslators(inContext, m_ReferencedInstance); - } - } - } - } - - void AfterRenderGraphIsBuilt(STranslation &inContext) override - { - SNode &theItem = static_cast<SNode &>(GetGraphObject()); - STranslatorDataModelParser theParser(inContext, m_InstanceHandle); - ITERATE_QT3DS_RENDER_NODE_PROPERTIES - theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Node.m_BoneId, - theItem.m_SkeletonId); - bool ignoresParent = false; - if (theParser.ParseProperty(inContext.m_ObjectDefinitions.m_Node.m_IgnoresParent, - ignoresParent)) - theItem.m_Flags.SetIgnoreParentTransform(ignoresParent); - theItem.m_Flags.SetDirty(true); - } - void AppendChild(SGraphObject &inObject) override - { - if (m_ReferenceTree) - m_ReferenceTree->AppendChild(inObject); - } - void ClearChildren() override - { - if (m_ReferenceTree) - m_ReferenceTree->ClearChildren(); - } - void SetActive(bool inActive) override - { - SNode &theItem = static_cast<SNode &>(GetGraphObject()); - theItem.m_Flags.SetActive(inActive); - } - SGraphObject &GetGraphObject() override - { - if (m_ReferenceTree) - return *m_ReferenceTree->m_GraphObject; - return *m_GraphObject; - } - qt3dsdm::Qt3DSDMInstanceHandle GetSceneGraphInstanceHandle() override - { - if (m_ReferencedInstance.Valid()) - return m_ReferencedInstance; - return m_InstanceHandle; - } - Qt3DSDMInstanceHandle GetInstanceHandle() override { return m_InstanceHandle; } - - SGraphObject &GetNonAliasedGraphObject() override { return *m_GraphObject; } -}; -} - -void SGraphObjectTranslator::PushTranslation(STranslation &inTranslatorContext) -{ - Q3DStudio::CString theId = inTranslatorContext.m_Reader.GetFileId(GetInstanceHandle()); - if (theId.size()) - GetGraphObject().m_Id = - inTranslatorContext.m_Context.GetStringTable().RegisterStr(theId.c_str()); -} - -bool STranslation::IncludeNode(const SNode &inNode) -{ - SGraphObjectTranslator *theTranslator = inNode.m_UserData.DynamicCast<SGraphObjectTranslator>(); - if (theTranslator - && m_Doc.GetDocumentReader().IsCurrentlyActive(theTranslator->GetInstanceHandle())) - return true; - return false; -} - -void STranslation::ReleaseEffect(qt3dsdm::Qt3DSDMInstanceHandle inInstance) -{ - if (m_Reader.IsInstance(inInstance) == false) - return; - - qt3dsdm::ComposerObjectTypes::Enum theType = m_ObjectDefinitions.GetType(inInstance); - qt3dsdm::Qt3DSDMInstanceHandle theParentClass = m_Reader.GetFirstBaseClass(inInstance); - - if (theType == NULL && theParentClass.Valid()) - theType = m_ObjectDefinitions.GetType(theParentClass); - - if (theType == qt3dsdm::ComposerObjectTypes::Effect) { - IEffectSystem &theSystem = m_Context.GetEffectSystem(); - if (theParentClass.Valid()) { - Q3DStudio::CString theInstanceName = m_Reader.GetName(theParentClass); - CRegisteredString theNameStr = - m_Context.GetStringTable().RegisterStr(theInstanceName); - - if (theSystem.IsEffectRegistered(theNameStr)) { - TInstanceToTranslatorMap::iterator theTranslatorList = - m_TranslatorMap.find(inInstance); - if (theTranslatorList != m_TranslatorMap.end()) - m_TranslatorMap.erase(theTranslatorList); - theSystem.SetEffectRequiresCompilation(theNameStr, true); - } - } - } -} - -SGraphObjectTranslator *STranslation::CreateTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance) -{ - SGraphObjectTranslator *theNewTranslator = nullptr; - qt3dsdm::ComposerObjectTypes::Enum theType = m_ObjectDefinitions.GetType(inInstance); - qt3dsdm::Qt3DSDMInstanceHandle theParentClass = m_Reader.GetFirstBaseClass(inInstance); - if (theType == NULL && theParentClass.Valid()) - theType = m_ObjectDefinitions.GetType(theParentClass); - - // For the subset of possible instances, pick out the valid translators. - switch (theType) { - case qt3dsdm::ComposerObjectTypes::Group: - case qt3dsdm::ComposerObjectTypes::Component: - case qt3dsdm::ComposerObjectTypes::Node: - theNewTranslator = QT3DS_NEW(m_Allocator, SNodeTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Scene: - theNewTranslator = QT3DS_NEW(m_Allocator, SSceneTranslator)(inInstance, m_Allocator); - m_Scene = static_cast<SScene *>(&theNewTranslator->GetGraphObject()); - m_Scene->m_Presentation = &m_Presentation; - break; - case qt3dsdm::ComposerObjectTypes::Layer: - theNewTranslator = QT3DS_NEW(m_Allocator, SLayerTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Light: - theNewTranslator = QT3DS_NEW(m_Allocator, SLightTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Camera: - theNewTranslator = QT3DS_NEW(m_Allocator, SCameraTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Model: - theNewTranslator = QT3DS_NEW(m_Allocator, SModelTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Image: - theNewTranslator = QT3DS_NEW(m_Allocator, SImageTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Text: - theNewTranslator = QT3DS_NEW(m_Allocator, STextTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Material: - theNewTranslator = QT3DS_NEW(m_Allocator, SDefaultMaterialTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::ReferencedMaterial: - theNewTranslator = - QT3DS_NEW(m_Allocator, SReferencedMaterialTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Alias: - theNewTranslator = QT3DS_NEW(m_Allocator, SAliasTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Path: - theNewTranslator = QT3DS_NEW(m_Allocator, SPathTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::SubPath: - theNewTranslator = QT3DS_NEW(m_Allocator, SPathSubPathTranslator)(inInstance, m_Allocator); - break; - case qt3dsdm::ComposerObjectTypes::Effect: { - IEffectSystem &theSystem = m_Context.GetEffectSystem(); - if (theParentClass.Valid()) { - Q3DStudio::CString theInstanceName = m_Reader.GetName(theParentClass); - CRegisteredString theNameStr = - m_Context.GetStringTable().RegisterStr(theInstanceName); - - if (theSystem.IsEffectRegistered(theNameStr) - && theSystem.DoesEffectRequireCompilation(theNameStr)) { - theSystem.UnregisterEffect(theNameStr); - } - - if (!theSystem.IsEffectRegistered(theNameStr)) { - // We assume the effect has already been registered and such. - qt3dsdm::IMetaData &theMetaData(*m_StudioSystem.GetActionMetaData()); - Q3DStudio::CString theInstancePath = m_Reader.GetSourcePath(theParentClass); - Option<qt3dsdm::SMetaDataEffect> theMetaEffect = - theMetaData.GetEffectBySourcePath( - m_Context.GetStringTable().GetNarrowStr(theInstancePath)); - if (theMetaEffect.hasValue()) { - qt3ds::render::IUIPLoader::CreateEffectClassFromMetaEffect( - theNameStr, m_Context.GetFoundation(), theSystem, theMetaEffect, - m_Context.GetStringTable()); - theSystem.SetEffectRequiresCompilation(theNameStr, true); - } - } - - if (theSystem.IsEffectRegistered(theNameStr)) { - theNewTranslator = QT3DS_NEW(m_Allocator, SEffectTranslator)( - inInstance, m_Allocator, - *theSystem.CreateEffectInstance(theNameStr, m_Allocator)); - } - } - } - break; - case qt3dsdm::ComposerObjectTypes::CustomMaterial: { - ICustomMaterialSystem &theSystem = m_Context.GetCustomMaterialSystem(); - if (theParentClass.Valid()) { - Q3DStudio::CString theInstanceName = m_Reader.GetName(theParentClass); - CRegisteredString theNameStr = - m_Context.GetStringTable().RegisterStr(theInstanceName); - if (!theSystem.IsMaterialRegistered(theNameStr)) { - // We assume the effect has already been registered and such. - qt3dsdm::IMetaData &theMetaData(*m_StudioSystem.GetActionMetaData()); - Q3DStudio::CString theInstancePath = m_Reader.GetSourcePath(theParentClass); - Option<qt3dsdm::SMetaDataCustomMaterial> theMaterialData = - theMetaData.GetMaterialBySourcePath( - m_Context.GetStringTable().GetNarrowStr(theInstancePath)); - if (theMaterialData.hasValue()) { - qt3ds::render::IUIPLoader::CreateMaterialClassFromMetaMaterial( - theNameStr, m_Context.GetFoundation(), theSystem, theMaterialData, - m_Context.GetStringTable()); - } - } - if (theSystem.IsMaterialRegistered(theNameStr)) { - theNewTranslator = QT3DS_NEW(m_Allocator, SCustomMaterialTranslator)( - inInstance, m_Allocator, - *theSystem.CreateCustomMaterial(theNameStr, m_Allocator)); - static_cast<SCustomMaterialTranslator *>(theNewTranslator)->m_MaterialSystem = - &theSystem; - } - } - } - break; - case qt3dsdm::ComposerObjectTypes::RenderPlugin: { - theNewTranslator = QT3DS_NEW(m_Allocator, SRenderPluginTranslator)(inInstance, m_Allocator); - } - break; - default: - break; - } - - return theNewTranslator; -} - -bool CompareTranslator(const STranslation::THandleTranslatorPair &first, - const STranslation::THandleTranslatorPair &second) -{ - return first.first == second.first; -} - -struct STranslatorPredicate -{ - Qt3DSDMInstanceHandle m_Instance; - STranslatorPredicate(Qt3DSDMInstanceHandle &ins) - : m_Instance(ins) - { - } - bool operator()(const STranslation::THandleTranslatorPair &first) const - { - return first.first == m_Instance; - } -}; - -Option<STranslation::THandleTranslatorPair> -FindTranslator(STranslation::THandleTranslatorPairList &inList, - Qt3DSDMInstanceHandle inInstance = Qt3DSDMInstanceHandle()) -{ - STranslation::THandleTranslatorPairList::iterator iter = - eastl::find_if(inList.begin(), inList.end(), STranslatorPredicate(inInstance)); - if (iter != inList.end()) - return *iter; - return Empty(); -} - -SGraphObjectTranslator *STranslation::GetOrCreateTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance) -{ - return GetOrCreateTranslator(inInstance, Qt3DSDMInstanceHandle()); -} - -SGraphObjectTranslator * -STranslation::GetOrCreateTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, - qt3dsdm::Qt3DSDMInstanceHandle inAliasInstance) -{ - TInstanceToTranslatorMap::iterator theTranslatorList = - m_TranslatorMap.insert(eastl::make_pair(inInstance, THandleTranslatorPairList())).first; - THandleTranslatorPairList &theList = theTranslatorList->second; - Option<STranslation::THandleTranslatorPair> theExistingTranslator = - FindTranslator(theList, inAliasInstance); - - if (theExistingTranslator.hasValue()) { - return theExistingTranslator->second; - } - if (m_Reader.IsInstance(inInstance) == false) - return nullptr; - - SGraphObjectTranslator *theNewTranslator = CreateTranslator(inInstance); - if (theNewTranslator != nullptr) { - theNewTranslator->m_AliasInstanceHandle = inAliasInstance; - m_DirtySet.insert(*theNewTranslator); - theList.push_back(THandleTranslatorPair(inAliasInstance, theNewTranslator)); - } - - return theNewTranslator; -} - -STranslation::THandleTranslatorPairList & -STranslation::GetTranslatorsForInstance(qt3dsdm::Qt3DSDMInstanceHandle inInstance) -{ - return m_TranslatorMap.insert(eastl::make_pair(inInstance, THandleTranslatorPairList())) - .first->second; -} - -qt3dsdm::Qt3DSDMInstanceHandle STranslation::GetAnchorPoint(QT3DSU32 inAnchorIndex) -{ - SGraphObjectTranslator *thePathTranslator = - static_cast<SGraphObjectTranslator *>(m_PathWidget->GetNode().m_UserData.m_UserData); - if (thePathTranslator == nullptr) - return qt3dsdm::Qt3DSDMInstanceHandle(); - qt3dsdm::Qt3DSDMInstanceHandle thePathHandle = thePathTranslator->GetInstanceHandle(); - QT3DSU32 theAnchorIndex = 0; - for (QT3DSI32 idx = 0, end = m_AssetGraph.GetChildCount(thePathHandle); idx < end; ++idx) { - qt3dsdm::Qt3DSDMInstanceHandle theChildInstance = m_AssetGraph.GetChild(thePathHandle, idx); - if (m_Doc.GetDocumentReader().GetObjectTypeName(theChildInstance) == L"SubPath") { - QT3DSI32 numAnchors = m_AssetGraph.GetChildCount(theChildInstance); - QT3DSU32 endIndex = theAnchorIndex + (QT3DSU32)numAnchors; - if (endIndex > inAnchorIndex) { - return m_AssetGraph.GetChild(theChildInstance, inAnchorIndex - theAnchorIndex); - } else - theAnchorIndex = endIndex; - } - } - return qt3dsdm::Qt3DSDMInstanceHandle(); -} - -qt3dsdm::Qt3DSDMInstanceHandle STranslation::GetAnchorPoint(SPathPick &inPick) -{ - return GetAnchorPoint(inPick.m_AnchorIndex); -} - -namespace qt3ds { -namespace studio { - struct SEditCameraLayerTranslator : public SLayerTranslator - { - SEditCameraLayerTranslator(qt3dsdm::Qt3DSDMInstanceHandle inInstance, - qt3ds::NVAllocatorCallback &inAlloc) - : SLayerTranslator(inInstance, inAlloc) - { - } - void PushTranslation(STranslation &) override - { - SLayer &theItem = static_cast<SLayer &>(GetGraphObject()); - theItem.m_Flags.SetActive(true); - } - void AppendChild(SGraphObject &inChild) override - { - if (GraphObjectTypes::IsNodeType(inChild.m_Type)) { - SNodeTranslator::AppendChild(inChild); - } - } - }; -} -} - -STranslation::STranslation(IStudioRenderer &inRenderer, IQt3DSRenderContext &inContext) - : m_Renderer(inRenderer) - , m_Context(inContext) - , m_Doc(*g_StudioApp.GetCore()->GetDoc()) - , m_Reader(m_Doc.GetDocumentReader()) - , m_ObjectDefinitions( - m_Doc.GetStudioSystem()->GetClientDataModelBridge()->GetObjectDefinitions()) - , m_StudioSystem(*m_Doc.GetStudioSystem()) - , m_FullSystem(*m_Doc.GetStudioSystem()->GetFullSystem()) - , m_AssetGraph(*m_Doc.GetAssetGraph()) - , m_Allocator(inContext.GetRenderContext().GetFoundation()) - , m_TranslatorMap(inContext.GetAllocator(), "STranslation::m_TranslatorMap") - , m_DirtySet(inContext.GetAllocator(), "STranslation::m_DirtySet") - , m_Scene(nullptr) - , m_SignalConnections(inContext.GetAllocator(), "STranslation::m_SignalConnections") - , m_ComponentSecondsDepth(0) - , m_KeyRepeat(0) - , m_EditCameraEnabled(false) - , m_EditLightEnabled(false) - , m_Viewport(0, 0) - , m_EditCameraLayerTranslator(nullptr) - , m_PixelBuffer(inContext.GetAllocator(), "STranslation::m_PixelBuffer") - , m_editModeCamerasAndLights(inContext.GetAllocator(), - "STranslation::m_editModeCamerasAndLights") - , m_GuideAllocator(inContext.GetAllocator(), "STranslation::m_GuideAllocator") -{ - m_EditCamera.m_Flags.SetActive(true); - m_EditLight.m_Flags.SetActive(true); - qt3dsdm::Qt3DSDMInstanceHandle theScene = m_AssetGraph.GetRoot(0); - m_GraphIterator.ClearResults(); - m_AssetGraph.GetDepthFirst(m_GraphIterator, theScene); - for (; !m_GraphIterator.IsDone(); ++m_GraphIterator) { - qt3dsdm::Qt3DSDMInstanceHandle theInstance(m_GraphIterator.GetCurrent()); - GetOrCreateTranslator(theInstance); - } - qt3dsdm::IStudioFullSystemSignalProvider *theProvider = m_FullSystem.GetSignalProvider(); - m_SignalConnections.push_back( - theProvider->ConnectInstanceCreated(std::bind(&STranslation::DoMarkDirty, - this, std::placeholders::_1))); - m_SignalConnections.push_back(theProvider->ConnectInstanceDeleted( - std::bind(&STranslation::ReleaseTranslation, this, std::placeholders::_1))); - m_SignalConnections.push_back( - theProvider->ConnectInstancePropertyValue(std::bind(&STranslation::DoMarkDirty, - this, std::placeholders::_1))); - m_SignalConnections.push_back(m_AssetGraph.ConnectChildAdded( - std::bind(&STranslation::MarkGraphInstanceDirty, this, std::placeholders::_1, - std::placeholders::_2))); - m_SignalConnections.push_back(m_AssetGraph.ConnectChildMoved( - std::bind(&STranslation::MarkGraphInstanceDirty, this, std::placeholders::_1, - std::placeholders::_2))); - m_SignalConnections.push_back(m_AssetGraph.ConnectChildRemoved( - std::bind(&STranslation::MarkGraphInstanceDirty, this, std::placeholders::_1, - std::placeholders::_2))); - m_SignalConnections.push_back(theProvider->ConnectBeginComponentSeconds( - std::bind(&STranslation::MarkBeginComponentSeconds, this, std::placeholders::_1))); - m_SignalConnections.push_back(theProvider->ConnectComponentSeconds( - std::bind(&STranslation::MarkComponentSeconds, this, std::placeholders::_1))); - - ::CColor color = CStudioPreferences::GetRulerBackgroundColor(); // Rectangles under tick marks - m_rectColor = QT3DSVec4(color.GetRed() / 255.f, - color.GetGreen() / 255.f, - color.GetBlue() / 255.f, - 1.f); - color = CStudioPreferences::GetRulerTickColor(); // Tick marks - m_lineColor = QT3DSVec4(color.GetRed() / 255.f, - color.GetGreen() / 255.f, - color.GetBlue() / 255.f, - 1.f); - color = CStudioPreferences::GetGuideColor(); - m_guideColor = QT3DSVec4(color.GetRed() / 255.f, - color.GetGreen() / 255.f, - color.GetBlue() / 255.f, - 1.f); - color = CStudioPreferences::GetGuideSelectedColor(); - m_selectedGuideColor = QT3DSVec4(color.GetRed() / 255.f, - color.GetGreen() / 255.f, - color.GetBlue() / 255.f, - 1.f); - color = CStudioPreferences::GetGuideFillColor(); // Not sure what this is used for - m_guideFillColor = QT3DSVec4(color.GetRed() / 255.f, - color.GetGreen() / 255.f, - color.GetBlue() / 255.f, - 1.f); - color = CStudioPreferences::GetGuideFillSelectedColor(); // Not sure what this is used for - m_selectedGuideFillColor = QT3DSVec4(color.GetRed() / 255.f, - color.GetGreen() / 255.f, - color.GetBlue() / 255.f, - 1.f); -} - -void STranslation::BuildRenderGraph(SGraphObjectTranslator &inParent, bool scenePreviewPass, - Qt3DSDMInstanceHandle inAliasHandle) -{ - SGraphObjectTranslator &theParentTranslator(inParent); - theParentTranslator.ClearChildren(); - if (m_EditCameraEnabled && !scenePreviewPass) { - const auto objectType = theParentTranslator.GetGraphObject().m_Type; - if (objectType == GraphObjectTypes::Layer) { - theParentTranslator.AppendChild(m_EditCamera); - if (m_EditLightEnabled) { - m_EditLight.m_Parent = &m_EditCamera; - m_EditCamera.m_FirstChild = &m_EditLight; - } else { - m_EditCamera.m_FirstChild = nullptr; - m_EditLight.m_Parent = nullptr; - } - } else if (objectType == GraphObjectTypes::Light) { - m_editModeCamerasAndLights.push_back(&inParent); - } else if (objectType == GraphObjectTypes::Camera) { - m_editModeCamerasAndLights.push_back(&inParent); - } - } - - // Alias handles propagate down the scene graph. - if (inParent.GetInstanceHandle() != inParent.GetSceneGraphInstanceHandle()) - inAliasHandle = inParent.GetInstanceHandle(); - for (long idx = 0, end = m_AssetGraph.GetChildCount(inParent.GetSceneGraphInstanceHandle()); - idx < end; ++idx) { - qt3dsdm::Qt3DSDMInstanceHandle theChild( - m_AssetGraph.GetChild(inParent.GetSceneGraphInstanceHandle(), idx)); - SGraphObjectTranslator *theTranslator = GetOrCreateTranslator(theChild, inAliasHandle); - if (theTranslator == nullptr) - continue; - - // We we have edit cameras active, we only render the active layer and we remove any cameras - // in the active layer. Furthermore if our edit light is active, then we also remove any - // active lights in the layer. - if (m_EditCameraEnabled && !scenePreviewPass) { - if (theTranslator->GetGraphObject().m_Type == GraphObjectTypes::Layer) { - if (theChild == m_Doc.GetActiveLayer()) { - if (m_EditCameraLayerTranslator != nullptr - && m_EditCameraLayerTranslator->GetInstanceHandle() != theChild) { - QT3DS_FREE(m_Allocator, m_EditCameraLayerTranslator); - m_EditCameraLayerTranslator = nullptr; - } - if (!m_EditCameraLayerTranslator) { - m_EditCameraLayerTranslator = - QT3DS_NEW(m_Allocator, SEditCameraLayerTranslator)(theChild, - m_Allocator); - } - theTranslator = m_EditCameraLayerTranslator; - theParentTranslator.AppendChild(theTranslator->GetGraphObject()); - BuildRenderGraph(*m_EditCameraLayerTranslator, scenePreviewPass); - } - } else { - theParentTranslator.AppendChild(theTranslator->GetGraphObject()); - BuildRenderGraph(theChild, scenePreviewPass, inAliasHandle); - - if (theTranslator->GetGraphObject().m_Type == GraphObjectTypes::Effect) - theTranslator->SetActive(false); - else if (theTranslator->GetGraphObject().m_Type == GraphObjectTypes::Camera) - theTranslator->SetActive(false); - else if (theTranslator->GetGraphObject().m_Type == GraphObjectTypes::Light - && m_EditLightEnabled == true) - theTranslator->SetActive(false); - else - theTranslator->SetActive(m_Reader.IsCurrentlyActive(theChild)); - } - } else // Else build the graph and it will be an exact copy of the asset graph. - { - theParentTranslator.AppendChild(theTranslator->GetGraphObject()); - if (m_Reader.IsCurrentlyActive(theChild)) { - BuildRenderGraph(theChild, scenePreviewPass, inAliasHandle); - theTranslator->SetActive(true); - } else { - theTranslator->SetActive(false); - DeactivateScan(*theTranslator, inAliasHandle); - } - } - } - if (GraphObjectTypes::Layer == theParentTranslator.GetGraphObject().m_Type) - m_Context.GetRenderer().ChildrenUpdated( - static_cast<SLayer &>(theParentTranslator.GetGraphObject())); - - // Allow certain nodes to override their children. - theParentTranslator.AfterRenderGraphIsBuilt(*this); -} - -void STranslation::DeactivateScan(SGraphObjectTranslator &inParent, - Qt3DSDMInstanceHandle inAliasHandle) -{ - // Alias handles propagate down the scene graph. - if (inParent.GetInstanceHandle() != inParent.GetSceneGraphInstanceHandle()) - inAliasHandle = inParent.GetInstanceHandle(); - for (long idx = 0, end = m_AssetGraph.GetChildCount(inParent.GetSceneGraphInstanceHandle()); - idx < end; ++idx) { - qt3dsdm::Qt3DSDMInstanceHandle theChild( - m_AssetGraph.GetChild(inParent.GetSceneGraphInstanceHandle(), idx)); - SGraphObjectTranslator *theTranslator = GetOrCreateTranslator(theChild, inAliasHandle); - if (theTranslator == nullptr) - continue; - theTranslator->SetActive(false); - DeactivateScan(*theTranslator, inAliasHandle); - } -} - -// We build the render graph every time we render. This may seem wasteful -void STranslation::BuildRenderGraph(qt3dsdm::Qt3DSDMInstanceHandle inParent, bool scenePreviewPass, - Qt3DSDMInstanceHandle inAliasHandle) -{ - SGraphObjectTranslator *theParentTranslator = GetOrCreateTranslator(inParent, inAliasHandle); - if (theParentTranslator == nullptr) - return; - if (m_Reader.IsCurrentlyActive(inParent) == false) { - theParentTranslator->SetActive(false); - return; - } - BuildRenderGraph(*theParentTranslator, scenePreviewPass, inAliasHandle); -} - -void STranslation::ReleaseTranslation(Q3DStudio::TIdentifier inInstance) -{ - m_TranslatorMap.erase(inInstance); -} - -void STranslation::MarkDirty(qt3dsdm::Qt3DSDMInstanceHandle inInstance) -{ - // Anchor points are not handled individually. - if (m_Reader.GetObjectTypeName(inInstance) == L"PathAnchorPoint") - inInstance = m_AssetGraph.GetParent(inInstance); - GetOrCreateTranslator(inInstance); - - THandleTranslatorPairList &theTranslators = GetTranslatorsForInstance(inInstance); - for (size_t idx = 0, end = theTranslators.size(); idx < end; ++idx) { - m_DirtySet.insert(*theTranslators[(eastl::allocator::size_type)idx].second); - // Reset effect when effect parameters change, as with certain corner cases - // some effects would accumulate ~infinitely and result would not reflect - // actual parameter setting unless reset (f.ex corona, other blur types) - m_DirtySet.back()->ResetEffect(); - } - RequestRender(); -} - -QT3DSVec2 STranslation::GetPreviewViewportDimensions() const -{ - CStudioProjectSettings *theSettings = m_Doc.GetCore()->GetStudioProjectSettings(); - QSize thePresSize = theSettings->getPresentationSize(); - return QT3DSVec2(thePresSize.width(), thePresSize.height()); -} - -qt3ds::QT3DSVec2 STranslation::GetOverlayPreviewDimensions() const -{ - QT3DSVec2 ret(0.0f); - if (hasRoomForOverlayPreview()) { - CStudioProjectSettings *theSettings = m_Doc.GetCore()->GetStudioProjectSettings(); - QSize thePresSize = theSettings->getPresentationSize(); - ret = QT3DSVec2(thePresSize.width(), thePresSize.height()); - - const float aspect = ret.x / ret.y; - if (aspect > 1.0) { - ret.x = m_overlayPreviewSize > ret.x ? ret.x : m_overlayPreviewSize; - ret.y = ret.x / aspect; - } else { - ret.y = m_overlayPreviewSize > ret.y ? ret.y : m_overlayPreviewSize; - ret.x = ret.y * aspect; - } - } - return ret; -} - -void STranslation::PreRender(bool scenePreviewPass) -{ - // Run through the entire asset graph and mark active or inactive if we have an - // associated render representation. - // If we cache all the components and some of their state then we don't have to do this - // but for now it is more stable to run through the graph. - // There is always one root, the scene. - TIdentifier theRoot = m_AssetGraph.GetRoot(0); - if (!scenePreviewPass) - m_editModeCamerasAndLights.clear(); - ClearDirtySet(); - m_EditLightEnabled = CStudioPreferences::editModeLightingEnabled(); - BuildRenderGraph(theRoot, scenePreviewPass); - QT3DSVec2 theViewportDims(GetViewportDimensions()); - if (scenePreviewPass) { - m_Context.SetScaleMode(qt3ds::render::ScaleModes::FitSelected); - theViewportDims = GetPreviewViewportDimensions(); - } else { - m_Context.SetScaleMode(qt3ds::render::ScaleModes::ExactSize); - } - - static const QT3DSVec4 matteColor(CStudioPreferences::matteColor().redF(), - CStudioPreferences::matteColor().greenF(), - CStudioPreferences::matteColor().blueF(), 1.0f); - m_Context.SetMatteColor(matteColor); - // Ensure the camera points where it should - if (m_EditCameraEnabled && !scenePreviewPass) { - m_EditCameraInfo.ApplyToCamera(m_EditCamera, theViewportDims); - m_EditLight.MarkDirty(qt3ds::render::NodeTransformDirtyFlag::TransformIsDirty); - } - - if (m_Scene) { - CStudioProjectSettings *theSettings = m_Doc.GetCore()->GetStudioProjectSettings(); - QSize thePresSize = theSettings->getPresentationSize(); - // The presentation sizes are used for when we have to render a layer offscreen. - // If their width and height isn't set, then they use the presentation dimensions. - m_Presentation.m_PresentationDimensions - = QT3DSVec2((QT3DSF32)thePresSize.width(), (QT3DSF32)thePresSize.height()); - m_Context.SetWindowDimensions( - QSize((QT3DSU32)theViewportDims.x, (QT3DSU32)theViewportDims.y)); - m_Context.SetPresentationDimensions( - QSize((QT3DSU32)m_Presentation.m_PresentationDimensions.x, - (QT3DSU32)m_Presentation.m_PresentationDimensions.y)); - - // set if we draw geometry in wireframe mode - m_Context.SetWireframeMode(CStudioPreferences::IsWireframeModeOn()); - - if (m_EditCameraEnabled && !scenePreviewPass) { - m_Presentation.m_PresentationDimensions = theViewportDims; - m_Context.SetPresentationDimensions( - QSize((QT3DSU32)theViewportDims.x, (QT3DSU32)theViewportDims.y)); - m_Context.SetSceneColor(QT3DSVec4(0.0f, 0.0f, 0.0f, 1.0f)); - } else { - - TIdentifier theRoot = m_AssetGraph.GetRoot(0); - SGraphObjectTranslator *theSceneTranslator = GetOrCreateTranslator(theRoot); - if (theSceneTranslator) { - SScene &theScene = static_cast<SScene &>(theSceneTranslator->GetGraphObject()); - if (scenePreviewPass) { - if (theScene.m_UseClearColor) - m_Context.SetMatteColor(theScene.m_ClearColor); - else - m_Context.SetMatteColor(QT3DSVec4(0.0f, 0.0f, 0.0f, 1.0f)); - } else { - if (theScene.m_UseClearColor) - m_Context.SetSceneColor(theScene.m_ClearColor); - else - m_Context.SetSceneColor(QT3DSVec4(QT3DSVec3(0.0f), 1.0f)); - } - } - } - } - if (m_EditCameraEnabled == false && g_StudioApp.IsAuthorZoom()) { - if (m_Presentation.m_PresentationDimensions.x > theViewportDims.x - || m_Presentation.m_PresentationDimensions.y > theViewportDims.y) { - m_Context.SetScaleMode(qt3ds::render::ScaleModes::FitSelected); - } - } -} - -static void CreatePixelRect(STranslation &inTranslation, QT3DSF32 left, QT3DSF32 right, QT3DSF32 bottom, - QT3DSF32 top, QT3DSVec4 color) -{ - SPGRect *theRect = QT3DS_NEW(inTranslation.m_GuideAllocator, SPGRect)(); - theRect->m_Left = left; - theRect->m_Right = right; - theRect->m_Top = top; - theRect->m_Bottom = bottom; - theRect->m_FillColor = color; - inTranslation.m_GuideContainer.push_back(theRect); -} - -static void CreatePixelVertLine(STranslation &inTranslation, QT3DSF32 inXPos, QT3DSF32 inBottom, - QT3DSF32 inTop, QT3DSVec4 color) -{ - SPGVertLine *theLine = QT3DS_NEW(inTranslation.m_GuideAllocator, SPGVertLine)(); - theLine->m_X = inXPos; - theLine->m_Bottom = inBottom; - theLine->m_Top = inTop; - theLine->m_LineColor = color; - inTranslation.m_GuideContainer.push_back(theLine); -} - -static void CreatePixelHorzLine(STranslation &inTranslation, QT3DSF32 inYPos, QT3DSF32 inLeft, - QT3DSF32 inRight, QT3DSVec4 color) -{ - SPGHorzLine *theLine = QT3DS_NEW(inTranslation.m_GuideAllocator, SPGHorzLine)(); - theLine->m_Y = inYPos; - theLine->m_Left = inLeft; - theLine->m_Right = inRight; - theLine->m_LineColor = color; - inTranslation.m_GuideContainer.push_back(theLine); -} - -static void CreateTopBottomTickMarks(STranslation &inTranslation, QT3DSF32 posX, QT3DSF32 innerBottom, - QT3DSF32 innerTop, QT3DSF32 outerBottom, QT3DSF32 outerTop, - QT3DSF32 lineHeight, QT3DSVec4 lineColor) -{ - CreatePixelVertLine(inTranslation, posX, innerBottom - lineHeight, innerBottom, lineColor); - CreatePixelVertLine(inTranslation, posX, innerTop, innerTop + lineHeight, lineColor); -} - -static void DrawTickMarksOnHorizontalRects(STranslation &inTranslation, QT3DSF32 innerLeft, - QT3DSF32 innerRight, QT3DSF32 innerBottom, QT3DSF32 innerTop, - QT3DSF32 outerBottom, QT3DSF32 outerTop, QT3DSVec4 lineColor) -{ - QT3DSF32 centerPosX = floor(innerLeft + (innerRight - innerLeft) / 2.0f + .5f); - CreateTopBottomTickMarks(inTranslation, centerPosX, innerBottom, innerTop, outerBottom, - outerTop, 15, lineColor); - for (QT3DSU32 incrementor = 10; - (centerPosX + incrementor) < innerRight && (centerPosX - incrementor) > innerLeft; - incrementor += 10) { - QT3DSF32 rightEdge = centerPosX + incrementor; - QT3DSF32 leftEdge = centerPosX - incrementor; - QT3DSF32 lineHeight = 0; - if (incrementor % 100 == 0) - lineHeight = 11; - else if (incrementor % 20) - lineHeight = 4; - else - lineHeight = 2; - - if (rightEdge < innerRight) - CreateTopBottomTickMarks(inTranslation, rightEdge, innerBottom, innerTop, outerBottom, - outerTop, lineHeight, lineColor); - if (leftEdge > innerLeft) - CreateTopBottomTickMarks(inTranslation, leftEdge, innerBottom, innerTop, outerBottom, - outerTop, lineHeight, lineColor); - } -} - -static void CreateLeftRightTickMarks(STranslation &inTranslation, QT3DSF32 inYPos, QT3DSF32 innerLeft, - QT3DSF32 innerRight, QT3DSF32 outerLeft, QT3DSF32 outerRight, - QT3DSF32 lineLength, QT3DSVec4 lineColor) -{ - CreatePixelHorzLine(inTranslation, inYPos, innerLeft - lineLength, innerLeft, lineColor); - CreatePixelHorzLine(inTranslation, inYPos, innerRight, innerRight + lineLength, lineColor); -} - -static void DrawTickMarksOnVerticalRects(STranslation &inTranslation, QT3DSF32 innerLeft, - QT3DSF32 innerRight, QT3DSF32 innerBottom, QT3DSF32 innerTop, - QT3DSF32 outerLeft, QT3DSF32 outerRight, QT3DSVec4 lineColor) -{ - QT3DSF32 centerPosY = floor(innerBottom + (innerTop - innerBottom) / 2.0f + .5f); - CreateLeftRightTickMarks(inTranslation, centerPosY, innerLeft, innerRight, outerLeft, - outerRight, 15, lineColor); - for (QT3DSU32 incrementor = 10; - (centerPosY + incrementor) < innerTop && (centerPosY - incrementor) > innerBottom; - incrementor += 10) { - QT3DSF32 topEdge = centerPosY + incrementor; - QT3DSF32 bottomEdge = centerPosY - incrementor; - QT3DSF32 lineHeight = 0; - if (incrementor % 100 == 0) - lineHeight = 11; - else if (incrementor % 20) - lineHeight = 4; - else - lineHeight = 2; - - if (topEdge < innerTop) - CreateLeftRightTickMarks(inTranslation, topEdge, innerLeft, innerRight, outerLeft, - outerRight, lineHeight, lineColor); - if (bottomEdge > innerBottom) - CreateLeftRightTickMarks(inTranslation, bottomEdge, innerLeft, innerRight, outerLeft, - outerRight, lineHeight, lineColor); - } -} - -class IGuideElementFactory -{ -protected: - virtual ~IGuideElementFactory() {} -public: - virtual void CreateLine(QT3DSF32 inPos) = 0; - virtual void CreateRect(QT3DSF32 inPosMin, QT3DSF32 inPosMax) = 0; -}; - -static void CreateGuide(IGuideElementFactory &inFactory, QT3DSF32 inPos, QT3DSF32 inWidth) -{ - QT3DSF32 halfWidth = inWidth / 2.0f; - QT3DSF32 leftLine = floor(inPos + 1.0f - halfWidth); - inFactory.CreateLine(leftLine); - // Then we are done if not enough width - if (inWidth < 2.0f) - return; - - QT3DSF32 rightLine = leftLine + inWidth - 1; - inFactory.CreateLine(rightLine); - - if (inWidth < 3.0f) - return; - QT3DSF32 rectStart = leftLine + 1; - QT3DSF32 rectStop = rectStart + inWidth - 2.0f; - inFactory.CreateRect(rectStart, rectStop); -} - -struct SHorizontalGuideFactory : public IGuideElementFactory -{ - STranslation &m_Translation; - QT3DSF32 m_Start; - QT3DSF32 m_Stop; - QT3DSVec4 m_LineColor; - QT3DSVec4 m_FillColor; - SHorizontalGuideFactory(STranslation &trans, QT3DSF32 start, QT3DSF32 stop, QT3DSVec4 lineColor, - QT3DSVec4 fillColor) - : m_Translation(trans) - , m_Start(start) - , m_Stop(stop) - , m_LineColor(lineColor) - , m_FillColor(fillColor) - { - } - void CreateLine(QT3DSF32 inPos) override - { - CreatePixelHorzLine(m_Translation, inPos, m_Start, m_Stop, m_LineColor); - } - - void CreateRect(QT3DSF32 inPosMin, QT3DSF32 inPosMax) override - { - CreatePixelRect(m_Translation, m_Start, m_Stop, inPosMin, inPosMax, m_FillColor); - } -}; - -struct SVerticalGuideFactory : public IGuideElementFactory -{ - STranslation &m_Translation; - QT3DSF32 m_Start; - QT3DSF32 m_Stop; - QT3DSVec4 m_LineColor; - QT3DSVec4 m_FillColor; - SVerticalGuideFactory(STranslation &trans, QT3DSF32 start, QT3DSF32 stop, QT3DSVec4 lineColor, - QT3DSVec4 fillColor) - : m_Translation(trans) - , m_Start(start) - , m_Stop(stop) - , m_LineColor(lineColor) - , m_FillColor(fillColor) - { - } - void CreateLine(QT3DSF32 inPos) override - { - CreatePixelVertLine(m_Translation, inPos, m_Start, m_Stop, m_LineColor); - } - - void CreateRect(QT3DSF32 inPosMin, QT3DSF32 inPosMax) override - { - CreatePixelRect(m_Translation, inPosMin, inPosMax, m_Start, m_Stop, m_FillColor); - } -}; - -qt3ds::render::NVRenderRect STranslation::GetPreviewViewport() const -{ - QT3DSVec2 vp = GetPreviewViewportDimensions(); - return qt3ds::render::NVRenderRect(0, 0, vp.x, vp.y); -} - -qt3ds::render::NVRenderRect STranslation::GetOverlayPreviewViewport() const -{ - QT3DSVec2 vp = GetOverlayPreviewDimensions(); - return qt3ds::render::NVRenderRect(0, 0, vp.x, vp.y); -} - -bool STranslation::hasRoomForOverlayPreview() const -{ - QT3DSVec2 vp(GetViewportDimensions()); - return vp.x > m_overlayPreviewSize && vp.y > m_overlayPreviewSize; -} - -void STranslation::Render(int inWidgetId, bool inDrawGuides, bool scenePreviewPass, - bool overlayPreview) -{ - // For now, we just render. - // Next step will be to get the bounding boxes and such setup. - // but we will want a custom renderer to do that. - if (m_Scene) { - // Note that begin frame is called before we allocate the bounding box and axis widgets so - // that we can take advantage of the renderer's per-frame-allocator. - m_Context.BeginFrame(true); - - qt3dsdm::TInstanceHandleList theHandles = m_Doc.GetSelectedValue().GetSelectedInstances(); - - if (scenePreviewPass) { - qt3ds::render::NVRenderContext &renderContext(m_Context.GetRenderContext()); - QT3DSVec2 previewDims(GetPreviewViewportDimensions()); - if (m_previewFboDimensions != previewDims) { - m_previewFboDimensions = previewDims; - if (m_previewFbo) - m_Context.GetResourceManager().Release(*m_previewFbo); - if (m_previewRenderBuffer) - m_Context.GetResourceManager().Release(*m_previewRenderBuffer); - if (m_previewTexture) - m_Context.GetResourceManager().Release(*m_previewTexture); - m_previewFbo = nullptr; - m_previewRenderBuffer = nullptr; - m_previewTexture = nullptr; - } - if (!m_previewFbo) - m_previewFbo = m_Context.GetResourceManager().AllocateFrameBuffer(); - if (!m_previewTexture) { - m_previewTexture = renderContext.CreateTexture2D(); - m_previewTexture->SetTextureData(qt3ds::foundation::NVDataRef<qt3ds::QT3DSU8>(), - 0, previewDims.x, previewDims.y, - qt3ds::render::NVRenderTextureFormats::RGBA8); - m_previewFbo->Attach( - qt3ds::render::NVRenderFrameBufferAttachments::Color0, - qt3ds::render::NVRenderTextureOrRenderBuffer(*m_previewTexture)); - } - if (!m_previewRenderBuffer) { - m_previewRenderBuffer = m_Context.GetResourceManager().AllocateRenderBuffer( - previewDims.x, previewDims.y, - qt3ds::render::NVRenderRenderBufferFormats::Depth24); - m_previewFbo->Attach( - qt3ds::render::NVRenderFrameBufferAttachments::Depth, - qt3ds::render::NVRenderTextureOrRenderBuffer(*m_previewRenderBuffer)); - } - renderContext.SetRenderTarget(m_previewFbo); - } else { - // Render the bounding boxes and extra widgets. - // This is called *before* the render because these sort of appendages need to be added - // to the layer renderables. - - // Don't show the bounding box or pivot for the component we are *in* the component - SGraphObjectTranslator *theTranslator = nullptr; - long theToolMode = g_StudioApp.GetToolMode(); - int theCameraToolMode = m_EditCameraEnabled - ? (theToolMode & STUDIO_CAMERATOOL_MASK) : 0; - bool shouldDisplayWidget = false; - if (theCameraToolMode == 0) { - switch (theToolMode) { - default: - break; - case STUDIO_TOOLMODE_MOVE: - case STUDIO_TOOLMODE_ROTATE: - case STUDIO_TOOLMODE_SCALE: - shouldDisplayWidget = true; - break; - }; - } - - bool selectedPath = false; - - for (size_t selectedIdx = 0, selectedEnd = theHandles.size(); selectedIdx < selectedEnd; - ++selectedIdx) { - qt3dsdm::Qt3DSDMInstanceHandle theInstance = theHandles[selectedIdx]; - if (theInstance - != m_Doc.GetDocumentReader().GetComponentForSlide(m_Doc.GetActiveSlide())) { - if (m_Doc.GetDocumentReader().GetObjectTypeName(theInstance) - == L"PathAnchorPoint") { - theInstance = m_AssetGraph.GetParent(m_AssetGraph.GetParent(theInstance)); - shouldDisplayWidget = false; - } - theTranslator = GetOrCreateTranslator(theInstance); - // Get the tool mode right now. - if (theTranslator) { - GraphObjectTypes::Enum theType(theTranslator->GetGraphObject().m_Type); - if (CStudioPreferences::IsBoundingBoxesOn()) { - switch (theType) { - case GraphObjectTypes::Node: - DrawGroupBoundingBoxes(*theTranslator); - break; - case GraphObjectTypes::Text: - case GraphObjectTypes::Model: - case GraphObjectTypes::Layer: - case GraphObjectTypes::Light: - case GraphObjectTypes::Path: - DrawNonGroupBoundingBoxes(*theTranslator); - break; - default: - break; - } - } - - // Don't draw the axis if there is a widget. - if (CStudioPreferences::ShouldDisplayPivotPoint()) { - switch (theTranslator->GetGraphObject().m_Type) { - case GraphObjectTypes::Node: - case GraphObjectTypes::Text: - case GraphObjectTypes::Model: - drawPivot(*theTranslator); - break; - default: - break; - } - } - - if (theType == GraphObjectTypes::Path && selectedPath == false) { - selectedPath = true; - if (!m_PathWidget) { - m_PathWidget = qt3ds::widgets::IPathWidget::CreatePathWidget( - m_Context.GetAllocator(), m_Context); - } - m_PathWidget->SetNode( - static_cast<SNode &>(theTranslator->GetGraphObject())); - m_Context.GetRenderer().AddRenderWidget(*m_PathWidget); - } - } - } - } - - if (theHandles.size() > 1) - theTranslator = nullptr; - - qt3ds::widgets::IStudioWidget *theNextWidget(nullptr); - if (theTranslator - && GraphObjectTypes::IsNodeType(theTranslator->GetGraphObject().m_Type) - && theTranslator->GetGraphObject().m_Type != GraphObjectTypes::Layer) { - - qt3ds::render::SNode &theNode( - static_cast<qt3ds::render::SNode &>(theTranslator->GetGraphObject())); - const GraphObjectTypes::Enum type = theTranslator->GetGraphObject().m_Type; - - // Don't draw widgets for non-visible nodes - bool isActive = theNode.m_Flags.IsActive(); - // Light and camera nodes are never active, so check from doc - if (type == GraphObjectTypes::Camera || type == GraphObjectTypes::Light) - isActive = m_Reader.IsCurrentlyActive(theHandles[0]); - shouldDisplayWidget = shouldDisplayWidget && isActive; - - SCamera *theRenderCamera = m_Context.GetRenderer().GetCameraForNode(theNode); - bool isActiveCamera = theRenderCamera == (static_cast<SCamera *>(&theNode)); - if (shouldDisplayWidget && !isActiveCamera - && ((type == GraphObjectTypes::Camera && m_EditCameraEnabled) - || type != GraphObjectTypes::Camera)) { - switch (theToolMode) { - default: - QT3DS_ASSERT(false); - break; - case STUDIO_TOOLMODE_MOVE: - // Render translation widget - if (!m_TranslationWidget) { - m_TranslationWidget - = qt3ds::widgets::IStudioWidget::CreateTranslationWidget( - m_Context.GetAllocator()); - } - theNextWidget = m_TranslationWidget.mPtr; - break; - case STUDIO_TOOLMODE_ROTATE: - if (!m_RotationWidget) { - m_RotationWidget = qt3ds::widgets::IStudioWidget::CreateRotationWidget( - m_Context.GetAllocator()); - } - theNextWidget = m_RotationWidget.mPtr; - break; - - case STUDIO_TOOLMODE_SCALE: - if (!m_ScaleWidget) { - m_ScaleWidget = qt3ds::widgets::IStudioWidget::CreateScaleWidget( - m_Context.GetAllocator()); - } - theNextWidget = m_ScaleWidget.mPtr; - break; - } - - if (theNextWidget) { - SNode &node = static_cast<SNode &>(theTranslator->GetGraphObject()); - theNextWidget->SetNode(node); - m_Context.GetRenderer().AddRenderWidget(*theNextWidget); - } - } - } - if (m_LastRenderedWidget.mPtr && m_LastRenderedWidget.mPtr != theNextWidget) - ResetWidgets(); - - m_LastRenderedWidget = theNextWidget; - if (m_LastRenderedWidget) { - m_LastRenderedWidget->SetSubComponentId(inWidgetId); - switch (g_StudioApp.GetManipulationMode()) { - case StudioManipulationModes::Local: - m_LastRenderedWidget->SetRenderWidgetMode( - qt3ds::render::RenderWidgetModes::Local); - break; - case StudioManipulationModes::Global: - m_LastRenderedWidget->SetRenderWidgetMode( - qt3ds::render::RenderWidgetModes::Global); - break; - default: - QT3DS_ASSERT(false); - break; - } - } - } - Option<NVRenderRect> viewport = m_Context.GetRenderContext().GetViewport(); - if (scenePreviewPass) { - m_Context.GetRenderContext().SetViewport(GetPreviewViewport()); - m_Context.SetSceneColor(Option<QT3DSVec4>()); - } - - m_Scene->PrepareForRender(scenePreviewPass ? GetPreviewViewportDimensions() - : GetViewportDimensions(), m_Context); - - m_Context.RunRenderTasks(); - - if (!scenePreviewPass && m_EditCameraEnabled) { - if (m_GradientWidget == nullptr) - m_GradientWidget = qt3ds::widgets::SGradientWidget - ::CreateGradientWidget(m_Context.GetAllocator()); - // render gradient background - SNode *node = GetEditCameraLayer(); - m_GradientWidget->SetNode(*node); - m_GradientWidget->Render(m_Context.GetRenderWidgetContext(), - m_Context.GetRenderContext(), - m_EditCameraInfo.IsOrthographic()); - } - - m_Scene->Render(scenePreviewPass - ? GetPreviewViewportDimensions() - : GetViewportDimensions(), m_Context, SScene::DoNotClear); - - if (!scenePreviewPass && m_editModeCamerasAndLights.size() > 0) { - if (!m_VisualAidWidget) { - m_VisualAidWidget = qt3ds::widgets::SVisualAidWidget - ::CreateVisualAidWidget(m_Context.GetAllocator()); - } - for (SGraphObjectTranslator *translator : m_editModeCamerasAndLights) { - SGraphObject &object = translator->GetGraphObject(); - qt3dsdm::Qt3DSDMInstanceHandle handle = translator->GetInstanceHandle(); - m_VisualAidWidget->setSelected(false); - - for (int j = 0; j < theHandles.size(); ++j) { - if (handle == theHandles[j]) { - m_VisualAidWidget->setSelected(true); - break; - } - } - - if (object.m_Type == GraphObjectTypes::Camera) { - if (m_InnerRect.isNull()) { - // this happens when the initial view is not the camera view - NVRenderRect thePresentationViewport = m_Context.GetPresentationViewport(); - m_InnerRect.m_Left = thePresentationViewport.m_X; - m_InnerRect.m_Right = thePresentationViewport.m_X - + thePresentationViewport.m_Width; - m_InnerRect.m_Bottom = thePresentationViewport.m_Y; - m_InnerRect.m_Top = thePresentationViewport.m_Y - + thePresentationViewport.m_Height; - } - - QT3DSVec2 dim = QT3DSVec2(m_InnerRect.m_Right - m_InnerRect.m_Left, - m_InnerRect.m_Top - m_InnerRect.m_Bottom); - NVRenderRectF theViewport(0, 0, dim.x, dim.y); - static_cast<SCamera *>(&object)->CalculateGlobalVariables(theViewport, dim); - } - m_VisualAidWidget->SetNode(static_cast<SNode *>(&object)); - m_VisualAidWidget->Render(m_Context.GetRenderWidgetContext(), - m_Context.GetRenderContext()); - } - } - - if (inDrawGuides && !m_EditCameraEnabled && !g_StudioApp.IsAuthorZoom()) { - m_GuideContainer.clear(); - // Figure out the matte area. - NVRenderRect theContextViewport = m_Context.GetContextViewport(); - NVRenderRect thePresentationViewport = m_Context.GetPresentationViewport(); - m_Context.GetRenderContext().SetViewport(theContextViewport); - QT3DSI32 innerLeft = thePresentationViewport.m_X; - QT3DSI32 innerRight = thePresentationViewport.m_X + thePresentationViewport.m_Width; - QT3DSI32 innerBottom = thePresentationViewport.m_Y; - QT3DSI32 innerTop = thePresentationViewport.m_Y + thePresentationViewport.m_Height; - - QT3DSI32 outerLeft = innerLeft - 16; - QT3DSI32 outerRight = innerRight + 16; - QT3DSI32 outerBottom = innerBottom - 16; - QT3DSI32 outerTop = innerTop + 16; - // Retain the rects for picking purposes. - m_InnerRect = SRulerRect(innerLeft, innerTop, innerRight, innerBottom); - m_OuterRect = SRulerRect(outerLeft, outerTop, outerRight, outerBottom); - - // Draw tick marks around the presentation - CreatePixelRect(*this, (QT3DSF32)outerLeft, (QT3DSF32)innerLeft, (QT3DSF32)innerBottom, - (QT3DSF32)innerTop, m_rectColor); - CreatePixelRect(*this, (QT3DSF32)innerRight, (QT3DSF32)outerRight, - (QT3DSF32)innerBottom, (QT3DSF32)innerTop, m_rectColor); - CreatePixelRect(*this, (QT3DSF32)innerLeft, (QT3DSF32)innerRight, (QT3DSF32)outerBottom, - (QT3DSF32)innerBottom, m_rectColor); - CreatePixelRect(*this, (QT3DSF32)innerLeft, (QT3DSF32)innerRight, (QT3DSF32)innerTop, - (QT3DSF32)outerTop, m_rectColor); - DrawTickMarksOnHorizontalRects(*this, (QT3DSF32)innerLeft, (QT3DSF32)innerRight, - (QT3DSF32)innerBottom, (QT3DSF32)innerTop, - (QT3DSF32)outerBottom, (QT3DSF32)outerTop, m_lineColor); - DrawTickMarksOnVerticalRects(*this, (QT3DSF32)innerLeft, (QT3DSF32)innerRight, - (QT3DSF32)innerBottom, (QT3DSF32)innerTop, - (QT3DSF32)outerLeft, (QT3DSF32)outerRight, m_lineColor); - qt3dsdm::TGuideHandleList theGuides = m_Doc.GetDocumentReader().GetGuides(); - qt3dsdm::Qt3DSDMGuideHandle theSelectedGuide; - Q3DStudio::SSelectedValue theSelection = m_Doc.GetSelectedValue(); - if (theSelection.getType() == Q3DStudio::SelectedValueTypes::Guide) - theSelectedGuide = theSelection.getData<qt3dsdm::Qt3DSDMGuideHandle>(); - - // Draw guides - for (size_t guideIdx = 0, guideEnd = theGuides.size(); guideIdx < guideEnd; - ++guideIdx) { - qt3dsdm::SGuideInfo theInfo = - m_Doc.GetDocumentReader().GetGuideInfo(theGuides[guideIdx]); - bool isGuideSelected = theGuides[guideIdx] == theSelectedGuide; - QT3DSVec4 theColor = isGuideSelected ? m_selectedGuideColor : m_guideColor; - QT3DSVec4 theFillColor = isGuideSelected ? m_selectedGuideFillColor - : m_guideFillColor; - switch (theInfo.m_Direction) { - case qt3dsdm::GuideDirections::Horizontal: { - SHorizontalGuideFactory theFactory(*this, (QT3DSF32)innerLeft, (QT3DSF32)innerRight, - theColor, theFillColor); - CreateGuide(theFactory, (QT3DSF32)m_InnerRect.m_Bottom + theInfo.m_Position, - (QT3DSF32)theInfo.m_Width); - } break; - case qt3dsdm::GuideDirections::Vertical: { - SVerticalGuideFactory theFactory(*this, (QT3DSF32)innerBottom, (QT3DSF32)innerTop, - theColor, theFillColor); - CreateGuide(theFactory, (QT3DSF32)m_InnerRect.m_Left + theInfo.m_Position, - (QT3DSF32)theInfo.m_Width); - } break; - default: - QT3DS_ASSERT(false); - break; - } - } - m_Context.GetPixelGraphicsRenderer().Render( - qt3ds::foundation::toDataRef(m_GuideContainer.data(), m_GuideContainer.size())); - - m_GuideContainer.clear(); - m_GuideAllocator.reset(); - } - - if (!scenePreviewPass && m_previewTexture) { - if (overlayPreview) { - // Draw the overlay framebuffer - qt3ds::render::NVRenderContext &renderContext(m_Context.GetRenderContext()); - renderContext.SetViewport(GetOverlayPreviewViewport()); - qt3ds::render::SCamera camera; - camera.MarkDirty(qt3ds::render::NodeTransformDirtyFlag::TransformIsDirty); - camera.m_Flags.SetOrthographic(true); - QT3DSVec2 previewDims(GetOverlayPreviewDimensions()); - camera.CalculateGlobalVariables( - render::NVRenderRectF(0, 0, previewDims.x, previewDims.y), previewDims); - QT3DSMat44 theVP; - camera.CalculateViewProjectionMatrix(theVP); - renderContext.SetCullingEnabled(false); - renderContext.SetBlendingEnabled(false); - renderContext.SetDepthTestEnabled(false); - renderContext.SetDepthWriteEnabled(false); - m_Context.GetRenderer().RenderQuad(previewDims, theVP, *m_previewTexture); - } else { - // Hack: For some reason, the m_previewTexture is only valid later if it is - // actually drawn somewhere during the main render pass, so draw a dummy quad - m_Context.GetRenderContext().SetViewport(NVRenderRect(0, 0, 0, 0)); - m_Context.GetRenderer().RenderQuad(QT3DSVec2(0.0f), QT3DSMat44(), - *m_previewTexture); - } - } - - if (scenePreviewPass) - m_Context.GetRenderContext().SetRenderTarget(nullptr); - - m_Context.EndFrame(); - m_Context.GetRenderContext().SetViewport(viewport); - QT3DSVec2 theViewportDims(GetViewportDimensions()); - m_Context.SetWindowDimensions(QSize((QT3DSU32)theViewportDims.x, - (QT3DSU32)theViewportDims.y)); - CStudioProjectSettings *theSettings = m_Doc.GetCore()->GetStudioProjectSettings(); - QSize thePresSize = theSettings->getPresentationSize(); - m_Presentation.m_PresentationDimensions = - QT3DSVec2((QT3DSF32)thePresSize.width(), (QT3DSF32)thePresSize.height()); - - if (m_ZoomRender.hasValue()) { - RenderZoomRender(*m_ZoomRender); - m_ZoomRender = Empty(); - } - - // Render the pick buffer, useful for debugging why a widget wasn't hit. - /* - if ( m_PickBuffer ) - { - qt3ds::render::NVRenderContext& theRenderContext( m_Context.GetRenderContext() ); - qt3ds::render::STextureDetails thePickDetails = m_PickBuffer->GetTextureDetails(); - theRenderContext.SetViewport( qt3ds::render::NVRenderRect( 0, 0, thePickDetails.m_Width, - thePickDetails.m_Height ) ); - qt3ds::render::SCamera theCamera; - theCamera.MarkDirty( qt3ds::render::NodeTransformDirtyFlag::TransformIsDirty ); - theCamera.m_Flags.SetOrthographic( true ); - QT3DSVec2 theDimensions( (QT3DSF32)thePickDetails.m_Width, (QT3DSF32)thePickDetails.m_Height ); - theCamera.CalculateGlobalVariables( render::NVRenderRectF( 0, 0, theDimensions.x, - theDimensions.y ), theDimensions ); - QT3DSMat44 theVP; - theCamera.CalculateViewProjectionMatrix( theVP ); - theRenderContext.SetCullingEnabled( false ); - theRenderContext.SetBlendingEnabled( false ); - theRenderContext.SetDepthTestEnabled( false ); - theRenderContext.SetDepthWriteEnabled( false ); - m_Context.GetRenderer().RenderQuad( theDimensions, theVP, *m_PickBuffer ); - }*/ - } -} - -void STranslation::ResetWidgets() -{ - if (m_ScaleWidget) - m_ScaleWidget->SetAxisScale(QT3DSVec3(1, 1, 1)); - if (m_RotationWidget) - m_RotationWidget->ClearRotationEdges(); - m_CumulativeRotation = 0.0f; -} - -void STranslation::DoPrepareForDrag(SNode *inSelectedNode) -{ - if (inSelectedNode == nullptr) - return; - - m_MouseDownNode = *inSelectedNode; - m_MouseDownParentGlobalTransformInverse = Empty(); - m_MouseDownParentRotationInverse = Empty(); - m_MouseDownGlobalRotation = Empty(); - // Orphan this node manually since it is a straight copy - m_MouseDownNode.m_Parent = nullptr; - m_MouseDownNode.m_FirstChild = nullptr; - m_MouseDownNode.m_NextSibling = nullptr; - SCamera *theCamera = m_Context.GetRenderer().GetCameraForNode(*inSelectedNode); - m_CumulativeRotation = 0.0f; - if (theCamera == nullptr) - return; - m_MouseDownCamera = *theCamera; - m_LastPathDragValue = Empty(); -} - -void STranslation::EndDrag() -{ - ResetWidgets(); -} - -bool STranslation::IsPathWidgetActive() -{ - qt3dsdm::TInstanceHandleList theHandles = m_Doc.GetSelectedValue().GetSelectedInstances(); - for (size_t selectedIdx = 0, selectedEnd = theHandles.size(); selectedIdx < selectedEnd; - ++selectedIdx) { - qt3dsdm::Qt3DSDMInstanceHandle theInstance(theHandles[selectedIdx]); - if (m_Doc.GetDocumentReader().GetObjectTypeName(theInstance) == L"PathAnchorPoint") - theInstance = m_AssetGraph.GetParent(m_AssetGraph.GetParent(theInstance)); - SGraphObjectTranslator *theTranslator = GetOrCreateTranslator(theInstance); - if (theTranslator && theTranslator->GetGraphObject().m_Type == GraphObjectTypes::Path) - return true; - } - return false; -} - -inline qt3ds::render::SLayer *GetLayerForNode(const qt3ds::render::SNode &inNode) -{ - SNode *theNode; - // empty loop intentional - for (theNode = const_cast<SNode *>(&inNode); - theNode && theNode->m_Type != GraphObjectTypes::Layer; theNode = theNode->m_Parent) { - } - if (theNode && theNode->m_Type == GraphObjectTypes::Layer) - return static_cast<SLayer *>(theNode); - return nullptr; -} - -void STranslation::RenderZoomRender(SZoomRender &inRender) -{ - SLayer *theLayer(inRender.m_Layer); - CPt thePoint(inRender.m_Point); - if (theLayer) { - qt3ds::render::IQt3DSRenderer &theRenderer(m_Context.GetRenderer()); - Option<qt3ds::render::SLayerPickSetup> thePickSetup( - theRenderer.GetLayerPickSetup(*theLayer, QT3DSVec2((QT3DSF32)thePoint.x, (QT3DSF32)thePoint.y), - QSize(16, 16))); - if (thePickSetup.hasValue()) { - qt3ds::render::NVRenderContext &theRenderContext(m_Context.GetRenderContext()); - theRenderContext.SetViewport(qt3ds::render::NVRenderRect(0, 0, 100, 100)); - theRenderContext.SetScissorRect(qt3ds::render::NVRenderRect(0, 0, 100, 100)); - theRenderContext.SetDepthWriteEnabled(true); - theRenderContext.SetScissorTestEnabled(true); - theRenderContext.SetClearColor(QT3DSVec4(.2f, .2f, .2f, 0.0f)); - theRenderContext.Clear(qt3ds::render::NVRenderClearFlags( - qt3ds::render::NVRenderClearValues::Color | qt3ds::render::NVRenderClearValues::Depth)); - theRenderer.RunLayerRender(*theLayer, thePickSetup->m_ViewProjection); - theRenderContext.SetScissorTestEnabled(false); - } - } -} - -void STranslation::DrawBoundingBox(SNode &inNode, QT3DSVec3 inColor) -{ - qt3ds::NVBounds3 theBounds = inNode.GetBounds(m_Context.GetBufferManager(), - m_Context.GetPathManager(), true, this); - qt3ds::render::IRenderWidget &theBBoxWidget = qt3ds::render::IRenderWidget::CreateBoundingBoxWidget( - inNode, theBounds, inColor, m_Context.GetRenderer().GetPerFrameAllocator()); - m_Context.GetRenderer().AddRenderWidget(theBBoxWidget); -} - -void STranslation::drawPivot(SGraphObjectTranslator &inTranslator) -{ - if (GraphObjectTypes::IsNodeType(inTranslator.GetGraphObject().m_Type)) { - qt3ds::render::IRenderWidget &theAxisWidget = qt3ds::render::IRenderWidget::CreateAxisWidget( - static_cast<SNode &>(inTranslator.GetGraphObject()), - m_Context.GetRenderer().GetPerFrameAllocator()); - m_Context.GetRenderer().AddRenderWidget(theAxisWidget); - } else { - QT3DS_ASSERT(false); - } -} - -void STranslation::SetViewport(qt3ds::QT3DSF32 inWidth, qt3ds::QT3DSF32 inHeight) -{ - m_Viewport = QT3DSVec2(inWidth, inHeight); - if (m_EditCameraEnabled) { - // Update inner rect as it is used to calculate camera frustrum for visual aid widget - QSize theSize = g_StudioApp.GetCore()->GetStudioProjectSettings()->getPresentationSize(); - m_InnerRect.m_Top = 0; - m_InnerRect.m_Bottom = theSize.height(); - m_InnerRect.m_Left = 0; - m_InnerRect.m_Right = theSize.width(); - } -} - -Option<QT3DSU32> STranslation::PickWidget(CPt inMouseCoords, TranslationSelectMode::Enum, - qt3ds::widgets::IStudioWidgetBase &inWidget) -{ - SNode &theNode = inWidget.GetNode(); - SGraphObjectTranslator *theWidgetTranslator = - theNode.m_UserData.DynamicCast<SGraphObjectTranslator>(); - SLayer *theLayer = GetLayerForNode(theNode); - if (theLayer && theWidgetTranslator) { - Option<qt3ds::render::SLayerPickSetup> thePickSetup( - m_Context.GetRenderer().GetLayerPickSetup( - *theLayer, QT3DSVec2((QT3DSF32)inMouseCoords.x, (QT3DSF32)inMouseCoords.y), - QSize(4, 4))); - if (thePickSetup.hasValue()) { - qt3ds::render::NVRenderContext &theContext(m_Context.GetRenderContext()); - qt3ds::render::NVRenderContextScopedProperty<qt3ds::render::NVRenderFrameBuffer *> - __currentrt(theContext, &qt3ds::render::NVRenderContext::GetRenderTarget, - &qt3ds::render::NVRenderContext::SetRenderTarget); - qt3ds::render::NVRenderFrameBuffer *theFBO = - m_Context.GetResourceManager().AllocateFrameBuffer(); - const QT3DSU32 fboDims = 8; - if (!m_PickBuffer) { - m_PickBuffer = theContext.CreateTexture2D(); - m_PickBuffer->SetTextureData(qt3ds::foundation::NVDataRef<qt3ds::QT3DSU8>(), 0, fboDims, - fboDims, - qt3ds::render::NVRenderTextureFormats::LuminanceAlpha8); - } - qt3ds::render::NVRenderRenderBuffer *theRenderBuffer = - m_Context.GetResourceManager().AllocateRenderBuffer( - fboDims, fboDims, qt3ds::render::NVRenderRenderBufferFormats::Depth16); - theFBO->Attach(qt3ds::render::NVRenderFrameBufferAttachments::Color0, - qt3ds::render::NVRenderTextureOrRenderBuffer(*m_PickBuffer)); - theFBO->Attach(qt3ds::render::NVRenderFrameBufferAttachments::Depth, - qt3ds::render::NVRenderTextureOrRenderBuffer(*theRenderBuffer)); - qt3ds::render::NVRenderRect theViewport(0, 0, fboDims, fboDims); - theContext.SetViewport(theViewport); - theContext.SetDepthWriteEnabled(true); - theContext.SetDepthTestEnabled(true); - theContext.SetScissorTestEnabled(false); - theContext.SetBlendingEnabled(false); - theContext.SetClearColor(QT3DSVec4(0, 0, 0, 0)); - theContext.Clear(qt3ds::render::NVRenderClearFlags( - qt3ds::render::NVRenderClearValues::Color | qt3ds::render::NVRenderClearValues::Depth)); - inWidget.RenderPick(thePickSetup->m_ProjectionPreMultiply, theContext, - QSize(4, 4)); - // Now read the pixels back. - m_PixelBuffer.resize(fboDims * fboDims * 3); - theContext.ReadPixels(theViewport, qt3ds::render::NVRenderReadPixelFormats::RGB8, - m_PixelBuffer); - m_Context.GetResourceManager().Release(*theFBO); - m_Context.GetResourceManager().Release(*theRenderBuffer); - eastl::hash_map<QT3DSU32, QT3DSU32> tallies; - QT3DSU32 numPixels = fboDims * fboDims; - for (QT3DSU32 idx = 0; idx < numPixels; ++idx) { - qt3ds::QT3DSU16 theChannelAmount = - m_PixelBuffer[idx * 3] + (m_PixelBuffer[idx * 3 + 1] << 8); - if (theChannelAmount) - tallies.insert(eastl::make_pair(theChannelAmount, (QT3DSU32)0)).first->second += 1; - } - QT3DSU32 tallyMaxTally = 0; - QT3DSU32 tallyMaxIdx = 0; - for (eastl::hash_map<QT3DSU32, QT3DSU32>::iterator iter = tallies.begin(), - end = tallies.end(); - iter != end; ++iter) { - if (iter->second > tallyMaxTally) { - tallyMaxTally = iter->second; - tallyMaxIdx = iter->first; - } - } - if (tallyMaxIdx > 0) { - return tallyMaxIdx; - } - } - } - return Empty(); -} - -SStudioPickValue STranslation::Pick(CPt inMouseCoords, TranslationSelectMode::Enum inSelectMode, - bool ignoreWidgets) -{ - bool requestRender = false; - - if (!ignoreWidgets) { - if (m_Doc.GetDocumentReader().AreGuidesEditable()) { - qt3dsdm::TGuideHandleList theGuides = m_Doc.GetDocumentReader().GetGuides(); - CPt renderSpacePt(inMouseCoords.x - (long)m_InnerRect.m_Left, - (long)GetViewportDimensions().y - inMouseCoords.y - - (long)m_InnerRect.m_Bottom); - for (size_t guideIdx = 0, guideEnd = theGuides.size(); - guideIdx < guideEnd; ++guideIdx) { - qt3dsdm::SGuideInfo theGuideInfo = - m_Doc.GetDocumentReader().GetGuideInfo(theGuides[guideIdx]); - float width = (theGuideInfo.m_Width / 2.0f) + 2.0f; - switch (theGuideInfo.m_Direction) { - case qt3dsdm::GuideDirections::Horizontal: - if (fabs((float)renderSpacePt.y - theGuideInfo.m_Position) <= width) - return theGuides[guideIdx]; - break; - case qt3dsdm::GuideDirections::Vertical: - if (fabs((float)renderSpacePt.x - theGuideInfo.m_Position) <= width) - return theGuides[guideIdx]; - break; - default: - break; - } - } - } - if (IsPathWidgetActive()) { - Option<QT3DSU32> picked = PickWidget(inMouseCoords, inSelectMode, *m_PathWidget); - if (picked.hasValue()) { - RequestRender(); - DoPrepareForDrag(&m_PathWidget->GetNode()); - return m_PathWidget->PickIndexToPickValue(*picked); - } - } - // Pick against the widget first if possible. - if (m_LastRenderedWidget && (m_LastRenderedWidget->GetNode().m_Flags.IsActive() - || m_LastRenderedWidget->GetNode().m_Type - == GraphObjectTypes::Light - || m_LastRenderedWidget->GetNode().m_Type - == GraphObjectTypes::Camera)) { - Option<QT3DSU32> picked = PickWidget(inMouseCoords, inSelectMode, - *m_LastRenderedWidget); - if (picked.hasValue()) { - RequestRender(); - DoPrepareForDrag(&m_LastRenderedWidget->GetNode()); - return m_LastRenderedWidget->PickIndexToPickValue(*picked); - } - } - } - // Pick against Lights and Cameras - // This doesn't use the color picker or renderer pick - float lastDist = 99999999999999.0f; - int lastIndex = -1; - for (int i = 0; i < int(m_editModeCamerasAndLights.size()); ++i) { - const QT3DSVec2 mouseCoords((QT3DSF32)inMouseCoords.x, (QT3DSF32)inMouseCoords.y); - float dist; - SGraphObject &object = m_editModeCamerasAndLights[i]->GetGraphObject(); - m_VisualAidWidget->SetNode(static_cast<SNode *>(&object)); - if (m_VisualAidWidget->pick(m_Context.GetRenderer().GetRenderWidgetContext(), - dist, GetViewportDimensions(), mouseCoords)) { - if (dist < lastDist) { - lastDist = dist; - lastIndex = i; - } - } - } - - if (m_Scene && m_Scene->m_FirstChild) { - qt3ds::render::Qt3DSRenderPickResult thePickResult = - m_Context.GetRenderer().Pick(*m_Scene->m_FirstChild, GetViewportDimensions(), - QT3DSVec2((QT3DSF32)inMouseCoords.x, (QT3DSF32)inMouseCoords.y)); - if (thePickResult.m_HitObject) { - const SGraphObject &theObject = *thePickResult.m_HitObject; - - // check hit distance to cameras and lights - if (lastIndex != -1 && thePickResult.m_CameraDistanceSq > lastDist * lastDist) { - DoPrepareForDrag(static_cast<SNode *>( - &(m_editModeCamerasAndLights[lastIndex]->GetGraphObject()))); - return m_editModeCamerasAndLights[lastIndex]->GetInstanceHandle(); - } - - if (theObject.m_Type == GraphObjectTypes::Model - || theObject.m_Type == GraphObjectTypes::Text - || theObject.m_Type == GraphObjectTypes::Path) { - const SNode &theTranslatorModel(static_cast<const SNode &>(theObject)); - SGraphObjectTranslator *theTranslator = - theTranslatorModel.m_UserData.DynamicCast<SGraphObjectTranslator>(); - const SNode *theModelPtr = &theTranslatorModel; - if (theTranslator->GetPossiblyAliasedInstanceHandle() - != theTranslator->GetInstanceHandle()) { - theTranslator = - GetOrCreateTranslator(theTranslator->GetPossiblyAliasedInstanceHandle()); - theModelPtr = - static_cast<const SNode *>(&theTranslator->GetNonAliasedGraphObject()); - } - Qt3DSDMInstanceHandle theActiveComponent = - m_Reader.GetComponentForSlide(m_Doc.GetActiveSlide()); - if (inSelectMode == TranslationSelectMode::Group) { - // Bounce up the hierarchy till one of two conditions are met - // the parent is a layer or the our component is the active component - // but the parent's is not. - while (theTranslator && GraphObjectTypes::IsNodeType( - theTranslator->GetGraphObject().m_Type)) { - SNode *myNode = static_cast<SNode *>(&theTranslator->GetGraphObject()); - if (myNode->m_Parent == nullptr) { - theTranslator = nullptr; - break; - } - SNode *parentNode = myNode->m_Parent; - SGraphObjectTranslator *theParentTranslator = - parentNode->m_UserData.DynamicCast<SGraphObjectTranslator>(); - Qt3DSDMInstanceHandle myComponent = - m_Reader.GetAssociatedComponent(theTranslator->GetInstanceHandle()); - Qt3DSDMInstanceHandle myParentComponent = m_Reader.GetAssociatedComponent( - theParentTranslator->GetInstanceHandle()); - if (parentNode->m_Type == GraphObjectTypes::Layer) { - if (myParentComponent != theActiveComponent) - theTranslator = nullptr; - break; - } - if (myComponent == theActiveComponent - && myParentComponent != theActiveComponent) - break; - theTranslator = theParentTranslator; - } - } else { - // Bounce up until we get into the active component and then stop. - while (inSelectMode == TranslationSelectMode::Single && theTranslator - && GraphObjectTypes::IsNodeType(theTranslator->GetGraphObject().m_Type) - && m_Reader.GetAssociatedComponent(theTranslator->GetInstanceHandle()) - != theActiveComponent) { - SNode *theNode = static_cast<SNode *>(&theTranslator->GetGraphObject()); - theNode = theNode->m_Parent; - if (theNode && theNode->m_Type != GraphObjectTypes::Layer) - theTranslator = - theNode->m_UserData.DynamicCast<SGraphObjectTranslator>(); - else - theTranslator = nullptr; - } - } - - if (theTranslator) { - QT3DS_ASSERT(GraphObjectTypes::IsNodeType(theTranslator->GetGraphObject().m_Type)); - DoPrepareForDrag(static_cast<SNode *>(&theTranslator->GetGraphObject())); - return theTranslator->GetInstanceHandle(); - } - } - } - if (requestRender) - RequestRender(); - } - - if (lastIndex != -1) { - DoPrepareForDrag(static_cast<SNode *>( - &(m_editModeCamerasAndLights[lastIndex]->GetGraphObject()))); - return m_editModeCamerasAndLights[lastIndex]->GetInstanceHandle(); - } - - return SStudioPickValue(); -} - -qt3ds::foundation::Option<qt3dsdm::SGuideInfo> STranslation::PickRulers(CPt inMouseCoords) -{ - CPt renderSpacePt(inMouseCoords.x, (long)GetViewportDimensions().y - inMouseCoords.y); - // If mouse is inside outer rect but outside inner rect. - if (m_OuterRect.Contains(renderSpacePt.x, renderSpacePt.y) - && !m_InnerRect.Contains(renderSpacePt.x, renderSpacePt.y)) { - std::shared_ptr<qt3dsdm::IGuideSystem> theGuideSystem = - m_StudioSystem.GetFullSystem()->GetCoreSystem()->GetGuideSystem(); - if (renderSpacePt.x >= m_InnerRect.m_Left && renderSpacePt.x <= m_InnerRect.m_Right) { - return qt3dsdm::SGuideInfo((QT3DSF32)renderSpacePt.y - (QT3DSF32)m_InnerRect.m_Bottom, - qt3dsdm::GuideDirections::Horizontal); - } else if (renderSpacePt.y >= m_InnerRect.m_Bottom - && renderSpacePt.y <= m_InnerRect.m_Top) { - return qt3dsdm::SGuideInfo((QT3DSF32)renderSpacePt.x - (QT3DSF32)m_InnerRect.m_Left, - qt3dsdm::GuideDirections::Vertical); - } - } - return qt3ds::foundation::Option<qt3dsdm::SGuideInfo>(); -} - -QT3DSVec3 STranslation::GetIntendedPosition(qt3dsdm::Qt3DSDMInstanceHandle inInstance, CPt inPos) -{ - ClearDirtySet(); - SGraphObjectTranslator *theTranslator = GetOrCreateTranslator(inInstance); - if (theTranslator == nullptr) - return QT3DSVec3(0, 0, 0); - if (GraphObjectTypes::IsNodeType(theTranslator->GetGraphObject().m_Type) == false) - return QT3DSVec3(0, 0, 0); - SNode *theNode = static_cast<SNode *>(&theTranslator->GetGraphObject()); - SCamera *theCamera = m_Context.GetRenderer().GetCameraForNode(*theNode); - { - // Get the node's parent - Qt3DSDMInstanceHandle theParent = m_AssetGraph.GetParent(inInstance); - SGraphObjectTranslator *theParentTranslator = GetOrCreateTranslator(theParent); - if (theParentTranslator - && GraphObjectTypes::IsNodeType(theParentTranslator->GetGraphObject().m_Type)) - theCamera = m_Context.GetRenderer().GetCameraForNode( - *static_cast<SNode *>(&theParentTranslator->GetGraphObject())); - } - if (theCamera == nullptr) - return QT3DSVec3(0, 0, 0); - - QT3DSVec3 theGlobalPos(theNode->GetGlobalPos()); - return m_Context.GetRenderer().UnprojectToPosition(*theCamera, theGlobalPos, - QT3DSVec2((QT3DSF32)inPos.x, (QT3DSF32)inPos.y)); -} - -static void CheckLockToAxis(QT3DSF32 &inXDistance, QT3DSF32 &inYDistance, bool inLockToAxis) -{ - if (inLockToAxis) { - if (fabs(inXDistance) > fabs(inYDistance)) - inYDistance = 0; - else - inXDistance = 0; - } -} - -void STranslation::ApplyPositionalChange(QT3DSVec3 inDiff, SNode &inNode, - CUpdateableDocumentEditor &inEditor) -{ - if (m_MouseDownParentGlobalTransformInverse.isEmpty()) { - if (inNode.m_Parent) - m_MouseDownParentGlobalTransformInverse = - inNode.m_Parent->m_GlobalTransform.getInverse(); - else - m_MouseDownParentGlobalTransformInverse = QT3DSMat44::createIdentity(); - } - QT3DSMat44 theGlobalTransform = m_MouseDownNode.m_GlobalTransform; - QT3DSMat44 theNewLocalTransform = - m_MouseDownParentGlobalTransformInverse.getValue() * theGlobalTransform; - QT3DSVec3 theOldPos = theNewLocalTransform.column3.getXYZ(); - theOldPos.z *= -1; - - theGlobalTransform.column3 += QT3DSVec4(inDiff, 0.0f); - theNewLocalTransform = m_MouseDownParentGlobalTransformInverse.getValue() * theGlobalTransform; - QT3DSVec3 thePos = theNewLocalTransform.column3.getXYZ(); - thePos.z *= -1; - - QT3DSVec3 theDiff = thePos - theOldPos; - - SetPosition(m_MouseDownNode.m_Position + theDiff, inEditor); -} - -void STranslation::TranslateSelectedInstanceAlongCameraDirection( - CPt inOriginalCoords, CPt inMouseCoords, CUpdateableDocumentEditor &inEditor) -{ - SNode *theNode = GetSelectedNode(); - if (theNode == nullptr) - return; - SCamera *theCamera = m_Context.GetRenderer().GetCameraForNode(*theNode); - if (theCamera == nullptr) - return; - QT3DSF32 theYDistance = QT3DSF32(inMouseCoords.y - inOriginalCoords.y); - if (fabs(theYDistance) == 0) - return; - - QT3DSF32 theMouseMultiplier = 1.0f / 2.0f; - QT3DSF32 theDistanceMultiplier = 1.0f + theYDistance * theMouseMultiplier; - QT3DSVec3 theCameraDir = m_MouseDownCamera.GetDirection(); - - QT3DSVec3 theDiff = theCameraDir * theDistanceMultiplier; - ApplyPositionalChange(theDiff, *theNode, inEditor); -} - -void STranslation::TranslateSelectedInstance(CPt inOriginalCoords, CPt inMouseCoords, - CUpdateableDocumentEditor &inEditor, bool inLockToAxis) -{ - SNode *theNode = GetSelectedNode(); - if (theNode == nullptr) - return; - qt3ds::render::IQt3DSRenderer &theRenderer(m_Context.GetRenderer()); - - QT3DSF32 theXDistance = QT3DSF32(inMouseCoords.x - inOriginalCoords.x); - QT3DSF32 theYDistance = QT3DSF32(inMouseCoords.y - inOriginalCoords.y); - if (fabs(theXDistance) == 0 && fabs(theYDistance) == 0) - return; - - CheckLockToAxis(theXDistance, theYDistance, inLockToAxis); - - inMouseCoords.x = inOriginalCoords.x + (long)theXDistance; - inMouseCoords.y = inOriginalCoords.y + (long)theYDistance; - QT3DSVec3 theNodeGlobal = m_MouseDownNode.GetGlobalPos(); - QT3DSVec3 theOriginalPos = theRenderer.UnprojectToPosition( - *theNode, theNodeGlobal, QT3DSVec2((QT3DSF32)inOriginalCoords.x, (QT3DSF32)inOriginalCoords.y)); - QT3DSVec3 theNewPos = theRenderer.UnprojectToPosition( - *theNode, theNodeGlobal, QT3DSVec2((QT3DSF32)inMouseCoords.x, (QT3DSF32)inMouseCoords.y)); - - QT3DSVec3 theDiff = theNewPos - theOriginalPos; - ApplyPositionalChange(theDiff, *theNode, inEditor); -} - -void STranslation::ScaleSelectedInstanceZ(CPt inOriginalCoords, CPt inMouseCoords, - CUpdateableDocumentEditor &inEditor) -{ - SNode *theNode = GetSelectedNode(); - if (theNode == nullptr) - return; - - // Scale scales uniformly and responds to mouse Y only. - QT3DSF32 theYDistance = (QT3DSF32)inMouseCoords.y - (QT3DSF32)inOriginalCoords.y; - if (fabs(theYDistance) == 0) - return; - - QT3DSF32 theMouseMultiplier = 1.0f / 40.0f; - QT3DSF32 theScaleMultiplier = 1.0f + theYDistance * theMouseMultiplier; - - SetScale(QT3DSVec3(m_MouseDownNode.m_Scale.x, m_MouseDownNode.m_Scale.y, - m_MouseDownNode.m_Scale.z * theScaleMultiplier), - inEditor); -} - -void STranslation::ScaleSelectedInstance(CPt inOriginalCoords, CPt inMouseCoords, - CUpdateableDocumentEditor &inEditor) -{ - SNode *theNode = GetSelectedNode(); - if (theNode == nullptr) - return; - - // Scale scales uniformly and responds to mouse Y only. - QT3DSF32 theYDistance = (QT3DSF32)inMouseCoords.y - (QT3DSF32)inOriginalCoords.y; - if (fabs(theYDistance) == 0) - return; - - QT3DSF32 theMouseMultiplier = 1.0f / 40.0f; - QT3DSF32 theScaleMultiplier = 1.0f + theYDistance * theMouseMultiplier; - - SetScale(m_MouseDownNode.m_Scale * theScaleMultiplier, inEditor); -} - -void STranslation::CalculateNodeGlobalRotation(SNode &inNode) -{ - if (inNode.m_Parent) - CalculateNodeGlobalRotation(*inNode.m_Parent); - if (m_MouseDownParentRotationInverse.isEmpty()) { - m_MouseDownParentRotationInverse = QT3DSMat33::createIdentity(); - m_MouseDownGlobalRotation = QT3DSMat33::createIdentity(); - } - - QT3DSMat44 localRotation; - inNode.CalculateRotationMatrix(localRotation); - if (inNode.m_Flags.IsLeftHanded()) - SNode::FlipCoordinateSystem(localRotation); - QT3DSMat33 theRotation; - SNode::GetMatrixUpper3x3(theRotation, localRotation); - - m_MouseDownParentRotationInverse = m_MouseDownGlobalRotation; - m_MouseDownGlobalRotation = m_MouseDownGlobalRotation.getValue() * theRotation; -} - -void STranslation::ApplyRotationToSelectedInstance(const QT3DSQuat &inFinalRotation, SNode &inNode, - CUpdateableDocumentEditor &inEditor, - bool inIsMouseRelative) -{ - if (m_MouseDownParentRotationInverse.isEmpty()) { - CalculateNodeGlobalRotation(inNode); - m_MouseDownParentRotationInverse = m_MouseDownParentRotationInverse->getInverse(); - } - QT3DSMat33 theRotationMatrix(inFinalRotation); - - QT3DSMat33 theFinalGlobal = theRotationMatrix * m_MouseDownGlobalRotation.getValue(); - QT3DSMat33 theLocalGlobal = m_MouseDownParentRotationInverse.getValue() * theFinalGlobal; - QT3DSVec3 theRotations = inNode.GetRotationVectorFromRotationMatrix(theLocalGlobal); - theRotations = qt3ds::render::SRotationHelper::ToNearestAngle(inNode.m_Rotation, theRotations, - inNode.m_RotationOrder); - SetRotation(theRotations, inEditor); - // Trackball rotation is relative to the previous mouse position. - // Rotation manipulator rotation is relative to only the original mouse down position - // so inIsMouseRelative is false for rotations that are relative to the original mouse down - // position. - if (inIsMouseRelative) - m_MouseDownGlobalRotation = theFinalGlobal; -} - -void STranslation::RotateSelectedInstanceAboutCameraDirectionVector( - CPt inPreviousMouseCoords, CPt inMouseCoords, CUpdateableDocumentEditor &inEditor) -{ - SNode *theNode = GetSelectedNode(); - if (theNode == nullptr) - return; - SCamera *theCamera = m_Context.GetRenderer().GetCameraForNode(*theNode); - if (theCamera == nullptr) - return; - - QT3DSVec3 theDirection = m_MouseDownCamera.GetDirection(); - QT3DSF32 theYDistance = (QT3DSF32)inMouseCoords.y - (QT3DSF32)inPreviousMouseCoords.y; - QT3DSQuat theYRotation(-1.0f * theYDistance * g_RotationScaleFactor, theDirection); - - ApplyRotationToSelectedInstance(theYRotation, *theNode, inEditor); -} - -// This method never feels right to me. It is difficult to apply it to a single axis (of course for -// that you can use the inspector palette). -void STranslation::RotateSelectedInstance(CPt inOriginalCoords, CPt inPreviousCoords, - CPt inMouseCoords, CUpdateableDocumentEditor &inEditor, - bool inLockToAxis) -{ - SNode *theNode = GetSelectedNode(); - if (theNode == nullptr) - return; - SCamera *theCamera = m_Context.GetRenderer().GetCameraForNode(*theNode); - if (theCamera == nullptr) - return; - // We want to do a similar translation to what we did below but we need to calculate the - // parent's global rotation without scale included. - - QT3DSF32 theXDistance = (QT3DSF32)inMouseCoords.x - (QT3DSF32)inPreviousCoords.x; - QT3DSF32 theYDistance = (QT3DSF32)inMouseCoords.y - (QT3DSF32)inPreviousCoords.y; - bool xIsZero = fabs(theXDistance) < .001f; - bool yIsZero = fabs(theYDistance) < .001f; - if (xIsZero && yIsZero) - return; - - if (inLockToAxis) { - QT3DSF32 originalDistX = (QT3DSF32)inMouseCoords.x - (QT3DSF32)inOriginalCoords.x; - QT3DSF32 originalDistY = (QT3DSF32)inMouseCoords.y - (QT3DSF32)inOriginalCoords.y; - if (inLockToAxis) { - if (fabs(originalDistX) > fabs(originalDistY)) - theYDistance = 0; - else - theXDistance = 0; - } - } - - QT3DSVec3 theXAxis = m_MouseDownCamera.m_GlobalTransform.column0.getXYZ(); - QT3DSVec3 theYAxis = m_MouseDownCamera.m_GlobalTransform.column1.getXYZ(); - - QT3DSVec3 theFinalAxis = theXDistance * theYAxis + theYDistance * theXAxis; - QT3DSF32 theTotalDistance = theFinalAxis.normalize(); - QT3DSQuat theRotation(theTotalDistance * g_RotationScaleFactor / 2.0f, theFinalAxis); - - ApplyRotationToSelectedInstance(theRotation, *theNode, inEditor); -} - -inline void NiceAdd(QT3DSF32 &ioValue, QT3DSF32 inIncrement) -{ - QT3DSF32 temp = ioValue + inIncrement; - // Round to nearest .5 - QT3DSF32 sign = temp >= 0 ? 1.0f : -1.0f; - QT3DSU32 largerValue = (QT3DSU32)(fabs(temp * 10.0f)); - - QT3DSU32 leftover = largerValue % 10; - // Round down to zero - largerValue -= leftover; - if (leftover < 2) - leftover = 0; - else if (leftover > 7) { - leftover = 0; - largerValue += 10; - } else - leftover = 5; - largerValue += leftover; - - ioValue = sign * (QT3DSF32)largerValue / 10.0f; -} - -static inline QT3DSVec3 GetAxis(QT3DSU32 inIndex, QT3DSMat33 &inMatrix) -{ - QT3DSVec3 retval(0, 0, 0); - switch (inIndex) { - case 0: - retval = inMatrix.column0; - break; - case 1: - retval = inMatrix.column1; - break; - case 2: - retval = inMatrix.column2; - break; - default: - QT3DS_ASSERT(false); - break; - } - retval.normalize(); - return retval; -} - -inline Option<QT3DSF32> GetScaleAlongAxis(const QT3DSVec3 &inAxis, const QT3DSVec3 &inObjToOriginal, - const QT3DSVec3 &inObjToCurrent) -{ - QT3DSF32 lhs = inAxis.dot(inObjToCurrent); - QT3DSF32 rhs = inAxis.dot(inObjToOriginal); - if (fabs(rhs) > .001f) - return lhs / rhs; - return Empty(); -} - -// Make a nice rotation from the incoming rotation -static inline QT3DSF32 MakeNiceRotation(QT3DSF32 inAngle) -{ - TODEG(inAngle); - inAngle *= 10.0f; - QT3DSF32 sign = inAngle > 0.0f ? 1.0f : -1.0f; - // Attempt to ensure angle is prtty clean - QT3DSU32 clampedAngle = (QT3DSU32)(fabs(inAngle) + .5f); - QT3DSU32 leftover = clampedAngle % 10; - clampedAngle -= leftover; - if (leftover <= 2) - leftover = 0; - else if (leftover <= 7) - leftover = 5; - else - leftover = 10; - clampedAngle += leftover; - QT3DSF32 retval = (QT3DSF32)clampedAngle; - retval = (retval * sign) / 10.0f; - TORAD(retval); - return retval; -} - -static inline QT3DSF32 ShortestAngleDifference(QT3DSF32 inCumulative, QT3DSF32 inNewTotal) -{ - QT3DSF32 diff = qt3ds::render::SRotationHelper::ToMinimalAngle(inNewTotal - inCumulative); - return inCumulative + diff; -} - -Option<SDragPreparationResult> -STranslation::PrepareWidgetDrag(qt3ds::widgets::StudioWidgetComponentIds::Enum inComponentId, - qt3ds::widgets::StudioWidgetTypes::Enum inWidgetId, - qt3ds::render::RenderWidgetModes::Enum inWidgetMode, SNode &inNode, - CPt inOriginalCoords, CPt inPreviousMouseCoords, CPt inMouseCoords) -{ - SDragPreparationResult retval; - retval.m_ComponentId = inComponentId; - retval.m_WidgetType = inWidgetId; - retval.m_WidgetMode = inWidgetMode; - qt3ds::render::IQt3DSRenderer &theRenderer(m_Context.GetRenderer()); - retval.m_Renderer = &theRenderer; - retval.m_Node = &inNode; - retval.m_Layer = GetLayerForNode(inNode); - retval.m_Camera = theRenderer.GetCameraForNode(inNode); - QSize theUnsignedDimensions(m_Context.GetWindowDimensions()); - QT3DSVec2 theWindowDimensions((QT3DSF32)theUnsignedDimensions.width(), - (QT3DSF32)theUnsignedDimensions.height()); - if (retval.m_Camera == nullptr || retval.m_Layer == nullptr) - return Empty(); - - SCamera &theCamera(*retval.m_Camera); - SLayer &theLayer(*retval.m_Layer); - QT3DSVec2 theLayerOriginalCoords = m_Context.GetRenderer().GetLayerMouseCoords( - *retval.m_Layer, QT3DSVec2((QT3DSF32)inOriginalCoords.x, (QT3DSF32)inOriginalCoords.y), - theWindowDimensions, true); - - QT3DSVec2 theLayerMouseCoords = m_Context.GetRenderer().GetLayerMouseCoords( - *retval.m_Layer, QT3DSVec2((QT3DSF32)inMouseCoords.x, (QT3DSF32)inMouseCoords.y), - theWindowDimensions, true); - - QT3DSVec2 thePreviousLayerMouseCoords = m_Context.GetRenderer().GetLayerMouseCoords( - *retval.m_Layer, QT3DSVec2((QT3DSF32)inPreviousMouseCoords.x, (QT3DSF32)inPreviousMouseCoords.y), - theWindowDimensions, true); - QT3DSMat44 theGlobalTransform(QT3DSMat44::createIdentity()); - if (inWidgetMode == qt3ds::render::RenderWidgetModes::Local) { - theGlobalTransform = m_MouseDownNode.m_GlobalTransform; - } - retval.m_GlobalTransform = theGlobalTransform; - QT3DSMat33 theNormalMat(theGlobalTransform.column0.getXYZ(), theGlobalTransform.column1.getXYZ(), - theGlobalTransform.column2.getXYZ()); - theNormalMat = theNormalMat.getInverse().getTranspose(); - retval.m_NormalMatrix = theNormalMat; - qt3ds::render::NVRenderRectF theLayerRect(theRenderer.GetLayerRect(theLayer)); - SRay theOriginalRay = - theCamera.Unproject(theLayerOriginalCoords, theLayerRect, theWindowDimensions); - SRay theCurrentRay = - theCamera.Unproject(theLayerMouseCoords, theLayerRect, theWindowDimensions); - SRay thePreviousRay = - theCamera.Unproject(thePreviousLayerMouseCoords, theLayerRect, theWindowDimensions); - retval.m_OriginalRay = theOriginalRay; - retval.m_CurrentRay = theCurrentRay; - retval.m_PreviousRay = thePreviousRay; - QT3DSVec3 theAxis; - QT3DSVec3 thePlaneNormal; - bool isPlane = false; - QT3DSVec3 globalPos = inNode.GetGlobalPivot(); - QT3DSVec3 camGlobalPos = theCamera.GetGlobalPos(); - QT3DSVec3 theCamDirection; - retval.m_GlobalPos = globalPos; - retval.m_CameraGlobalPos = camGlobalPos; - if (theCamera.m_Flags.IsOrthographic()) - theCamDirection = theCamera.GetDirection(); - else { - theCamDirection = globalPos - camGlobalPos; - // The normal will be normalized below. - } - theCamDirection.normalize(); - retval.m_CameraDirection = theCamDirection; - retval.m_AxisIndex = 0; - switch (inComponentId) { - default: - QT3DS_ASSERT(false); - break; - case qt3ds::widgets::StudioWidgetComponentIds::XAxis: - theAxis = QT3DSVec3(1, 0, 0); - break; - case qt3ds::widgets::StudioWidgetComponentIds::YAxis: - theAxis = QT3DSVec3(0, 1, 0); - retval.m_AxisIndex = 1; - break; - case qt3ds::widgets::StudioWidgetComponentIds::ZAxis: - theAxis = QT3DSVec3(0, 0, -1); - retval.m_AxisIndex = 2; - break; - case qt3ds::widgets::StudioWidgetComponentIds::XPlane: - thePlaneNormal = QT3DSVec3(1, 0, 0); - isPlane = true; - break; - case qt3ds::widgets::StudioWidgetComponentIds::YPlane: - thePlaneNormal = QT3DSVec3(0, 1, 0); - isPlane = true; - break; - case qt3ds::widgets::StudioWidgetComponentIds::ZPlane: - thePlaneNormal = QT3DSVec3(0, 0, -1); - isPlane = true; - break; - case qt3ds::widgets::StudioWidgetComponentIds::CameraPlane: { - isPlane = true; - thePlaneNormal = theCamDirection; - } break; - } - retval.m_IsPlane = isPlane; - if (inWidgetId == qt3ds::widgets::StudioWidgetTypes::Rotation) { - if (isPlane == false) { - theAxis = theNormalMat.transform(theAxis); - theAxis.normalize(); - thePlaneNormal = theAxis; - retval.m_Plane = qt3ds::NVPlane(thePlaneNormal, -1.0f * thePlaneNormal.dot(globalPos)); - } else { - if (inComponentId != qt3ds::widgets::StudioWidgetComponentIds::CameraPlane) { - thePlaneNormal = theNormalMat.transform(thePlaneNormal); - } - thePlaneNormal.normalize(); - retval.m_Plane = qt3ds::NVPlane(thePlaneNormal, -1.0f * (thePlaneNormal.dot(globalPos))); - } - } else { - if (isPlane == false) { - theAxis = theNormalMat.transform(theAxis); - theAxis.normalize(); - QT3DSVec3 theCameraToObj = globalPos - camGlobalPos; - QT3DSVec3 theTemp = theAxis.cross(theOriginalRay.m_Direction); - // When the axis is parallel to the camera, we can't drag meaningfully - if (theTemp.magnitudeSquared() < .05f) { - // Attempt to find a better axis by moving the object back towards the camera. - QT3DSF32 theSign = theCameraToObj.dot(theCamDirection) > 0.0 ? -1.0f : 1.0f; - QT3DSF32 theDistance = theCameraToObj.dot(theCamDirection); - QT3DSVec3 thePoint = globalPos + (theDistance * theSign) * theAxis; - // Check if we actually moved to right direction - QT3DSVec3 theNewCameraToObj = thePoint - camGlobalPos; - QT3DSF32 theNewDistance = theNewCameraToObj.dot(theCamDirection); - if (theNewDistance > theDistance) - thePoint = globalPos - (theDistance * theSign) * theAxis; - - QT3DSVec3 theNewDir = thePoint - camGlobalPos; - theNewDir.normalize(); - theTemp = theAxis.cross(theNewDir); - // Attempt again to find a better cross - if (theTemp.magnitudeSquared() < .05f) - return Empty(); - } - thePlaneNormal = theTemp.cross(theAxis); - thePlaneNormal.normalize(); - retval.m_Plane = qt3ds::NVPlane(thePlaneNormal, -1.0f * thePlaneNormal.dot(globalPos)); - } else { - thePlaneNormal = theNormalMat.transform(thePlaneNormal); - thePlaneNormal.normalize(); - retval.m_Plane = qt3ds::NVPlane(thePlaneNormal, -1.0f * (thePlaneNormal.dot(globalPos))); - } - } - retval.m_Axis = theAxis; - retval.m_OriginalPlaneCoords = theOriginalRay.Intersect(retval.m_Plane); - retval.m_CurrentPlaneCoords = theCurrentRay.Intersect(retval.m_Plane); - retval.m_PreviousPlaneCoords = thePreviousRay.Intersect(retval.m_Plane); - return retval; -} - -void STranslation::PerformWidgetDrag(int inWidgetSubComponent, CPt inOriginalCoords, - CPt inPreviousMouseCoords, CPt inMouseCoords, - CUpdateableDocumentEditor &inEditor) -{ - if (inWidgetSubComponent == 0 || m_LastRenderedWidget == nullptr) { - QT3DS_ASSERT(false); - return; - } - Option<SDragPreparationResult> thePrepResult(PrepareWidgetDrag( - static_cast<qt3ds::widgets::StudioWidgetComponentIds::Enum>(inWidgetSubComponent), - m_LastRenderedWidget->GetWidgetType(), m_LastRenderedWidget->GetRenderWidgetMode(), - m_LastRenderedWidget->GetNode(), inOriginalCoords, inPreviousMouseCoords, inMouseCoords)); - if (!thePrepResult.hasValue()) - return; - - Option<QT3DSVec3> theOriginalPlaneCoords(thePrepResult->m_OriginalPlaneCoords); - Option<QT3DSVec3> theCurrentPlaneCoords(thePrepResult->m_CurrentPlaneCoords); - QT3DSVec3 globalPos(thePrepResult->m_GlobalPos); - bool isPlane(thePrepResult->m_IsPlane); - QT3DSVec3 theAxis(thePrepResult->m_Axis); - QT3DSU32 axisIndex(thePrepResult->m_AxisIndex); - SNode *theNode(thePrepResult->m_Node); - SRay theCurrentRay(thePrepResult->m_CurrentRay); - SRay theOriginalRay(thePrepResult->m_OriginalRay); - QT3DSVec3 thePlaneNormal(thePrepResult->m_Plane.n); - QT3DSVec3 theCamDirection(thePrepResult->m_CameraDirection); - QT3DSVec3 camGlobalPos(thePrepResult->m_CameraGlobalPos); - - switch (m_LastRenderedWidget->GetWidgetType()) { - default: - QT3DS_ASSERT(false); - return; - case qt3ds::widgets::StudioWidgetTypes::Scale: { - if (theOriginalPlaneCoords.hasValue() && theCurrentPlaneCoords.hasValue()) { - QT3DSVec3 objToOriginal = globalPos - *theOriginalPlaneCoords; - QT3DSVec3 objToCurrent = globalPos - *theCurrentPlaneCoords; - QT3DSVec3 theScaleMultiplier(1, 1, 1); - if (!isPlane) { - // Ensure that we only have a scale vector in the direction of the axis. - objToOriginal = theAxis * (theAxis.dot(objToOriginal)); - objToCurrent = theAxis * (theAxis.dot(objToCurrent)); - QT3DSF32 objToOriginalDot = theAxis.dot(objToOriginal); - if (fabs(objToOriginalDot) > .001f) - theScaleMultiplier[axisIndex] = - theAxis.dot(objToCurrent) / theAxis.dot(objToOriginal); - else - theScaleMultiplier[axisIndex] = 0.0f; - } - - QT3DSMat33 theNodeAxisMatrix(theNode->m_GlobalTransform.column0.getXYZ(), - theNode->m_GlobalTransform.column1.getXYZ(), - theNode->m_GlobalTransform.column2.getXYZ()); - theNodeAxisMatrix = theNodeAxisMatrix.getInverse().getTranspose(); - QT3DSVec3 &theLocalXAxis(theNodeAxisMatrix.column0); - QT3DSVec3 &theLocalYAxis(theNodeAxisMatrix.column1); - QT3DSVec3 &theLocalZAxis(theNodeAxisMatrix.column2); - theLocalXAxis.normalize(); - theLocalYAxis.normalize(); - theLocalZAxis.normalize(); - - Option<QT3DSF32> theXScale = GetScaleAlongAxis(theLocalXAxis, objToOriginal, objToCurrent); - Option<QT3DSF32> theYScale = GetScaleAlongAxis(theLocalYAxis, objToOriginal, objToCurrent); - Option<QT3DSF32> theZScale = GetScaleAlongAxis(theLocalZAxis, objToOriginal, objToCurrent); - QT3DSVec3 theScale = m_MouseDownNode.m_Scale; - if (theXScale.isEmpty() && theYScale.isEmpty() && theZScale.isEmpty()) { - theScale = QT3DSVec3(0, 0, 0); - } else { - if (theXScale.hasValue()) - theScale.x *= *theXScale; - if (theYScale.hasValue()) - theScale.y *= *theYScale; - if (theZScale.hasValue()) - theScale.z *= *theZScale; - } - m_LastRenderedWidget->SetAxisScale(theScaleMultiplier); - SetScale(theScale, inEditor); - } - } break; - case qt3ds::widgets::StudioWidgetTypes::Rotation: { - QT3DSF32 theIntersectionCosine = theOriginalRay.m_Direction.dot(thePlaneNormal); - QT3DSVec3 objToPrevious; - QT3DSVec3 objToCurrent; - if (fabs(theIntersectionCosine) > .08f) { - if (!theOriginalPlaneCoords.hasValue() || !theCurrentPlaneCoords.hasValue()) - return; - objToPrevious = globalPos - *theOriginalPlaneCoords; - objToCurrent = globalPos - *theCurrentPlaneCoords; - objToPrevious.normalize(); - QT3DSF32 lineLen = objToCurrent.normalize(); - - if (!thePrepResult->m_Camera->m_Flags.IsOrthographic()) { - // Flip object vector if coords are behind camera to get the correct angle - QT3DSVec3 camToCurrent = camGlobalPos - *theCurrentPlaneCoords; - if (camToCurrent.dot(theCamDirection) >= 0.0f) { - objToCurrent = -objToCurrent; - // Negative line length seems counterintuitive, but since the end point is - // behind the camera, it results in correct line when rendered - lineLen = -lineLen; - } - } - - QT3DSF32 cosAngle = objToPrevious.dot(objToCurrent); - QT3DSVec3 theCrossProd = objToPrevious.cross(objToCurrent); - QT3DSF32 theCrossPlaneDot = theCrossProd.dot(thePlaneNormal); - QT3DSF32 angleSign = theCrossPlaneDot >= 0.0f ? 1.0f : -1.0f; - QT3DSF32 angleRad = acos(cosAngle) * angleSign; - angleRad = MakeNiceRotation(angleRad); - QT3DSQuat theRotation(angleRad, thePlaneNormal); - - m_CumulativeRotation = ShortestAngleDifference(m_CumulativeRotation, angleRad); - m_LastRenderedWidget->SetRotationEdges(-1.0f * objToPrevious, thePlaneNormal, - m_CumulativeRotation, lineLen); - ApplyRotationToSelectedInstance(theRotation, *theNode, inEditor, false); - } - // In this case we are viewing the plane of rotation pretty much dead on, so we need to - // assume the camera and the object are both in the plane of rotation. In this case we - // *sort* of need to do trackball rotation but force it to one plane of rotation. - else { - // Setup a plane 600 units away from the camera and have the gadget run from there. - - // This keeps rotation consistent. - QT3DSVec3 thePlaneSpot = theCamDirection * -600.0f + camGlobalPos; - qt3ds::NVPlane theCameraPlaneAtObject(theCamDirection, - -1.0f * (theCamDirection.dot(thePlaneSpot))); - theCurrentPlaneCoords = theCurrentRay.Intersect(theCameraPlaneAtObject); - theOriginalPlaneCoords = theOriginalRay.Intersect(theCameraPlaneAtObject); - QT3DSVec3 theChangeVector = *theOriginalPlaneCoords - *theCurrentPlaneCoords; - // Remove any component of the change vector that doesn't lie in the plane. - theChangeVector = - theChangeVector - theChangeVector.dot(thePlaneNormal) * thePlaneNormal; - QT3DSF32 theDistance = theChangeVector.normalize(); - // We want about 90* per 200 units in imaginary 600-units-from-camera space. - QT3DSF32 theScaleFactor = 1.0f / 200.0f; - if (thePrepResult->m_Camera->m_Flags.IsOrthographic()) - theScaleFactor = 1.0f / 100.0f; - - QT3DSF32 theDeg = 90.0f * theDistance * theScaleFactor; - // Check the sign of the angle. - QT3DSVec3 theCurrentIsectDir = camGlobalPos - *theCurrentPlaneCoords; - QT3DSVec3 thePreviousIsectDir = camGlobalPos - *theOriginalPlaneCoords; - QT3DSVec3 theCrossProd = theCurrentIsectDir.cross(thePreviousIsectDir); - QT3DSF32 theAngleSign = theCrossProd.dot(thePlaneNormal) > 0.0f ? 1.0f : -1.0f; - theDeg *= theAngleSign; - QT3DSF32 theRad(theDeg); - TORAD(theRad); - theRad = MakeNiceRotation(theRad); - QT3DSQuat theRotation(theRad, thePlaneNormal); - ApplyRotationToSelectedInstance(theRotation, *theNode, inEditor, false); - } - } break; - case qt3ds::widgets::StudioWidgetTypes::Translation: { - if (theOriginalPlaneCoords.hasValue() && theCurrentPlaneCoords.hasValue()) { - QT3DSVec3 theDiff = *theCurrentPlaneCoords - *theOriginalPlaneCoords; - if (isPlane) { - ApplyPositionalChange(theDiff, *theNode, inEditor); - } else { - QT3DSVec3 theMovement = theAxis * theAxis.dot(theDiff); - ApplyPositionalChange(theMovement, *theNode, inEditor); - } - } - } break; - } -} - -static float RoundToNearest(float inValue, float inMin, float inMax, float inRound) -{ - float half = (inMin + inMax) / 2.0f; - inValue -= half; - inValue = inRound * floor(inValue / inRound + .5f); - inValue += half; - inValue -= inMin; - return inValue; -} - -void STranslation::PerformGuideDrag(Qt3DSDMGuideHandle inGuide, CPt inPoint, - CUpdateableDocumentEditor &inEditor) -{ - qt3dsdm::SGuideInfo theInfo = m_Doc.GetDocumentReader().GetGuideInfo(inGuide); - CPt renderSpacePt(inPoint.x, (long)GetViewportDimensions().y - inPoint.y); - switch (theInfo.m_Direction) { - case qt3dsdm::GuideDirections::Horizontal: - theInfo.m_Position = RoundToNearest((float)renderSpacePt.y, (float)m_InnerRect.m_Bottom, - (float)m_InnerRect.m_Top, 10.0f); - break; - case qt3dsdm::GuideDirections::Vertical: - theInfo.m_Position = RoundToNearest((float)renderSpacePt.x, (float)m_InnerRect.m_Left, - (float)m_InnerRect.m_Right, 10.0f); - break; - default: - QT3DS_ASSERT(FALSE); - break; - break; - } - inEditor.EnsureEditor(QObject::tr("Drag Guide"), __FILE__, __LINE__).UpdateGuide(inGuide, - theInfo); - inEditor.FireImmediateRefresh(qt3dsdm::Qt3DSDMInstanceHandle()); -} - -void STranslation::CheckGuideInPresentationRect(Qt3DSDMGuideHandle inGuide, - CUpdateableDocumentEditor &inEditor) -{ - qt3dsdm::SGuideInfo theInfo = m_Doc.GetDocumentReader().GetGuideInfo(inGuide); - bool inPresentation = false; - QT3DSF32 presHeight = (QT3DSF32)m_InnerRect.m_Top - (QT3DSF32)m_InnerRect.m_Bottom; - QT3DSF32 presWidth = (QT3DSF32)m_InnerRect.m_Right - (QT3DSF32)m_InnerRect.m_Left; - switch (theInfo.m_Direction) { - case qt3dsdm::GuideDirections::Horizontal: - inPresentation = 0.0f <= theInfo.m_Position && presHeight >= theInfo.m_Position; - break; - case qt3dsdm::GuideDirections::Vertical: - inPresentation = 0.0f <= theInfo.m_Position && presWidth >= theInfo.m_Position; - break; - default: - break; - } - - if (!inPresentation) - inEditor.EnsureEditor(QObject::tr("Delete Guide"), __FILE__, __LINE__).DeleteGuide(inGuide); -} - -void STranslation::PerformPathDrag(qt3ds::studio::SPathPick &inPathPick, CPt inOriginalCoords, - CPt inPreviousMouseCoords, CPt inMouseCoords, - CUpdateableDocumentEditor &inEditor) -{ - Option<SDragPreparationResult> thePrepResult(PrepareWidgetDrag( - qt3ds::widgets::StudioWidgetComponentIds::ZPlane, - qt3ds::widgets::StudioWidgetTypes::Translation, qt3ds::render::RenderWidgetModes::Local, - m_PathWidget->GetNode(), inOriginalCoords, inPreviousMouseCoords, inMouseCoords)); - if (!thePrepResult.hasValue()) - return; - - Option<QT3DSVec3> theOriginalPlaneCoords(thePrepResult->m_OriginalPlaneCoords); - Option<QT3DSVec3> theCurrentPlaneCoords(thePrepResult->m_CurrentPlaneCoords); - Option<QT3DSVec3> thePreviousPlaneCoords(thePrepResult->m_PreviousPlaneCoords); - if (theOriginalPlaneCoords.hasValue() && theCurrentPlaneCoords.hasValue()) { - QT3DSVec3 theGlobalDiff = *theCurrentPlaneCoords - *theOriginalPlaneCoords; - QT3DSMat44 theGlobalInverse = thePrepResult->m_GlobalTransform.getInverse(); - QT3DSVec3 theCurrentPos = theGlobalInverse.transform(*theCurrentPlaneCoords); - QT3DSVec3 theOldPos = theGlobalInverse.transform(*theOriginalPlaneCoords); - QT3DSVec3 theDiff = theCurrentPos - theOldPos; - // Now find the anchor point; nontrivial. - SPathTranslator *theTranslator = - reinterpret_cast<SPathTranslator *>(thePrepResult->m_Node->m_UserData.m_UserData); - qt3dsdm::Qt3DSDMInstanceHandle thePathHandle = theTranslator->GetInstanceHandle(); - qt3dsdm::Qt3DSDMInstanceHandle theAnchorHandle = GetAnchorPoint(inPathPick); - - if (theAnchorHandle.Valid()) { - qt3dsdm::Qt3DSDMPropertyHandle thePosProperty = - m_ObjectDefinitions.m_PathAnchorPoint.m_Position.m_Property; - qt3dsdm::Qt3DSDMPropertyHandle theAngleProperty = - m_ObjectDefinitions.m_PathAnchorPoint.m_IncomingAngle.m_Property; - qt3dsdm::Qt3DSDMPropertyHandle theIncomingDistanceProperty = - m_ObjectDefinitions.m_PathAnchorPoint.m_IncomingDistance.m_Property; - qt3dsdm::Qt3DSDMPropertyHandle theOutgoingDistanceProperty = - m_ObjectDefinitions.m_PathAnchorPoint.m_OutgoingDistance.m_Property; - - IDocumentReader &theReader(m_Doc.GetDocumentReader()); - SFloat2 anchorPos = - *theReader.GetTypedInstancePropertyValue<SFloat2>(theAnchorHandle, thePosProperty); - QT3DSVec2 anchorPosVec = QT3DSVec2(anchorPos[0], anchorPos[1]); - if (m_LastPathDragValue.hasValue() == false) { - SPathAnchorDragInitialValue initialValue; - initialValue.m_Position = anchorPosVec; - initialValue.m_IncomingAngle = theReader.GetTypedInstancePropertyValue<float>( - theAnchorHandle, theAngleProperty); - initialValue.m_IncomingDistance = theReader.GetTypedInstancePropertyValue<float>( - theAnchorHandle, theIncomingDistanceProperty); - initialValue.m_OutgoingDistance = theReader.GetTypedInstancePropertyValue<float>( - theAnchorHandle, theOutgoingDistanceProperty); - m_LastPathDragValue = initialValue; - } - SPathAnchorDragInitialValue &lastValue(*m_LastPathDragValue); - QT3DSVec2 theCurrentValue; - switch (inPathPick.m_Property) { - case SPathPick::Anchor: - theCurrentValue = lastValue.m_Position; - break; - case SPathPick::IncomingControl: - theCurrentValue = qt3ds::render::IPathManagerCore::GetControlPointFromAngleDistance( - lastValue.m_Position, lastValue.m_IncomingAngle, lastValue.m_IncomingDistance); - break; - case SPathPick::OutgoingControl: - theCurrentValue = qt3ds::render::IPathManagerCore::GetControlPointFromAngleDistance( - lastValue.m_Position, lastValue.m_IncomingAngle + 180.0f, - lastValue.m_OutgoingDistance); - break; - default: - QT3DS_ASSERT(false); - break; - } - theCurrentValue[0] += theDiff.x; - theCurrentValue[1] += theDiff.y; - Q3DStudio::IDocumentEditor &theEditor = inEditor.EnsureEditor( - QObject::tr("Anchor Point Drag"), __FILE__, __LINE__); - switch (inPathPick.m_Property) { - case SPathPick::Anchor: - theEditor.SetInstancePropertyValue(theAnchorHandle, thePosProperty, - SFloat2(theCurrentValue.x, theCurrentValue.y)); - break; - case SPathPick::IncomingControl: { - QT3DSVec2 angleDistance = - qt3ds::render::IPathManagerCore::GetAngleDistanceFromControlPoint( - anchorPosVec, theCurrentValue); - float angleDiff = angleDistance.x - lastValue.m_IncomingAngle; - float minimalDiff = - qRadiansToDegrees(qt3ds::render::SRotationHelper::ToMinimalAngle( - qDegreesToRadians(angleDiff))); - float newAngle = lastValue.m_IncomingAngle + minimalDiff; - theEditor.SetInstancePropertyValue(theAnchorHandle, theAngleProperty, newAngle); - theEditor.SetInstancePropertyValue(theAnchorHandle, theIncomingDistanceProperty, - angleDistance.y); - } break; - case SPathPick::OutgoingControl: { - QT3DSVec2 angleDistance = - qt3ds::render::IPathManagerCore::GetAngleDistanceFromControlPoint( - anchorPosVec, theCurrentValue); - angleDistance.x += 180.0f; - float angleDiff = angleDistance.x - lastValue.m_IncomingAngle; - float minimalDiff = - qRadiansToDegrees(qt3ds::render::SRotationHelper::ToMinimalAngle( - qDegreesToRadians(angleDiff))); - float newAngle = lastValue.m_IncomingAngle + minimalDiff; - theEditor.SetInstancePropertyValue(theAnchorHandle, theAngleProperty, newAngle); - theEditor.SetInstancePropertyValue(theAnchorHandle, theOutgoingDistanceProperty, - angleDistance.y); - } break; - } - - inEditor.FireImmediateRefresh(m_AssetGraph.GetParent(theAnchorHandle)); - } - } -} - -SNode *STranslation::GetEditCameraLayer() -{ - if (m_EditCameraLayerTranslator) - return static_cast<SNode *>(&m_EditCameraLayerTranslator->GetGraphObject()); - return nullptr; -} - -PickTargetAreas::Enum STranslation::GetPickArea(CPt inPoint) -{ - qt3ds::render::NVRenderRectF displayViewport = m_Context.GetDisplayViewport(); - QT3DSVec2 thePickPoint((QT3DSF32)inPoint.x, - m_Context.GetWindowDimensions().height() - (QT3DSF32)inPoint.y); - QT3DSF32 left = displayViewport.m_X; - QT3DSF32 right = displayViewport.m_X + displayViewport.m_Width; - QT3DSF32 top = displayViewport.m_Y + displayViewport.m_Height; - QT3DSF32 bottom = displayViewport.m_Y; - if (thePickPoint.x < left || thePickPoint.x > right || thePickPoint.y < bottom - || thePickPoint.y > top) - return PickTargetAreas::Matte; - return PickTargetAreas::Presentation; -} |