void FrameBuffer::Initialize()
{
mRenderObject = new SceneGraph::FrameBuffer( mWidth, mHeight, mAttachments );
- AddFrameBuffer( mEventThreadServices.GetUpdateManager(), *mRenderObject );
+ OwnerPointer< SceneGraph::FrameBuffer > transferOwnership( mRenderObject );
+ AddFrameBufferMessage( mEventThreadServices.GetUpdateManager(), transferOwnership );
}
void FrameBuffer::AttachColorTexture( TexturePtr texture, unsigned int mipmapLevel, unsigned int layer )
( texture->GetHeight() / ( 1u << mipmapLevel ) == mHeight ) )
{
mColor = texture;
- AttachColorTextureToFrameBuffer( mEventThreadServices.GetUpdateManager(), *mRenderObject, texture->GetRenderObject(), mipmapLevel, layer );
+ AttachColorTextureMessage( mEventThreadServices, *mRenderObject, texture->GetRenderObject(), mipmapLevel, layer );
}
else
{
{
if( EventThreadServices::IsCoreRunning() && mRenderObject )
{
- RemoveFrameBuffer( mEventThreadServices.GetUpdateManager(), *mRenderObject );
+ RemoveFrameBufferMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject );
}
}
{
mRenderObject = new SceneGraph::Geometry();
OwnerPointer< SceneGraph::Geometry > transferOwnership( mRenderObject );
- AddGeometry( mEventThreadServices.GetUpdateManager(), transferOwnership );
+ AddGeometryMessage( mEventThreadServices.GetUpdateManager(), transferOwnership );
}
Geometry::~Geometry()
{
if( EventThreadServices::IsCoreRunning() && mRenderObject )
{
- RemoveGeometry( mEventThreadServices.GetUpdateManager(), *mRenderObject );
+ RemoveGeometryMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject );
}
}
OwnerContainer< Renderer* > renderers; ///< A container of owned renderers
OwnerContainer< TextureSet* > textureSets; ///< A container of owned texture sets
OwnerContainer< Shader* > shaders; ///< A container of owned shaders
-
- OwnerContainer< SceneGraph::Sampler* > samplerContainer; ///< List of owned samplers
- OwnerContainer< SceneGraph::Texture* > textureContainer; ///< List of owned textures
- OwnerContainer< SceneGraph::FrameBuffer* > frameBufferContainer; ///< List of owned framebuffers
- OwnerContainer< SceneGraph::PropertyBuffer* > propertyBufferContainer; ///< List of owned property buffers
- OwnerContainer< SceneGraph::Geometry* > geometryContainer; ///< List of owned Geometries
+ OwnerContainer< Sampler* > samplerContainer; ///< A container of owned samplers
+ OwnerContainer< Texture* > textureContainer; ///< A container of owned textures
+ OwnerContainer< FrameBuffer* > frameBufferContainer; ///< A container of owned framebuffers
+ OwnerContainer< PropertyBuffer* > propertyBufferContainer; ///< A container of owned property buffers
+ OwnerContainer< Geometry* > geometryContainer; ///< A container of owned Geometries
OwnerPointer< PanGesture > panGestureProcessor; ///< Owned pan gesture processor; it lives for the lifecycle of UpdateManager
mImpl->systemLevelRoot->CreateTransform( &mImpl->transformManager );
mImpl->systemLevelRoot->SetRoot(true);
}
-
}
void UpdateManager::AddNode( OwnerPointer<Node>& node )
void UpdateManager::AddRenderer( OwnerPointer< Renderer >& renderer )
{
- renderer->ConnectToSceneGraph( mSceneGraphBuffers.GetUpdateBufferIndex() );
+ renderer->Initialize( mImpl->graphics );
mImpl->renderers.PushBack( renderer.Release() );
mImpl->renderersAdded = true;
}
// Find the renderer and destroy it
// @todo Don't need to use discard queue for SceneGraph::Renderer any more ( No dependency from Graphics::RenderCommand )
EraseUsingDiscardQueue( mImpl->renderers, renderer, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
- renderer->DisconnectFromSceneGraph( mSceneGraphBuffers.GetUpdateBufferIndex() );
}
void UpdateManager::SetPanGestureProcessor( PanGesture* panGestureProcessor )
//Apply constraints
ConstrainPropertyOwner( *mImpl->renderers[i], bufferIndex );
- mImpl->renderers[i]->PrepareRender( mImpl->graphics.GetController(), bufferIndex );
+ mImpl->renderers[i]->PrepareRender( bufferIndex );
}
}
{
if ( iter == texture )
{
- //texture->Destroy(); //@todo Do something in Gfx?
mImpl->textureContainer.Erase( &iter ); // Texture found; now destroy it
return;
}
}
}
-void UpdateManager::AddFrameBuffer( SceneGraph::FrameBuffer* frameBuffer )
+void UpdateManager::AddFrameBuffer( OwnerPointer< SceneGraph::FrameBuffer>& frameBuffer )
{
- mImpl->frameBufferContainer.PushBack( frameBuffer );
- //frameBuffer->Initialize(); @todo Rewrite for Gfx
+ frameBuffer->Initialize( mImpl->graphics );
+ mImpl->frameBufferContainer.PushBack( frameBuffer.Release() );
}
void UpdateManager::RemoveFrameBuffer( SceneGraph::FrameBuffer* frameBuffer)
{
if ( iter == frameBuffer )
{
- //frameBuffer->Destroy(); @todo Rewrite for Gfx
mImpl->frameBufferContainer.Erase( &iter ); // frameBuffer found; now destroy it
break;
}
}
}
-void UpdateManager::AttachColorTextureToFrameBuffer( SceneGraph::FrameBuffer* frameBuffer, SceneGraph::Texture* texture, unsigned int mipmapLevel, unsigned int layer )
-{
- //frameBuffer->AttachColorTexture( mImpl->context, texture, mipmapLevel, layer ); @todo Rewrite for Gfx
- DALI_ASSERT_ALWAYS( true && "GRAPHICS: FIXME" );
-}
-
-Graphics::API::Controller& UpdateManager::GetGraphicsController() const
-{
- return mImpl->graphics.GetController();
-}
} // namespace SceneGraph
class Animation;
class DiscardQueue;
-class RenderManager;
class RenderTaskList;
class RenderTaskProcessor;
-class RenderQueue;
-class PropertyBuffer;
/**
bool FlushQueue();
/**
- * Add a new sampler to RenderManager
+ * Add a new sampler to Update Manager
* @param[in] sampler The sampler to add
- * @post Sends a message to RenderManager to add the sampler.
- * The sampler will be owned by RenderManager
+ * The sampler will be owned by UpdateManager
*/
void AddSampler( OwnerPointer< SceneGraph::Sampler >& sampler );
/**
- * Removes an existing sampler from RenderManager
+ * Removes an existing sampler from UpdateManager
* @param[in] sampler The sampler to remove
- * @post The sampler will be destroyed in the render thread
*/
void RemoveSampler( SceneGraph::Sampler* sampler );
/**
- * Add a new property buffer to RenderManager
+ * Add a new property buffer to UpdateManager
* @param[in] propertryBuffer The property buffer to add
- * @post Sends a message to RenderManager to add the property buffer.
- * The property buffer will be owned by RenderManager
+ * The property buffer will be owned by UpdateManager
*/
void AddPropertyBuffer( OwnerPointer< SceneGraph::PropertyBuffer >& propertyBuffer );
/**
- * Removes an existing PropertyBuffer from RenderManager
+ * Removes an existing PropertyBuffer from UpdateManager
* @param[in] propertryBuffer The property buffer to remove
- * @post The property buffer will be destroyed in the render thread
*/
void RemovePropertyBuffer( SceneGraph::PropertyBuffer* propertryBuffer );
/**
- * Sets the format of an existing property buffer
- * @param[in] propertyBuffer The property buffer.
- * @param[in] format The new format of the buffer
- * @post Sends a message to RenderManager to set the new format to the property buffer.
- */
- void SetPropertyBufferFormat( SceneGraph::PropertyBuffer* propertyBuffer, OwnerPointer< SceneGraph::PropertyBuffer::Format>& format );
-
- /**
- * Sets the data of an existing property buffer
- * @param[in] propertyBuffer The property buffer.
- * @param[in] data The new data of the buffer
- * @param[in] size The new size of the buffer
- * @post Sends a message to RenderManager to set the new data to the property buffer.
- */
- void SetPropertyBufferData( SceneGraph::PropertyBuffer* propertyBuffer, OwnerPointer< Vector<char> >& data, size_t size );
-
- /**
- * Adds a geometry to the RenderManager
+ * Adds a geometry to the UpdateManager
* @param[in] geometry The geometry to add
- * @post Sends a message to RenderManager to add the Geometry
- * The geometry will be owned by RenderManager
+ * The geometry will be owned by UpdateManager
*/
void AddGeometry( OwnerPointer< SceneGraph::Geometry >& geometry );
/**
- * Removes an existing Geometry from RenderManager
+ * Removes an existing Geometry from UpdateManager
* @param[in] geometry The geometry to remove
- * @post The geometry will be destroyed in the render thread
*/
void RemoveGeometry( SceneGraph::Geometry* geometry );
/**
- * Sets the geometry type of an existing Geometry
- * @param[in] geometry The geometry
- * @param[in] geometryType The type of the geometry
- */
- void SetGeometryType( SceneGraph::Geometry* geometry, unsigned int geometryType );
-
- /**
- * Sets the index buffer to be used by a geometry
- * @param[in] geometry The geometry
- * @param[in] indices A vector containing the indices for the geometry
- */
- void SetIndexBuffer( SceneGraph::Geometry* geometry, Dali::Vector<unsigned short>& indices );
-
- /**
- * Adds a vertex buffer to a geometry
- * @param[in] geometry The geometry
- * @param[in] propertyBuffer The property buffer
- */
- void AttachVertexBuffer( SceneGraph::Geometry* geometry, SceneGraph::PropertyBuffer* propertyBuffer );
-
- /**
- * Removes a vertex buffer from a geometry
- * @param[in] geometry The geometry
- * @param[in] propertyBuffer The property buffer
- */
- void RemoveVertexBuffer( SceneGraph::Geometry* geometry, SceneGraph::PropertyBuffer* propertyBuffer );
-
- /**
- * Adds a texture to the render manager
+ * Adds a texture to the update manager
* @param[in] texture The texture to add
- * The texture will be owned by RenderManager
+ * The texture will be owned by UpdateManager
*/
void AddTexture( OwnerPointer< SceneGraph::Texture >& texture );
/**
- * Removes a texture from the render manager
+ * Removes a texture from the update manager
* @param[in] texture The texture to remove
- * @post The texture will be destroyed in the render thread
*/
void RemoveTexture( SceneGraph::Texture* texture );
/**
- * Adds a framebuffer to the render manager
+ * Adds a framebuffer to the update manager
* @param[in] frameBuffer The framebuffer to add
- * The framebuffer will be owned by RenderManager
+ * The framebuffer will be owned by UpdateManager
*/
- void AddFrameBuffer( SceneGraph::FrameBuffer* frameBuffer );
+ void AddFrameBuffer( OwnerPointer<SceneGraph::FrameBuffer>& frameBuffer );
/**
- * Removes a FrameBuffer from the render manager
+ * Removes a FrameBuffer from the update manager
* @param[in] frameBuffer The FrameBuffer to remove
- * @post The FrameBuffer will be destroyed in the render thread
*/
void RemoveFrameBuffer( SceneGraph::FrameBuffer* frameBuffer );
- /**
- * Attach a texture as color output to an existing FrameBuffer
- * @param[in] frameBuffer The FrameBuffer
- * @param[in] texture The texture that will be used as output when rendering
- * @param[in] mipmapLevel The mipmap of the texture to be attached
- * @param[in] layer Indicates which layer of a cube map or array texture to attach. Unused for 2D textures
- */
- void AttachColorTextureToFrameBuffer( SceneGraph::FrameBuffer* frameBuffer, SceneGraph::Texture* texture, unsigned int mipmapLevel, unsigned int face );
-
- Graphics::API::Controller& GetGraphicsController() const;
public:
new (slot) LocalType( &manager, &UpdateManager::PropertyNotificationSetNotify, propertyNotification, notifyMode );
}
-// The render thread can safely change the Shader
inline void AddShaderMessage( UpdateManager& manager, OwnerPointer< Shader >& shader )
{
typedef MessageValue1< UpdateManager, OwnerPointer< Shader > > LocalType;
new (slot) LocalType( &manager, &UpdateManager::AddShader, shader );
}
-// The render thread can safely change the Shader
inline void RemoveShaderMessage( UpdateManager& manager, Shader& shader )
{
typedef MessageValue1< UpdateManager, Shader* > LocalType;
new (slot) LocalType( &manager, &UpdateManager::AddTextureSet, textureSet );
}
-// The render thread can safely change the Shader
inline void RemoveTextureSetMessage( UpdateManager& manager, TextureSet& textureSet )
{
typedef MessageValue1< UpdateManager, TextureSet* > LocalType;
new (slot) LocalType( &manager, &UpdateManager::RemovePropertyBuffer, &propertyBuffer );
}
-inline void AddGeometry( UpdateManager& manager, OwnerPointer< SceneGraph::Geometry >& geometry )
+inline void AddGeometryMessage( UpdateManager& manager, OwnerPointer< SceneGraph::Geometry >& geometry )
{
// Message has ownership of Geometry while in transit from event -> update
typedef MessageValue1< UpdateManager, OwnerPointer< SceneGraph::Geometry > > LocalType;
new (slot) LocalType( &manager, &UpdateManager::AddGeometry, geometry );
}
-inline void RemoveGeometry( UpdateManager& manager, SceneGraph::Geometry& geometry )
+inline void RemoveGeometryMessage( UpdateManager& manager, SceneGraph::Geometry& geometry )
{
typedef MessageValue1< UpdateManager, SceneGraph::Geometry* > LocalType;
new (slot) LocalType( &manager, &UpdateManager::RemoveTexture, &texture );
}
-
-inline void AddFrameBuffer( UpdateManager& manager, SceneGraph::FrameBuffer& frameBuffer )
+inline void AddFrameBufferMessage( UpdateManager& manager, OwnerPointer<SceneGraph::FrameBuffer>& frameBuffer )
{
- typedef MessageValue1< UpdateManager, SceneGraph::FrameBuffer* > LocalType;
+ typedef MessageValue1< UpdateManager, OwnerPointer<SceneGraph::FrameBuffer> > LocalType;
// Reserve some memory inside the message queue
unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &manager, &UpdateManager::AddFrameBuffer, &frameBuffer );
+ new (slot) LocalType( &manager, &UpdateManager::AddFrameBuffer, frameBuffer );
}
-inline void RemoveFrameBuffer( UpdateManager& manager, SceneGraph::FrameBuffer& frameBuffer )
+inline void RemoveFrameBufferMessage( UpdateManager& manager, SceneGraph::FrameBuffer& frameBuffer )
{
typedef MessageValue1< UpdateManager, SceneGraph::FrameBuffer* > LocalType;
new (slot) LocalType( &manager, &UpdateManager::RemoveFrameBuffer, &frameBuffer );
}
-inline void AttachColorTextureToFrameBuffer( UpdateManager& manager, SceneGraph::FrameBuffer& frameBuffer, SceneGraph::Texture* texture, unsigned int mipmapLevel, unsigned int layer )
-{
- typedef MessageValue4< UpdateManager, SceneGraph::FrameBuffer*, SceneGraph::Texture*, unsigned int, unsigned int > LocalType;
-
- // Reserve some memory inside the message queue
- unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &manager, &UpdateManager::AttachColorTextureToFrameBuffer, &frameBuffer, texture, mipmapLevel, layer );
-}
-
inline void SetDepthIndicesMessage( UpdateManager& manager, OwnerPointer< NodeDepths >& nodeDepths )
{
typedef MessageValue1< UpdateManager, OwnerPointer< NodeDepths > > LocalType;
{
FrameBuffer::FrameBuffer( unsigned int width, unsigned int height, unsigned int attachments )
-: mWidth( width ),
- mHeight( height )
+: mGraphics( nullptr ),
+ mWidth( width ),
+ mHeight( height )
{
}
{
}
+void FrameBuffer::Initialize( Integration::Graphics::Graphics& graphics )
+{
+ mGraphics = &graphics;
+}
+
void FrameBuffer::AttachColorTexture( SceneGraph::Texture* texture, unsigned int mipmapLevel, unsigned int layer )
{
}
~FrameBuffer();
/**
+ * Initialize the frame buffer object with the Graphics API when added to UpdateManager
+ *
+ * @param[in] graphics The Graphics API
+ */
+ void Initialize( Integration::Graphics::Graphics& graphics );
+
+ /**
* @brief Attach a texture for color rendering. Valid only for Framebuffers with COLOR attachments.
* param[in] context The GL context
* @param[in] texture The texture that will be used as output when rendering
unsigned int GetHeight() const;
private:
+ Integration::Graphics::Graphics* mGraphics; ///< Graphics interface object
unsigned int mWidth;
unsigned int mHeight;
};
+inline void AttachColorTextureMessage( EventThreadServices& eventThreadServices,
+ SceneGraph::FrameBuffer& frameBuffer,
+ SceneGraph::Texture* texture,
+ unsigned int mipmapLevel,
+ unsigned int layer )
+{
+ typedef MessageValue3< SceneGraph::FrameBuffer, SceneGraph::Texture*, unsigned int, unsigned int > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ), false );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &frameBuffer, &FrameBuffer::AttachColorTexture, texture, mipmapLevel, layer );
+}
} // namespace SceneGraph
{
Geometry::Geometry()
-: mIndices(),
+: mGraphics( nullptr ),
+ mIndices(),
mGeometryType( Dali::Geometry::TRIANGLES ),
mIndicesChanged(false),
mHasBeenUpdated(false),
}
}
-// Flags for re-sending data to renderer.
-enum Flags
-{
- RESEND_DATA_PROVIDER = 1 << 0,
- RESEND_GEOMETRY = 1 << 1,
- RESEND_FACE_CULLING_MODE = 1 << 2,
- RESEND_BLEND_COLOR = 1 << 3,
- RESEND_BLEND_BIT_MASK = 1 << 4,
- RESEND_PREMULTIPLIED_ALPHA = 1 << 5,
- RESEND_INDEXED_DRAW_FIRST_ELEMENT = 1 << 6,
- RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 7,
- RESEND_DEPTH_WRITE_MODE = 1 << 8,
- RESEND_DEPTH_TEST_MODE = 1 << 9,
- RESEND_DEPTH_FUNCTION = 1 << 10,
- RESEND_RENDER_MODE = 1 << 11,
- RESEND_STENCIL_FUNCTION = 1 << 12,
- RESEND_STENCIL_FUNCTION_MASK = 1 << 13,
- RESEND_STENCIL_FUNCTION_REFERENCE = 1 << 14,
- RESEND_STENCIL_MASK = 1 << 15,
- RESEND_STENCIL_OPERATION_ON_FAIL = 1 << 16,
- RESEND_STENCIL_OPERATION_ON_Z_FAIL = 1 << 17,
- RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 18,
- RESEND_WRITE_TO_COLOR_BUFFER = 1 << 19,
-};
-
} // Anonymous namespace
namespace Dali
}
Renderer::Renderer()
-: mRenderDataProvider(),
+: mGraphics( nullptr ),
+ mRenderDataProvider(),
mTextureSet( NULL ),
mGeometry( NULL ),
mShader( NULL ),
mIndexedDrawElementsCount( 0u ),
mBlendBitmask( 0u ),
mRegenerateUniformMap( 0u ),
- mResendFlag( 0u ),
mDepthFunction( DepthFunction::LESS ),
mFaceCullingMode( FaceCullingMode::NONE ),
mBlendMode( BlendMode::AUTO ),
gRendererMemoryPool.FreeThreadSafe( static_cast<Renderer*>( ptr ) );
}
+void Renderer::Initialize( Integration::Graphics::Graphics& graphics )
+{
+ mGraphics = &graphics;
+
+ mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
+
+ mRenderDataProvider = std::make_unique< RenderDataProvider >();
+
+ mRenderDataProvider->mUniformMapDataProvider = this;
+ mRenderDataProvider->mShader = mShader;
+
+ if( mTextureSet )
+ {
+ size_t textureCount = mTextureSet->GetTextureCount();
+ mRenderDataProvider->mTextures.resize( textureCount );
+ mRenderDataProvider->mSamplers.resize( textureCount );
+ for( unsigned int i(0); i<textureCount; ++i )
+ {
+ mRenderDataProvider->mTextures[i] = mTextureSet->GetTexture(i);
+ mRenderDataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i);
+ }
+ }
+}
+
void* AllocateUniformBufferMemory( size_t size )
{
}
+void Renderer::UpdateUniformMap( BufferIndex updateBufferIndex )
+{
+
+ if( mRegenerateUniformMap > UNIFORM_MAP_READY )
+ {
+ if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
+ {
+ CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
+ localMap.Resize(0);
+
+ const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
+ AddMappings( localMap, rendererUniformMap );
+
+ if( mShader )
+ {
+ AddMappings( localMap, mShader->GetUniformMap() );
+ }
+ }
+ else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
+ {
+ // Copy old map into current map
+ CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
+ CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
+
+ localMap.Resize( oldMap.Count() );
+
+ unsigned int index=0;
+ for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
+ {
+ localMap[index] = *iter;
+ }
+ }
+
+ mUniformMapChanged[updateBufferIndex] = true;
+ mRegenerateUniformMap--;
+ }
+}
-void Renderer::PrepareRender( Graphics::API::Controller& controller, BufferIndex updateBufferIndex )
+void Renderer::PrepareRender( BufferIndex updateBufferIndex )
{
+ auto& controller = mGraphics->GetController();
+
// prepare all stuff
auto gfxShader = mShader->GetGfxObject();
}
}
- /**
- * REGENERATE UNIFORM MAP
- */
- if( mRegenerateUniformMap > UNIFORM_MAP_READY )
- {
- if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
- {
- CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
- localMap.Resize(0);
-
- const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
- AddMappings( localMap, rendererUniformMap );
-
- if( mShader )
- {
- AddMappings( localMap, mShader->GetUniformMap() );
- }
- }
- else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
- {
- // Copy old map into current map
- CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
- CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
-
- localMap.Resize( oldMap.Count() );
-
- unsigned int index = 0;
- for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
- {
- localMap[index] = *iter;
- }
- }
-
- mUniformMapChanged[updateBufferIndex] = true;
- mRegenerateUniformMap--;
- }
+ UpdateUniformMap( updateBufferIndex );
auto& shader = mShader->GetGfxObject().Get();
auto uboCount = shader.GetUniformBlockCount();
auto pushConstantsBindings = Graphics::API::RenderCommand::NewPushConstantsBindings( uboCount );
// allocate new command ( may be not necessary at all )
- // mGfxRenderCommand = Graphics::API::RenderCommandBuilder().Build();
+ // mGfxRenderCommand = Graphics::API::RenderCommandBuilder().Build();
// see if we need to reallocate memory for each UBO
// todo: do it only when shader has changed
}
}
-void Renderer::PrepareRender( BufferIndex updateBufferIndex )
-{
-
- if( mRegenerateUniformMap > UNIFORM_MAP_READY )
- {
- if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
- {
- CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
- localMap.Resize(0);
-
- const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
- AddMappings( localMap, rendererUniformMap );
-
- if( mShader )
- {
- AddMappings( localMap, mShader->GetUniformMap() );
- }
- }
- else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
- {
- // Copy old map into current map
- CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
- CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
-
- localMap.Resize( oldMap.Count() );
-
- unsigned int index=0;
- for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
- {
- localMap[index] = *iter;
- }
- }
-
- mUniformMapChanged[updateBufferIndex] = true;
- mRegenerateUniformMap--;
- }
-
- if( mResendFlag != 0 )
- {
- // This used to send messages to obsolete Render::Renderer at this point
- mResendFlag = 0;
- }
-}
void Renderer::SetTextures( TextureSet* textureSet )
{
mTextureSet = textureSet;
mTextureSet->AddObserver( this );
mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
- mResendFlag |= RESEND_DATA_PROVIDER;
}
void Renderer::SetShader( Shader* shader )
mShader = shader;
mShader->AddConnectionObserver( *this );
mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
- mResendFlag |= RESEND_DATA_PROVIDER;
}
void Renderer::SetGeometry( SceneGraph::Geometry* geometry )
void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode )
{
mFaceCullingMode = faceCullingMode;
- mResendFlag |= RESEND_FACE_CULLING_MODE;
}
void Renderer::SetBlendMode( BlendMode::Type blendingMode )
if( mBlendBitmask != options)
{
mBlendBitmask = options;
- mResendFlag |= RESEND_BLEND_BIT_MASK;
}
}
*mBlendColor = blendColor;
}
}
-
- mResendFlag |= RESEND_BLEND_COLOR;
}
void Renderer::SetIndexedDrawFirstElement( size_t firstElement )
{
mIndexedDrawFirstElement = firstElement;
- mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT;
}
void Renderer::SetIndexedDrawElementsCount( size_t elementsCount )
{
mIndexedDrawElementsCount = elementsCount;
- mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT;
}
void Renderer::EnablePreMultipliedAlpha( bool preMultipled )
{
mPremultipledAlphaEnabled = preMultipled;
- mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
}
void Renderer::SetDepthWriteMode( DepthWriteMode::Type depthWriteMode )
{
mDepthWriteMode = depthWriteMode;
- mResendFlag |= RESEND_DEPTH_WRITE_MODE;
}
void Renderer::SetDepthTestMode( DepthTestMode::Type depthTestMode )
{
mDepthTestMode = depthTestMode;
- mResendFlag |= RESEND_DEPTH_TEST_MODE;
}
void Renderer::SetDepthFunction( DepthFunction::Type depthFunction )
{
mDepthFunction = depthFunction;
- mResendFlag |= RESEND_DEPTH_FUNCTION;
}
void Renderer::SetRenderMode( RenderMode::Type mode )
{
mStencilParameters.renderMode = mode;
- mResendFlag |= RESEND_RENDER_MODE;
}
void Renderer::SetStencilFunction( StencilFunction::Type stencilFunction )
{
mStencilParameters.stencilFunction = stencilFunction;
- mResendFlag |= RESEND_STENCIL_FUNCTION;
}
void Renderer::SetStencilFunctionMask( int stencilFunctionMask )
{
mStencilParameters.stencilFunctionMask = stencilFunctionMask;
- mResendFlag |= RESEND_STENCIL_FUNCTION_MASK;
}
void Renderer::SetStencilFunctionReference( int stencilFunctionReference )
{
mStencilParameters.stencilFunctionReference = stencilFunctionReference;
- mResendFlag |= RESEND_STENCIL_FUNCTION_REFERENCE;
}
void Renderer::SetStencilMask( int stencilMask )
{
mStencilParameters.stencilMask = stencilMask;
- mResendFlag |= RESEND_STENCIL_MASK;
}
void Renderer::SetStencilOperationOnFail( StencilOperation::Type stencilOperationOnFail )
{
mStencilParameters.stencilOperationOnFail = stencilOperationOnFail;
- mResendFlag |= RESEND_STENCIL_OPERATION_ON_FAIL;
}
void Renderer::SetStencilOperationOnZFail( StencilOperation::Type stencilOperationOnZFail )
{
mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail;
- mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_FAIL;
}
void Renderer::SetStencilOperationOnZPass( StencilOperation::Type stencilOperationOnZPass )
{
mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass;
- mResendFlag |= RESEND_STENCIL_OPERATION_ON_Z_PASS;
-}
-
-//Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created )
-void Renderer::ConnectToSceneGraph( BufferIndex bufferIndex )
-{
- mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
-
- mRenderDataProvider = std::make_unique< RenderDataProvider >();
-
- mRenderDataProvider->mUniformMapDataProvider = this;
- mRenderDataProvider->mShader = mShader;
-
- if( mTextureSet )
- {
- size_t textureCount = mTextureSet->GetTextureCount();
- mRenderDataProvider->mTextures.resize( textureCount );
- mRenderDataProvider->mSamplers.resize( textureCount );
- for( unsigned int i(0); i<textureCount; ++i )
- {
- mRenderDataProvider->mTextures[i] = mTextureSet->GetTexture(i);
- mRenderDataProvider->mSamplers[i] = mTextureSet->GetTextureSampler(i);
- }
- }
-}
-
-//Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced )
-void Renderer::DisconnectFromSceneGraph( BufferIndex bufferIndex )
-{
}
const Vector4& Renderer::GetBlendColor() const
void Renderer::TextureSetChanged()
{
- mResendFlag |= RESEND_DATA_PROVIDER;
}
void Renderer::TextureSetDeleted()
{
mTextureSet = NULL;
-
- mResendFlag |= RESEND_DATA_PROVIDER;
}
+
void Renderer::ConnectionsChanged( PropertyOwner& object )
{
// One of our child objects has changed it's connections. Ensure the uniform
// map gets regenerated during PrepareRender
mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
-
- // Ensure the child object pointers get re-sent to the renderer
- mResendFlag |= RESEND_DATA_PROVIDER;
}
void Renderer::ConnectedUniformMapChanged()
void operator delete( void* ptr );
/**
+ * Initialize the renderer object with the Graphics API when added to UpdateManager
+ *
+ * @param[in] graphics The Graphics API
+ */
+ void Initialize( Integration::Graphics::Graphics& graphics );
+
+ /**
* Set the texture set for the renderer
* @param[in] textureSet The texture set this renderer will use
*/
*/
void TextureSetDeleted();
- /**
- * Connect the object to the scene graph
- *
- * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
- */
- void ConnectToSceneGraph( BufferIndex bufferIndex );
-
- /**
- * Disconnect the object from the scene graph
- * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
- */
- void DisconnectFromSceneGraph( BufferIndex bufferIndex );
-
public: // Implementation of ConnectionChangePropagator
/**
* @copydoc ConnectionChangePropagator::AddObserver
*/
const Vector4& GetBlendColor() const;
+ /**
+ * Helper function to update the uniform map.
+ */
+ void UpdateUniformMap( BufferIndex updateBufferIndex );
private:
+ Integration::Graphics::Graphics* mGraphics; ///< Graphics interface object
CollectedUniformMap mCollectedUniformMap[2]; ///< Uniform maps collected by the renderer
std::unique_ptr<RenderDataProvider> mRenderDataProvider; ///< Contains data for graphics renderer @todo Refactor
projects / platform / core / uifw / dali-core.git / commitdiff