diff options
Diffstat (limited to 'Runtime/Filters/Renderer.cpp')
| -rw-r--r-- | Runtime/Filters/Renderer.cpp | 663 |
1 files changed, 663 insertions, 0 deletions
diff --git a/Runtime/Filters/Renderer.cpp b/Runtime/Filters/Renderer.cpp new file mode 100644 index 0000000..33a0b5b --- /dev/null +++ b/Runtime/Filters/Renderer.cpp @@ -0,0 +1,663 @@ +#include "UnityPrefix.h" +#include "Renderer.h" +#include "Runtime/Shaders/Material.h" +#include "Runtime/Shaders/MaterialProperties.h" +#include "Runtime/Camera/UnityScene.h" +#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h" +#include "Runtime/Graphics/Transform.h" +#include "Runtime/Geometry/AABB.h" +#include "Runtime/Camera/Camera.h" +#include "Runtime/Camera/Culler.h" +#include "Runtime/BaseClasses/SupportedMessageOptimization.h" +#include "Runtime/Misc/BuildSettings.h" +#include "Runtime/Camera/LODGroup.h" +#include "Runtime/BaseClasses/EventIDs.h" +#include "Runtime/Misc/GameObjectUtility.h" +#include "Runtime/Modules/ExportModules.h" +#include "RendererAnimationBinding.h" + +using namespace Unity; + +IMPLEMENT_CLASS_HAS_POSTINIT (Renderer) +IMPLEMENT_OBJECT_SERIALIZE (Renderer) +INSTANTIATE_TEMPLATE_TRANSFER_EXPORTED (Renderer) + +typedef List< ListNode<Renderer> > RendererList; +static RendererList gRenderersToUpdate; + + +static Transform *gIdentityTransform = NULL; + +Transform* GetIdentityTransform() { return gIdentityTransform; } + +Renderer::Renderer (RendererType type, MemLabelId label, ObjectCreationMode mode) +: Super(label, mode) +, BaseRenderer(type) +, m_LODGroup (NULL) +, m_SceneHandle(kInvalidSceneHandle) +, m_RenderersListNode(this) +, m_Enabled(true) +, m_Visible(true) +//, m_Materials (Renderer::MaterialArray::allocator_type (*baseAllocator)) +#if UNITY_EDITOR +, m_SelectedWireframeHidden(false) +#endif +, m_UseLightProbes(false) +, m_LastLightProbeTetIndex(-1) +, m_SortingLayer(0) +, m_SortingOrder(0) +#if UNITY_EDITOR +, m_SortingLayerID(0) +#endif +{ + +} + +void Renderer::SmartReset () +{ + Super::SmartReset(); + SetMaterialCount (1); +} + +Renderer::~Renderer () +{ + DebugAssert (!IsInScene()); + delete m_CustomProperties; + + if (m_LODGroup) + m_LODGroup->RemoveFromCachedRenderers(this); +} + +void Renderer::CleanupClass() +{ + Assert(gIdentityTransform != NULL); + gIdentityTransform = NULL; + + CleanupRendererAnimationBindingInterface (); +} + +void Renderer::InitializeClass() +{ + REGISTER_MESSAGE (Renderer, kTransformChanged, TransformChanged, int); + REGISTER_MESSAGE_VOID (Renderer, kLayerChanged, LayerChanged); + + InitializeRendererAnimationBindingInterface (); +} + +void Renderer::PostInitializeClass() +{ + Assert(gIdentityTransform == NULL); + + GameObject* go = CreateObjectFromCode<GameObject> (); + gIdentityTransform = CreateObjectFromCode<Transform> (); + GameObject::AddComponentInternal(*go, *gIdentityTransform); + go->SetHideFlags(kHideAndDontSave); + Assert(!go->IsActive()); +} + +bool Renderer::IsVisibleInScene () const +{ + Assert ((m_IsVisibleInScene && IsInScene()) == m_IsVisibleInScene); + return m_IsVisibleInScene; +} + +void Renderer::RendererBecameVisible() +{ + BaseRenderer::RendererBecameVisible (); + + InvokeEvent (kBecameVisibleEvent); + + SendMessage (kBecameVisible); +} + +void Renderer::RendererBecameInvisible() +{ + BaseRenderer::RendererBecameInvisible (); + + SendMessage (kBecameInvisible); + + InvokeEvent (kBecameInvisibleEvent); +} + +int Renderer::GetLayer() const +{ + return GetGameObject().GetLayer(); +} + + +void Renderer::SetVisible (bool visible) +{ + m_Visible = visible; + + bool shouldBeInScene = ShouldBeInScene(); + if (shouldBeInScene == IsInScene()) + return; + + if (!shouldBeInScene) + { + // Remove from scene immediately + RemoveFromScene (); + UpdateManagerState( false ); + + InvokeEvent(kBecameInvisibleEvent); + } + else + { + // Add to scene in renderers update + UpdateManagerState( true ); + } +} + +void Renderer::BoundsChanged () +{ + m_BoundsDirty = true; + if (IsInScene()) + GetScene().SetDirtyAABB(m_SceneHandle); +} + +void Renderer::LayerMaskChanged () +{ + if (IsInScene()) + GetScene().SetRendererLayer(m_SceneHandle, GetLayer()); +} + +void Renderer::UpdateManagerState( bool needsUpdate ) +{ + if( needsUpdate == m_RenderersListNode.IsInList() ) + return; + if( needsUpdate ) + gRenderersToUpdate.push_front(m_RenderersListNode); + else + m_RenderersListNode.RemoveFromList(); +} + +void Renderer::UpdateAllRenderersInternal() +{ + // Update the renderers from the update list: + // - before updating each, remove from the list + // - a renderer can add itself again, so only process the original list length + RendererList::iterator next, listEnd = gRenderersToUpdate.end(); + for( RendererList::iterator i = gRenderersToUpdate.begin(); i != listEnd; i = next ) + { + next = i; + next++; + Renderer& renderer = **i; + renderer.m_RenderersListNode.RemoveFromList(); + renderer.UpdateRenderer(); + } +} + +void Renderer::NotifySceneHandleChange (SceneHandle handle) +{ + m_SceneHandle = handle; +} + +void Renderer::UpdateLODGroup () +{ + if (!IsInScene()) + return; + Unity::Scene& scene = GetScene(); + DebugAssert (scene.GetRendererNode(m_SceneHandle).renderer == this); + + UInt32 lodGroup = 0; + UInt32 lodIndexMask = 0; + if (m_LODGroup != NULL) + { + m_LODGroup->GetLODGroupIndexAndMask(this, &lodGroup, &lodIndexMask); + } + scene.SetRendererLODGroup(m_SceneHandle, lodGroup); + scene.SetRendererLODIndexMask(m_SceneHandle, lodIndexMask); +} + +void Renderer::UpdateSceneHandle () +{ + if (!IsInScene()) + return; + Unity::Scene& scene = GetScene(); + DebugAssert (scene.GetRendererNode(m_SceneHandle).renderer == this); + + AABB worldAABB; + GetWorldAABB (worldAABB); + scene.SetRendererAABB(m_SceneHandle, worldAABB); + + bool needsCullCallback = (GetGameObject().GetSupportedMessages() & kHasOnWillRenderObject) != 0; + scene.SetRendererNeedsCullCallback(m_SceneHandle, needsCullCallback); + scene.SetRendererLayer(m_SceneHandle, GetLayer()); + + UpdateLODGroup(); +} + +void Renderer::UpdateTransformInfo () +{ + Transform const& transform = GetTransform(); + if(m_TransformDirty) + { + m_TransformInfo.invScale = 1.0f; + // will return a cached matrix most of the time + m_TransformInfo.transformType = transform.CalculateTransformMatrix (m_TransformInfo.worldMatrix); + } + + if(m_BoundsDirty) + UpdateLocalAABB (); + + TransformAABB( m_TransformInfo.localAABB, m_TransformInfo.worldMatrix, m_TransformInfo.worldAABB ); + + if (IsNoScaleTransform(m_TransformInfo.transformType)) + return; + + // run slow path for non uniform scale + Matrix4x4f scaleOnly; + float scale; + TransformType type = transform.CalculateTransformMatrixDisableNonUniformScale (m_TransformInfo.worldMatrix, scaleOnly, scale); + Assert (type == m_TransformInfo.transformType); + + m_TransformInfo.invScale = 1.0F / scale; + + if (IsNonUniformScaleTransform(type)) + { + // must recalculate this since it is changed with the following transform + UpdateLocalAABB (); + TransformAABB (m_TransformInfo.localAABB, scaleOnly, m_TransformInfo.localAABB); + } +} + +void Renderer::UpdateRenderer () +{ + if (ShouldBeInScene ()) + { + if (!IsInScene()) + { + m_SceneHandle = GetScene().AddRenderer (this); + } + Assert (m_SceneHandle != kInvalidSceneHandle); + UpdateSceneHandle (); + } + else + { + // This should not be necessary but fixes a weird bug where a mesh is + // being leaked when disabled before loading a scene. Happens in the fps tutorial. + RemoveFromScene (); + } +} + +void Renderer::SetPropertyBlock (const MaterialPropertyBlock& block) +{ + delete m_CustomProperties; + m_CustomProperties = new MaterialPropertyBlock (block); + ComputeCustomPropertiesHash(); +} + +void Renderer::GetPropertyBlock (MaterialPropertyBlock& outBlock) +{ + if (!m_CustomProperties) + { + outBlock.Clear(); + return; + } + outBlock = *m_CustomProperties; +} + +void Renderer::ClearPropertyBlock () +{ + delete m_CustomProperties; + m_CustomProperties = NULL; + ComputeCustomPropertiesHash(); +} + +MaterialPropertyBlock& Renderer::GetPropertyBlockRememberToUpdateHash () +{ + if (!m_CustomProperties) + m_CustomProperties = new MaterialPropertyBlock (); + return *m_CustomProperties; +} + + +void Renderer::SetEnabled (bool newEnabled) +{ + m_Enabled = newEnabled; + SetDirty(); + SetVisible(m_Visible); +} + +void Renderer::Deactivate (DeactivateOperation operation) +{ + RemoveFromScene (); + UpdateManagerState( false ); + Super::Deactivate (operation); +} + +/// Set how many materials this renderer uses +/// @param size the number of materials. +void Renderer::SetMaterialCount (int size) +{ + const size_t oldSize = m_Materials.size (); + + if (size != (int)oldSize) + { + Assert(m_SubsetIndices.empty() || m_SubsetIndices.size() == m_Materials.size()); + + resize_trimmed (m_Materials, size); + HealSubsetIndices(); + + SetDirty (); + BoundsChanged(); + } +} + +void Renderer::HealSubsetIndices() +{ + // We are using batching and our subset indices have gone out of sync + if (!m_SubsetIndices.empty() && m_SubsetIndices.size() != m_Materials.size()) + { + int oldSize = m_SubsetIndices.size(); + resize_trimmed (m_SubsetIndices, m_Materials.size()); + // All new subset indices get the + for (size_t q = oldSize; q < m_SubsetIndices.size(); ++q) + m_SubsetIndices[q] = (UInt32)q; + BoundsChanged(); + } +} + +void Renderer::RemoveFromScene () +{ + if (!IsInScene()) + return; + + bool wasVisible = IsVisibleInScene (); + + BaseRenderer* remRenderer = GetScene ().RemoveRenderer (m_SceneHandle); + Assert(remRenderer == this); + + m_SceneHandle = kInvalidSceneHandle; + + if (wasVisible) + RendererBecameInvisible (); +} + +void Renderer::CheckConsistency() +{ + Super::CheckConsistency(); + + HealSubsetIndices(); +} + +void Renderer::ClearSubsetIndices() +{ + m_SubsetIndices.clear(); + SetDirty (); + BoundsChanged(); +} + +void Renderer::SetSubsetIndex (int index, int subsetIndex) +{ + if (m_SubsetIndices.empty()) + { + resize_trimmed (m_SubsetIndices, m_Materials.size()); + for (size_t q = 0; q < m_Materials.size(); ++q) + m_SubsetIndices[q] = (UInt32)q; + } + + Assert(index < m_SubsetIndices.size()); + Assert (m_Materials.size() == m_SubsetIndices.size()); + m_SubsetIndices[index] = subsetIndex; + SetDirty (); + BoundsChanged(); +} + +/// Set a given Material. +/// @param material the material to assign +/// @param index the index to assign the material to. +void Renderer::SetMaterial (PPtr<Material> material, int index) +{ + Assert (index < m_Materials.size()); + m_Materials[index] = material; + + /* + #if !DEPLOY_OPTIMIZED + Material* materialPtr = material; + if (materialPtr && materialPtr->GetOwner ().GetInstanceID () != 0 && materialPtr->GetOwner() != PPtr<Object> (this)) + { + ErrorString("Assigning an instantiated material is not a good idea. Since the material is owned by another game object, it will be destroyed when the game object is destroyed.\nYou probably want to explicitly instantiate the material."); + } + #endif + */ + + SetDirty (); +} + +void Renderer::SetMaterialArray( const MaterialArray& m, const IndexArray& i ) +{ + m_Materials = m; + m_SubsetIndices = i; +} + +Material* Renderer::GetAndAssignInstantiatedMaterial(int i, bool allowFromEditMode) +{ + // Grab shared material + Material* material = NULL; + if (GetMaterialCount () > i) + material = GetMaterial (i); + + // instantiate material if necessary + Material* instantiated = &Material::GetInstantiatedMaterial (material, *this, allowFromEditMode); + + // Assign material + if (material != instantiated) + { + SetMaterialCount (std::max(GetMaterialCount (), i + 1)); + SetMaterial (instantiated, i); + } + + return instantiated; +} + +Transform& Renderer::GetTransform() +{ + if (!IsPartOfStaticBatch()) + return GetComponent(Transform); + + if (!m_StaticBatchRoot.IsNull()) + return *m_StaticBatchRoot; + + return *gIdentityTransform; +} + +Transform const& Renderer::GetTransform() const +{ + return const_cast<Renderer*>(this)->GetTransform(); +} + +Matrix4x4f Renderer::GetWorldToLocalMatrix () const +{ + return GetTransform().GetWorldToLocalMatrix(); +} + +Matrix4x4f Renderer::GetLocalToWorldMatrix () const +{ + return GetTransform().GetLocalToWorldMatrix(); +} + + +// Receiver for the TransformChanged message. +// Updates the scene info with the new bounds. +void Renderer::TransformChanged (int changeMask) +{ + m_TransformDirty = true; + BoundsChanged (); +} + +// Receiver for the LayerChanged message. +// Updates the scene info with the new layerMask. +void Renderer::LayerChanged () +{ + LayerMaskChanged (); +} + +void Renderer::AwakeFromLoad (AwakeFromLoadMode awakeMode) +{ + Super::AwakeFromLoad (awakeMode); + + // Materials might have been changed eg. from the property editor + // When loading from disk the materials are only being restored not changed + if ((awakeMode & kDidLoadFromDisk) == 0) + { + // m_Enabled might have changed - update visibility status + SetVisible(m_Visible); + } + + UpdateManagerState( IsActive() ); + SetupSortingOverride(); +} + +void Renderer::SupportedMessagesDidChange (int mask) +{ + Super::SupportedMessagesDidChange(mask); + + if (IsInScene()) + { + bool needsCullCallback = (GetGameObject().GetSupportedMessages() & kHasOnWillRenderObject) != 0; + GetScene().SetRendererNeedsCullCallback(m_SceneHandle, needsCullCallback); + } +} + +void Renderer::SetLightmapIndexInt(int index) +{ + UInt8 oldIndex = m_LightmapIndex; + SetLightmapIndexIntNoDirty (index); + if (oldIndex != m_LightmapIndex) + SetDirty(); +} + +void Renderer::SetLightmapST( const Vector4f& st ) +{ + if (st != m_LightmapST) + { + m_LightmapST = st; + SetDirty(); + } +} + + +#if UNITY_EDITOR +bool Renderer::CanSelectedWireframeBeRendered () const +{ + return m_Enabled && m_Visible && IsInScene() && !m_SelectedWireframeHidden; +} +#endif + +template<class TransferFunction> +void Renderer::Transfer (TransferFunction& transfer) +{ + Super::Transfer (transfer); + transfer.Transfer(m_Enabled, "m_Enabled", kHideInEditorMask); + transfer.Transfer(m_CastShadows, "m_CastShadows"); + transfer.Transfer(m_ReceiveShadows, "m_ReceiveShadows"); + transfer.Transfer(m_LightmapIndex, "m_LightmapIndex", kHideInEditorMask | kDontAnimate); + transfer.Transfer(m_LightmapST, "m_LightmapTilingOffset", kHideInEditorMask | kDontAnimate); + transfer.Transfer (m_Materials, "m_Materials"); + transfer.Transfer (m_SubsetIndices, "m_SubsetIndices", kHideInEditorMask); + transfer.Transfer (m_StaticBatchRoot, "m_StaticBatchRoot", kHideInEditorMask); + TRANSFER (m_UseLightProbes); + transfer.Align(); + TRANSFER (m_LightProbeAnchor); + #if UNITY_EDITOR + if (!transfer.IsSerializingForGameRelease()) + transfer.Transfer (m_ScaleInLightmap, "m_ScaleInLightmap", kHideInEditorMask | kDontAnimate); + #endif + transfer.Align(); + + transfer.Transfer (m_SortingLayer, "m_SortingLayer", kHideInEditorMask); + transfer.Transfer (m_SortingOrder, "m_SortingOrder", kHideInEditorMask); + // In the editor, we also transfer global sorting layer ID, so we can derive final sorting value + // in case layers are reordered / etc. + TRANSFER_EDITOR_ONLY_HIDDEN(m_SortingLayerID); +} + +Vector3f Renderer::GetLightProbeInterpolationPosition (const AABB& worldBounds) +{ + Transform* anchor = m_LightProbeAnchor; + if (anchor != NULL) + return anchor->GetPosition(); + + return worldBounds.GetCenter(); +} + + +Vector3f Renderer::GetLightProbeInterpolationPosition () +{ + Transform* anchor = m_LightProbeAnchor; + if (anchor != NULL) + return anchor->GetPosition(); + + AABB aabb; + GetWorldAABB(aabb); + if (aabb.IsValid()) + return aabb.GetCenter(); + + return Vector3f(0,0,0); +} + + + +int Renderer::GetSortingLayerUserID() const +{ + if (m_SortingLayer == 0) + return 0; + return ::GetSortingLayerUserIDFromValue(m_SortingLayer); +} + +void Renderer::SetSortingLayerUserID(int id) +{ + int layerValue = GetSortingLayerValueFromUserID(id); + if (m_SortingLayer == layerValue) + return; + +# if UNITY_EDITOR + if (layerValue == 0) + m_SortingLayerID = 0; + else + m_SortingLayerID = ::GetSortingLayerUniqueIDFromValue(layerValue); +# endif + + m_SortingLayer = layerValue; + SetupSortingOverride(); + SetDirty(); +} + +std::string Renderer::GetSortingLayerName() const +{ + if (m_SortingLayer == 0) + return std::string(); + return ::GetSortingLayerNameFromValue(m_SortingLayer); +} + +void Renderer::SetSortingLayerName(const std::string& name) +{ + int layerValue = ::GetSortingLayerValueFromName(name); + int layerUserID = ::GetSortingLayerUserIDFromValue(layerValue); + SetSortingLayerUserID (layerUserID); +} + + +void Renderer::SetSortingOrder(SInt16 newValue) +{ + if (m_SortingOrder == newValue) + return; + + m_SortingOrder = newValue; + SetupSortingOverride(); +} + +void Renderer::SetupSortingOverride() +{ + // In editor, make sure our final layer sorting value is up to date + // (might have changed behind our backs by global layer reordering). +# if UNITY_EDITOR + m_SortingLayer = GetSortingLayerValueFromUniqueID(m_SortingLayerID); +# endif // if UNITY_EDITOR + + GlobalLayeringData gld = GlobalLayeringDataCleared(); + gld.layer = m_SortingLayer; + gld.order = m_SortingOrder; + SetGlobalLayeringData(gld); +} |