/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/update/animation/scene-graph-animation.h>
#include <dali/internal/update/common/discard-queue.h>
#include <dali/internal/update/common/scene-graph-buffers.h>
+#include <dali/internal/update/common/texture-cache-dispatcher.h>
#include <dali/internal/update/controllers/render-message-dispatcher.h>
#include <dali/internal/update/controllers/scene-controller-impl.h>
#include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
#include <dali/internal/update/manager/object-owner-container.h>
-#include <dali/internal/update/manager/process-render-tasks.h>
+#include <dali/internal/update/manager/render-task-processor.h>
#include <dali/internal/update/manager/sorted-layers.h>
#include <dali/internal/update/manager/update-algorithms.h>
#include <dali/internal/update/manager/update-manager-debug.h>
#include <dali/internal/update/manager/transform-manager.h>
-#include <dali/internal/update/node-attachments/scene-graph-camera-attachment.h>
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
#include <dali/internal/update/queue/update-message-queue.h>
#include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
#include <dali/internal/update/rendering/scene-graph-texture-set.h>
#include <dali/internal/update/resources/resource-manager.h>
-#include <dali/internal/update/touch/touch-resampler.h>
#include <dali/internal/render/common/render-instruction-container.h>
#include <dali/internal/render/common/render-manager.h>
#include <dali/internal/render/queue/render-queue.h>
#include <dali/internal/render/gl-resources/texture-cache.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
+#include <dali/internal/render/renderers/render-frame-buffer.h>
#include <dali/internal/render/renderers/render-sampler.h>
+#include <dali/internal/update/render-tasks/scene-graph-camera.h>
// Un-comment to enable node tree debug logging
//#define NODE_TREE_LOGGING 1
RenderController& renderController,
RenderManager& renderManager,
RenderQueue& renderQueue,
- TextureCache& textureCache,
- TouchResampler& touchResampler,
- SceneGraphBuffers& sceneGraphBuffers )
+ SceneGraphBuffers& sceneGraphBuffers,
+ RenderTaskProcessor& renderTaskProcessor )
: renderMessageDispatcher( renderManager, renderQueue, sceneGraphBuffers ),
notificationManager( notificationManager ),
transformManager(),
renderManager( renderManager ),
renderQueue( renderQueue ),
renderInstructions( renderManager.GetRenderInstructionContainer() ),
- touchResampler( touchResampler ),
+ renderTaskProcessor( renderTaskProcessor ),
backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
taskList( renderMessageDispatcher, resourceManager ),
systemLevelTaskList( renderMessageDispatcher, resourceManager ),
nodeDirtyFlags( TransformFlag ), // set to TransformFlag to ensure full update the first time through Update()
previousUpdateScene( false ),
frameCounter( 0 ),
- renderSortingHelper(),
renderTaskWaiting( false )
{
- sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue, textureCache );
+ sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue );
renderers.SetSceneController( *sceneController );
for(;iter!=endIter;++iter)
{
(*iter)->OnDestroy();
- delete(*iter);
+ Node::Delete(*iter);
}
// If there is root, reset it, otherwise do nothing as rendering was never started
{
root->OnDestroy();
- delete root;
+ Node::Delete( root );
root = NULL;
}
{
systemLevelRoot->OnDestroy();
- delete systemLevelRoot;
+ Node::Delete( systemLevelRoot );
systemLevelRoot = NULL;
}
- sceneController->GetTextureCache().SetBufferIndices(NULL); // TODO - Remove
delete sceneController;
}
RenderManager& renderManager; ///< This is responsible for rendering the results of each "update"
RenderQueue& renderQueue; ///< Used to queue messages for the next render
RenderInstructionContainer& renderInstructions; ///< Used to prepare the render instructions
- TouchResampler& touchResampler; ///< Used to resample touch events on every update.
+ RenderTaskProcessor& renderTaskProcessor; ///< Handles RenderTasks and RenderInstrucitons
Vector4 backgroundColor; ///< The glClear color used at the beginning of each frame.
SortedLayerPointers sortedLayers; ///< A container of Layer pointers sorted by depth
SortedLayerPointers systemLevelSortedLayers; ///< A separate container of system-level Layers
+ OwnerContainer< Camera* > cameras; ///< A container of cameras
OwnerContainer< PropertyOwner* > customObjects; ///< A container of owned objects (with custom properties)
AnimationContainer animations; ///< A container of owned animations
PropertyNotificationContainer propertyNotifications; ///< A container of owner property notifications.
ObjectOwnerContainer<Renderer> renderers;
- TextureSetContainer textureSets; ///< A container of texture sets
+ TextureSetContainer textureSets; ///< A container of texture sets
ShaderContainer shaders; ///< A container of owned shaders
bool previousUpdateScene; ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
int frameCounter; ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
- RendererSortingHelper renderSortingHelper; ///< helper used to sort transparent renderers
GestureContainer gestures; ///< A container of owned gesture detectors
bool renderTaskWaiting; ///< A REFRESH_ONCE render task is waiting to be rendered
RenderController& controller,
RenderManager& renderManager,
RenderQueue& renderQueue,
- TextureCache& textureCache,
- TouchResampler& touchResampler )
+ TextureCacheDispatcher& textureCacheDispatcher,
+ RenderTaskProcessor& renderTaskProcessor )
: mImpl(NULL)
{
mImpl = new Impl( notificationManager,
controller,
renderManager,
renderQueue,
- textureCache,
- touchResampler,
- mSceneGraphBuffers );
+ mSceneGraphBuffers,
+ renderTaskProcessor );
- textureCache.SetBufferIndices( &mSceneGraphBuffers );
+ textureCacheDispatcher.SetBufferIndices( &mSceneGraphBuffers );
}
UpdateManager::~UpdateManager()
node->OnDestroy();
}
-//@todo MESH_REWORK Extend to allow arbitrary scene objects to connect to each other
-void UpdateManager::AttachToNode( Node* node, NodeAttachment* attachment )
+void UpdateManager::AddCamera( Camera* camera )
{
- DALI_ASSERT_DEBUG( node != NULL );
- DALI_ASSERT_DEBUG( attachment != NULL );
+ DALI_ASSERT_DEBUG( camera != NULL );
+
+ mImpl->cameras.PushBack( camera ); // takes ownership
+}
+
+void UpdateManager::RemoveCamera( const Camera* camera )
+{
+ // Find the camera
+ OwnerContainer<Camera*>::Iterator iter = mImpl->cameras.Begin();
+ OwnerContainer<Camera*>::ConstIterator end = mImpl->cameras.End();
+ for ( ; iter != end; ++iter )
+ {
+ Camera* value = *iter;
+ if ( camera == value )
+ {
+ // Transfer ownership to the discard queue
+ mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), mImpl->cameras.Release( iter ) );
+
+ return;
+ }
+ }
- // attach node to attachment first so that parent is known by the time attachment is connected
- node->Attach( *attachment ); // node takes ownership
}
void UpdateManager::AddObject( PropertyOwner* object )
if( textureSet == mImpl->textureSets[i] )
{
mImpl->textureSets.Remove( mImpl->textureSets.Begin() + i );
+
+ // Update manager has ownership of the TextureSet
+ delete textureSet;
return;
}
}
//Apply constraints
ConstrainPropertyOwner( *rendererContainer[i], bufferIndex );
- if( rendererContainer[i]->IsReferenced() )
- {
- rendererContainer[i]->PrepareRender( bufferIndex );
- }
+ rendererContainer[i]->PrepareRender( bufferIndex );
}
}
return;
}
- // Prepare resources, update shaders, update attachments, for each node
+ // Prepare resources, update shaders, for each node
// And add the renderers to the sorted layers. Start from root, which is also a layer
- mImpl->nodeDirtyFlags = UpdateNodesAndAttachments( *( mImpl->root ),
- bufferIndex,
- mImpl->resourceManager,
- mImpl->renderQueue );
+ mImpl->nodeDirtyFlags = UpdateNodeTree( *( mImpl->root ),
+ bufferIndex,
+ mImpl->resourceManager,
+ mImpl->renderQueue );
if ( mImpl->systemLevelRoot )
{
- mImpl->nodeDirtyFlags |= UpdateNodesAndAttachments( *( mImpl->systemLevelRoot ),
- bufferIndex,
- mImpl->resourceManager,
- mImpl->renderQueue );
+ mImpl->nodeDirtyFlags |= UpdateNodeTree( *( mImpl->systemLevelRoot ),
+ bufferIndex,
+ mImpl->resourceManager,
+ mImpl->renderQueue );
}
}
bool resourceChanged = mImpl->resourceManager.UpdateCache( bufferIndex );
//Process Touches & Gestures
- mImpl->touchResampler.Update();
const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
- const bool updateScene = // The scene-graph requires an update if..
+ bool updateScene = // The scene-graph requires an update if..
(mImpl->nodeDirtyFlags & RenderableUpdateFlags) || // ..nodes were dirty in previous frame OR
IsAnimationRunning() || // ..at least one animation is running OR
mImpl->messageQueue.IsSceneUpdateRequired() || // ..a message that modifies the scene graph node tree is queued OR
mImpl->transformManager.ResetToBaseValue();
}
- //Process the queued scene messages
- mImpl->messageQueue.ProcessMessages( bufferIndex );
+ // Process the queued scene messages. Note, MessageQueue::FlushQueue may be called
+ // between calling IsSceneUpdateRequired() above and here, so updateScene should
+ // be set again
+ updateScene |= mImpl->messageQueue.ProcessMessages( bufferIndex );
//Post Process Ids of resources updated by renderer
mImpl->resourceManager.PostProcessResources( bufferIndex );
//Prepare texture sets and apply constraints to them
PrepareTextureSets( bufferIndex );
- //Clear the lists of renderable-attachments from the previous update
+ //Clear the lists of renderers from the previous update
for( size_t i(0); i<mImpl->sortedLayers.size(); ++i )
{
mImpl->sortedLayers[i]->ClearRenderables();
if ( NULL != mImpl->root )
{
- ProcessRenderTasks( bufferIndex,
- mImpl->taskList,
- *mImpl->root,
- mImpl->sortedLayers,
- mImpl->renderSortingHelper,
- mImpl->renderInstructions );
+ mImpl->renderTaskProcessor.Process( bufferIndex,
+ mImpl->taskList,
+ *mImpl->root,
+ mImpl->sortedLayers,
+ mImpl->renderInstructions );
// Process the system-level RenderTasks last
if ( NULL != mImpl->systemLevelRoot )
{
- ProcessRenderTasks( bufferIndex,
- mImpl->systemLevelTaskList,
- *mImpl->systemLevelRoot,
- mImpl->systemLevelSortedLayers,
- mImpl->renderSortingHelper,
- mImpl->renderInstructions );
+ mImpl->renderTaskProcessor.Process( bufferIndex,
+ mImpl->systemLevelTaskList,
+ *mImpl->systemLevelRoot,
+ mImpl->systemLevelSortedLayers,
+ mImpl->renderInstructions );
}
}
}
new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
}
-void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode )
+void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode )
{
- typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
+ typedef MessageValue4< RenderManager, Render::Sampler*, unsigned int, unsigned int, unsigned int > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetWrapMode, sampler, uWrapMode, vWrapMode );
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
}
void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveGeometry, geometry );
}
-void UpdateManager::SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest )
-{
- typedef MessageValue2< RenderManager, Render::Geometry*, bool > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetGeometryRequiresDepthTest, geometry, requiresDepthTest );
-}
-
void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
{
typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType;
new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddVertexBuffer, geometry, propertyBuffer );
}
+void UpdateManager::AddTexture( Render::NewTexture* texture )
+{
+ typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddTexture, texture );
+}
+
+void UpdateManager::RemoveTexture( Render::NewTexture* texture)
+{
+ typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveTexture, texture );
+}
+
+void UpdateManager::UploadTexture( Render::NewTexture* texture, PixelDataPtr pixelData, const NewTexture::UploadParams& params )
+{
+ typedef MessageValue3< RenderManager, Render::NewTexture*, PixelDataPtr, NewTexture::UploadParams > DerivedType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
+}
+
+void UpdateManager::GenerateMipmaps( Render::NewTexture* texture )
+{
+ typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::GenerateMipmaps, texture );
+}
+
+void UpdateManager::AddFrameBuffer( Render::FrameBuffer* frameBuffer )
+{
+ typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddFrameBuffer, frameBuffer );
+}
+
+void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
+{
+ typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveFrameBuffer, frameBuffer );
+}
+
+void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::NewTexture* texture, unsigned int mipmapLevel, unsigned int layer )
+{
+ typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::NewTexture*, unsigned int, unsigned int > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
+}
} // namespace SceneGraph
projects / platform / core / uifw / dali-core.git / blobdiff