*/
virtual Integration::StencilBufferAvailable GetStencilBufferRequired() = 0;
- /**
- * @brief Sets the background color of the surface.
- * @param[in] color The new background color
- */
- virtual void SetBackgroundColor(Vector4 color) = 0;
-
- /**
- * @brief Gets the background color of the surface.
- * @return The background color
- */
- virtual Vector4 GetBackgroundColor() = 0;
-
private:
/**
return GetImplementation(*this).GetDpi();
}
+void Scene::SetBackgroundColor( const Vector4& color )
+{
+ GetImplementation(*this).SetBackgroundColor( color );
+}
+
+Vector4 Scene::GetBackgroundColor() const
+{
+ return GetImplementation(*this).GetBackgroundColor();
+}
+
RenderTaskList Scene::GetRenderTaskList() const
{
return RenderTaskList( &GetImplementation(*this).GetRenderTaskList() );
// INTERNAL INCLUDES
#include <dali/public-api/object/handle.h>
#include <dali/public-api/math/vector2.h>
+#include <dali/public-api/math/vector4.h>
namespace Dali
{
Vector2 GetDpi() const;
/**
+ * @brief Sets the background color.
+ *
+ * @param[in] color The new background color
+ */
+ void SetBackgroundColor( const Vector4& color );
+
+ /**
+ * @brief Gets the background color of the render surface.
+ *
+ * @return The background color
+ */
+ Vector4 GetBackgroundColor() const;
+
+ /**
* @brief Retrieves the list of render-tasks.
*
* @return A valid handle to a RenderTaskList
{
if( (*iter)->GetSurface() == surface )
{
- (*iter)->SetSurface( *surface );
+ (*iter)->SurfaceResized();
}
}
}
mSize( size ),
mSurfaceSize( Vector2::ZERO ),
mDpi( Vector2::ZERO ),
+ mBackgroundColor( DEFAULT_BACKGROUND_COLOR ),
mDepthTreeDirty( false ),
mEventProcessor( *this, ThreadLocalStorage::GetInternal()->GetGestureEventProcessor() )
{
mSurface = &surface;
if ( mSurface )
{
- mSurfaceSize.width = static_cast<float>( mSurface->GetPositionSize().width );
- mSurfaceSize.height = static_cast<float>( mSurface->GetPositionSize().height );
+ RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u );
- mSize.width = mSurfaceSize.width;
- mSize.height = mSurfaceSize.height;
+ mFrameBuffer = Dali::Internal::FrameBuffer::New( surface, Dali::FrameBuffer::Attachment::NONE );
+ defaultRenderTask->SetFrameBuffer( mFrameBuffer );
- // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
- mDefaultCamera->SetPerspectiveProjection( mSurfaceSize );
+ SurfaceResized();
+ }
+}
- mRootLayer->SetSize( mSize.width, mSize.height );
+void Scene::SurfaceResized()
+{
+ if( mSurface )
+ {
+ const float fWidth = static_cast<float>( mSurface->GetPositionSize().width );
+ const float fHeight = static_cast<float>( mSurface->GetPositionSize().height );
- ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
- SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager();
- SetDefaultSurfaceRectMessage( updateManager, Rect<int32_t>( 0, 0, static_cast<int32_t>( mSurfaceSize.width ), static_cast<int32_t>( mSurfaceSize.height ) ) ); // truncated
+ if( ( fabsf( mSurfaceSize.width - fWidth ) > Math::MACHINE_EPSILON_1 ) || ( fabsf( mSurfaceSize.height - fHeight ) > Math::MACHINE_EPSILON_1 ) )
+ {
+ Rect<int32_t> newSize( 0, 0, static_cast<int32_t>( mSurface->GetPositionSize().width ), static_cast<int32_t>( mSurface->GetPositionSize().height ) );
- RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u );
+ mSurfaceSize.width = fWidth;
+ mSurfaceSize.height = fHeight;
- // if single render task to screen then set its viewport parameters
- if( 1 == mRenderTaskList->GetTaskCount() )
- {
- if( !defaultRenderTask->GetTargetFrameBuffer() )
+ mSize.width = mSurfaceSize.width;
+ mSize.height = mSurfaceSize.height;
+
+ // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
+ mDefaultCamera->SetPerspectiveProjection( mSurfaceSize );
+
+ mRootLayer->SetSize( mSize.width, mSize.height );
+
+ ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
+ SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager();
+ SetDefaultSurfaceRectMessage( updateManager, newSize ); // truncated
+
+ RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u );
+
+ // if single render task to screen then set its viewport parameters
+ if( 1 == mRenderTaskList->GetTaskCount() )
{
- defaultRenderTask->SetViewport( Viewport( 0, 0, static_cast<int32_t>( mSurfaceSize.width ), static_cast<int32_t>( mSurfaceSize.height ) ) ); // truncated
+ if( !defaultRenderTask->GetTargetFrameBuffer() )
+ {
+ defaultRenderTask->SetViewport( newSize ); // truncated
+ }
}
- }
- mFrameBuffer = Dali::Internal::FrameBuffer::New( surface, Dali::FrameBuffer::Attachment::NONE );
- defaultRenderTask->SetFrameBuffer( mFrameBuffer );
+ defaultRenderTask->GetFrameBuffer()->SetSize( static_cast<uint32_t>( newSize.width ), static_cast<uint32_t>( newSize.height ) );
+ }
}
}
}
}
-void Scene::SetBackgroundColor(Vector4 color)
+void Scene::SetBackgroundColor( const Vector4& color )
{
+ mBackgroundColor = color;
+
if( mSurface )
{
- mSurface->SetBackgroundColor( color );
+ mRenderTaskList->GetTask( 0u )->GetFrameBuffer()->SetBackgroundColor( color );
}
}
Vector4 Scene::GetBackgroundColor() const
{
- return mSurface ? mSurface->GetBackgroundColor() : DEFAULT_BACKGROUND_COLOR;
+ return mBackgroundColor;
}
void Scene::EmitKeyEventSignal(const KeyEvent& event)
void SetSurface( Integration::RenderSurface& surface );
/**
+ * Notify the surface has been resized.
+ */
+ void SurfaceResized();
+
+ /**
* Retrieve the render surface the scene is binded to.
* @return The render surface.
*/
void RebuildDepthTree();
/**
- * @brief Sets the background color of the render surface.
+ * @brief Sets the background color of the render surface.
* @param[in] color The new background color
*/
- void SetBackgroundColor(Vector4 color);
+ void SetBackgroundColor( const Vector4& color );
/**
* @brief Gets the background color of the render surface.
Vector2 mDpi;
+ Vector4 mBackgroundColor;
+
LayerPtr mRootLayer;
// Ordered list of currently on-stage layers
return mIsSurfaceBacked ? nullptr : mColor.Get();
}
+void FrameBuffer::SetSize( uint32_t width, uint32_t height )
+{
+ mWidth = width;
+ mHeight = height;
+
+ if( mRenderObject->IsSurfaceBacked() )
+ {
+ SetFrameBufferSizeMessage( mEventThreadServices.GetUpdateManager(), static_cast<Render::SurfaceFrameBuffer*>( mRenderObject ), width, height );
+ }
+}
+
+void FrameBuffer::SetBackgroundColor( const Vector4& color )
+{
+ if( mRenderObject->IsSurfaceBacked() )
+ {
+ SetFrameBufferBackgroundColorMessage( mEventThreadServices.GetUpdateManager(), static_cast<Render::SurfaceFrameBuffer*>( mRenderObject ), color );
+ }
+}
+
FrameBuffer::~FrameBuffer()
{
if( EventThreadServices::IsCoreRunning() && mRenderObject )
/**
* @brief Create a new FrameBuffer
*
- * @param[in] renderSurface The render surface
- * @param[in] attachments The attachments comprising the format of the FrameBuffer (bit-mask)
+ * @param[in] renderSurface The render surface
+ * @param[in] attachments The attachments comprising the format of the FrameBuffer (bit-mask)
* @return A smart-pointer to the newly allocated Texture.
*/
static FrameBufferPtr New( Dali::Integration::RenderSurface& renderSurface, Mask attachments );
*/
Texture* GetColorTexture();
+ /**
+ * @brief Sets the frame buffer size.
+ * @param[in] width The width size
+ * @param[in] height The height size
+ */
+ void SetSize( uint32_t width, uint32_t height );
+
+ /**
+ * @brief Sets the background color
+ * @param[in] color The new background color
+ */
+ void SetBackgroundColor( const Vector4& color );
+
private: // implementation
/**
SurfaceFrameBuffer::SurfaceFrameBuffer( Integration::RenderSurface* surface )
: FrameBuffer(),
mSurface( surface ),
- mContext( nullptr )
+ mContext( nullptr ),
+ mWidth( mSurface->GetPositionSize().width ),
+ mHeight( mSurface->GetPositionSize().height ),
+ mBackgroundColor( 0.f, 0.f, 0.f, 1.f ),
+ mSizeChanged( false )
{
}
void SurfaceFrameBuffer::Bind( Context& context )
{
- mSurface->PreRender( false );
+ mSurface->PreRender( mSizeChanged );
+
context.BindFramebuffer( GL_FRAMEBUFFER, 0u );
}
uint32_t SurfaceFrameBuffer::GetWidth() const
{
- return mSurface->GetPositionSize().width;
+ return mWidth;
}
uint32_t SurfaceFrameBuffer::GetHeight() const
{
- return mSurface->GetPositionSize().height;
+ return mHeight;
}
void SurfaceFrameBuffer::PostRender()
{
- mSurface->PostRender( false, false, false );
+ mSurface->PostRender( false, false, mSizeChanged );
+
+ mSizeChanged = false;
}
Context* SurfaceFrameBuffer::GetContext()
Vector4 SurfaceFrameBuffer::GetBackgroundColor()
{
- return mSurface->GetBackgroundColor();
+ return mBackgroundColor;
+}
+
+void SurfaceFrameBuffer::SetSize( uint32_t width, uint32_t height )
+{
+ mWidth = width;
+ mHeight = height;
+ mSizeChanged = true;
+}
+
+void SurfaceFrameBuffer::SetBackgroundColor( const Vector4& color )
+{
+ mBackgroundColor = color;
}
} //Render
*/
// INTERNAL INCLUDES
+#include <dali/internal/update/manager/update-manager.h>
#include <dali/internal/render/renderers/render-frame-buffer.h>
#include <dali/integration-api/render-surface.h>
*/
bool IsSurfaceBacked() override { return true; };
+ /**
+ * @brief Sets the frame buffer size.
+ * @param[in] width The width size
+ * @param[in] height The height size
+ */
+ void SetSize( uint32_t width, uint32_t height );
+
+ /**
+ * @brief Sets the background color.
+ * @param[in] color The new background color
+ */
+ void SetBackgroundColor( const Vector4& color );
+
public:
/**
Integration::RenderSurface* mSurface; ///< The render surface
Context* mContext; ///< The context holding the GL state of rendering for the surface backed frame buffer
+
+ uint32_t mWidth;
+ uint32_t mHeight;
+ Vector4 mBackgroundColor;
+ bool mSizeChanged;
};
+// Messages for FrameBuffer
+inline void SetFrameBufferSizeMessage( SceneGraph::UpdateManager& updateManager, SurfaceFrameBuffer* surfaceFrameBuffer, uint32_t width, uint32_t height )
+{
+ typedef MessageValue2< SurfaceFrameBuffer, uint32_t, uint32_t > LocalType;
+
+ // Reserve some memory inside the message queue
+ uint32_t* slot = updateManager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( surfaceFrameBuffer, &SurfaceFrameBuffer::SetSize, width, height );
+}
+
+inline void SetFrameBufferBackgroundColorMessage( SceneGraph::UpdateManager& updateManager, SurfaceFrameBuffer* surfaceFrameBuffer, const Vector4& color )
+{
+ typedef MessageValue1< SurfaceFrameBuffer, Vector4 > LocalType;
+
+ // Reserve some memory inside the message queue
+ uint32_t* slot = updateManager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( surfaceFrameBuffer, &SurfaceFrameBuffer::SetBackgroundColor, color );
+}
} // namespace Render