dali/internal/update/node-attachments/scene-graph-renderable-attachment.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/update/node-attachments/scene-graph-renderable-attachment.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/integration-api/resource-declarations.h>
  23 #include <dali/public-api/actors/image-actor.h>
  24 #include <dali/internal/update/manager/prepare-render-instructions.h>
  25 #include <dali/internal/update/nodes/node.h>
  26 #include <dali/internal/update/resources/resource-manager.h>
  27 #include <dali/internal/update/resources/complete-status-manager.h>
  28 #include <dali/internal/update/resources/resource-tracker.h>
  29 #include <dali/internal/render/queue/render-queue.h>
  30 #include <dali/internal/render/renderers/render-renderer.h>
  31 #include <dali/internal/render/shaders/scene-graph-shader.h>
  32 #include <dali/internal/common/image-sampler.h>
  33
  34 namespace Dali
  35 {
  36
  37 namespace Internal
  38 {
  39
  40 namespace SceneGraph
  41 {
  42
  43 RenderableAttachment::RenderableAttachment( bool usesGeometryScaling )
  44 : mSceneController(NULL), //@todo MESH_REWORK Pass in where required rather than store
  45   mShader( NULL ),
  46   mTrackedResources(),
  47   mSortModifier( 0.0f ),
  48   mBlendingMode( Dali::ImageActor::DEFAULT_BLENDING_MODE ),
  49   mUsesGeometryScaling( usesGeometryScaling ),
  50   mScaleForSizeDirty( true ),
  51   mHasSizeAndColorFlag( false ),
  52   mResourcesReady( false ),
  53   mFinishedResourceAcquisition( false ),
  54   mHasUntrackedResources( false )
  55 {
  56 }
  57
  58 RenderableAttachment::~RenderableAttachment()
  59 {
  60 }
  61
  62 void RenderableAttachment::Initialize( SceneController& sceneController, BufferIndex updateBufferIndex )
  63 {
  64   mSceneController = &sceneController;
  65
  66   // Chain to derived attachments
  67   Initialize2( updateBufferIndex );
  68 }
  69
  70 void RenderableAttachment::OnDestroy()
  71 {
  72   // Chain to derived attachments
  73   OnDestroy2();
  74
  75   // SceneController is no longer valid
  76   mSceneController = NULL;
  77 }
  78
  79 void RenderableAttachment::SetRecalculateScaleForSize()
  80 {
  81   mScaleForSizeDirty = true;
  82 }
  83
  84 void RenderableAttachment::GetScaleForSize( const Vector3& nodeSize, Vector3& scaling )
  85 {
  86   DoGetScaleForSize( nodeSize, scaling );
  87   mScaleForSizeDirty = false;
  88 }
  89
  90 bool RenderableAttachment::ResolveVisibility( BufferIndex updateBufferIndex )
  91 {
  92   mHasSizeAndColorFlag = mParent->ResolveVisibility(updateBufferIndex);
  93   return mHasSizeAndColorFlag;
  94 }
  95
  96 void RenderableAttachment::DoGetScaleForSize( const Vector3& nodeSize, Vector3& scaling )
  97 {
  98   scaling = Vector3::ONE;
  99 }
 100
 101 void RenderableAttachment::PrepareResources( BufferIndex updateBufferIndex, ResourceManager& resourceManager )
 102 {
 103   mHasUntrackedResources = false; // Only need to know this if the resources are not yet complete
 104   mTrackedResources.Clear(); // Resource trackers are only needed if not yet completea
 105
 106   if( mShader )
 107   {
 108     Integration::ResourceId id = mShader->GetEffectTextureResourceId();
 109
 110     if( id != 0 )
 111     {
 112       CompleteStatusManager& completeStatusManager = mSceneController->GetCompleteStatusManager();
 113
 114       if(CompleteStatusManager::COMPLETE != completeStatusManager.GetStatus( id ))
 115       {
 116         FollowTracker(id);
 117         mFinishedResourceAcquisition = false;
 118         mResourcesReady = false;
 119
 120         // If shader has effect texture and it's not complete and tracked, ensure
 121         // we call DoPrepareResources, as the effect texture may become ready in
 122         // the ProcessRenderTasks step.  Otherwise, may early out.
 123         if( mHasUntrackedResources )
 124         {
 125           return;
 126         }
 127       }
 128     }
 129   }
 130
 131   mResourcesReady = DoPrepareResources( updateBufferIndex, resourceManager );
 132 }
 133
 134 void RenderableAttachment::FollowTracker( Integration::ResourceId id )
 135 {
 136   CompleteStatusManager& completeStatusManager = mSceneController->GetCompleteStatusManager();
 137
 138   if( completeStatusManager.FindResourceTracker(id) != NULL )
 139   {
 140     bool found = false;
 141     std::size_t numTrackedResources = mTrackedResources.Count();
 142     for( size_t i=0; i < numTrackedResources; ++i )
 143     {
 144       if(mTrackedResources[i] == id)
 145       {
 146         found = true;
 147         break;
 148       }
 149     }
 150     if( ! found )
 151     {
 152       mTrackedResources.PushBack( id );
 153     }
 154   }
 155   else
 156   {
 157     mHasUntrackedResources = true;
 158   }
 159 }
 160
 161
 162 void RenderableAttachment::GetReadyAndComplete(bool& ready, bool& complete) const
 163 {
 164   ready = mResourcesReady;
 165   complete = false;
 166
 167   CompleteStatusManager& completeStatusManager = mSceneController->GetCompleteStatusManager();
 168
 169   std::size_t numTrackedResources = mTrackedResources.Count();
 170   if( mHasUntrackedResources || numTrackedResources == 0 )
 171   {
 172     complete = mFinishedResourceAcquisition;
 173   }
 174   else
 175   {
 176     // If there are tracked resources and no untracked resources, test the trackers
 177     bool trackersComplete = true;
 178     for( size_t i=0; i < numTrackedResources; ++i )
 179     {
 180       ResourceId id = mTrackedResources[i];
 181       ResourceTracker* tracker = completeStatusManager.FindResourceTracker(id);
 182       if( tracker  && ! tracker->IsComplete() )
 183       {
 184         trackersComplete = false;
 185         break;
 186       }
 187     }
 188
 189     complete = mFinishedResourceAcquisition || trackersComplete;
 190   }
 191 }
 192
 193 RenderableAttachment* RenderableAttachment::GetRenderable()
 194 {
 195   return this;
 196 }
 197
 198 void RenderableAttachment::SetSortModifier(float modifier)
 199 {
 200   // Setting sort modifier makes the node dirty, i.e. we cannot reuse previous frames render items
 201   if( mParent )
 202   {
 203     // only do this if we are on-stage
 204     mParent->SetDirtyFlag( SortModifierFlag );
 205   }
 206   mSortModifier = modifier;
 207 }
 208
 209 void RenderableAttachment::SetSortAttributes( BufferIndex bufferIndex, RendererWithSortAttributes& sortAttributes )
 210 {
 211   sortAttributes.shader = mShader;
 212   sortAttributes.textureResourceId = Integration::InvalidResourceId;
 213   sortAttributes.geometry = NULL;
 214 }
 215
 216 } // namespace SceneGraph
 217
 218 } // namespace Internal
 219
 220 } // namespace Dali