/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
END_TEST;
}
+
+int utcDaliEnsureRenderWhenRemovingLastRenderableActor(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ tet_infoline( "Ensure we clear the screen when the last actor is removed" );
+
+ Actor actor = CreateRenderableActor();
+ actor.SetSize( 100.0f, 100.0f );
+ stage.Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ auto& glAbstraction = application.GetGlAbstraction();
+ const auto clearCountBefore = glAbstraction.GetClearCountCalled();
+
+ actor.Unparent();
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int utcDaliEnsureRenderWhenMakingLastActorInvisible(void)
+{
+ TestApplication application;
+ auto stage = Stage::GetCurrent();
+
+ tet_infoline( "Ensure we clear the screen when the last actor is removed" );
+
+ Actor actor = CreateRenderableActor();
+ actor.SetSize( 100.0f, 100.0f );
+ stage.Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ auto& glAbstraction = application.GetGlAbstraction();
+ const auto clearCountBefore = glAbstraction.GetClearCountCalled();
+
+ actor.SetVisible( false );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
+
+ END_TEST;
+}
struct TouchedSignalData
{
TouchedSignalData()
- : functorCalled(false)
+ : functorCalled(false),
+ createNewScene(false),
+ newSceneCreated(false)
{}
void Reset()
{
functorCalled = false;
+ createNewScene = false;
+ newSceneCreated = false;
receivedTouchEvent.points.clear();
receivedTouchEvent.time = 0;
}
bool functorCalled;
+ bool createNewScene;
+ bool newSceneCreated;
TouchEvent receivedTouchEvent;
TouchData receivedTouchData;
};
{
signalData.functorCalled = true;
signalData.receivedTouchData = touch;
+
+ if ( signalData.createNewScene )
+ {
+ Dali::Integration::Scene scene = Dali::Integration::Scene::New( Vector2( 480.0f, 800.0f ) );
+ DALI_TEST_CHECK( scene );
+
+ signalData.newSceneCreated = true;
+ }
}
void operator()()
END_TEST;
}
+int UtcDaliSceneCreateNewSceneDuringCoreEventProcessing(void)
+{
+ TestApplication application;
+
+ Dali::Integration::Scene scene = application.GetScene();
+
+ TouchedSignalData data;
+ data.createNewScene = true;
+ TouchFunctor functor( data );
+ scene.TouchSignal().Connect( &application, functor );
+
+ // Render and notify.
+ application.SendNotification();
+ application.Render();
+
+ GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+
+ DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS( true, data.createNewScene, TEST_LOCATION );
+ DALI_TEST_EQUALS( true, data.newSceneCreated, TEST_LOCATION );
+ data.Reset();
+
+ END_TEST;
+}
+
int UtcDaliSceneEventProcessingFinishedP(void)
{
TestApplication application;
namespace Integration
{
class Core;
-class GestureManager;
class GlAbstraction;
class GlSyncAbstraction;
class PlatformAbstraction;
*
* 6) Provide an implementation of the GlAbstraction interface, used to access OpenGL services.
*
- * 7) Provide an implementation of the GestureManager interface, used to register gestures provided by the platform.
- *
* Multi-threading notes:
*
* The Dali API methods are not reentrant. If you access the API from multiple threads simultaneously, then the results
* @param[in] platformAbstraction The interface providing platform specific services.
* @param[in] glAbstraction The interface providing OpenGL services.
* @param[in] glSyncAbstraction The interface providing OpenGL sync objects.
- * @param[in] gestureManager The interface providing gesture manager services.
* @param[in] policy The data retention policy. This depends on application setting
* and platform support. Dali should honour this policy when deciding to discard
* intermediate resource data.
+++ /dev/null
-#ifndef DALI_INTEGRATION_GESTURE_MANAGER_H
-#define DALI_INTEGRATION_GESTURE_MANAGER_H
-
-/*
- * Copyright (c) 2019 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// INTERNAL INCLUDES
-#include <dali/public-api/events/gesture.h>
-#include <dali/integration-api/events/gesture-requests.h>
-
-namespace Dali
-{
-
-namespace Integration
-{
-
-/**
- * GestureManager is an abstract interface, used by Dali to register and unregister gestures provided
- * by the adaptor. A concrete implementation must be created for each adaptor, and provided when creating
- * the Dali::Integration::Core object.
- */
-class DALI_CORE_API GestureManager
-{
-public:
-
- /**
- * Called by Dali to enable the adaptor to start detecting the required gesture type.
- * @param[in] request The required gesture and details.
- */
- virtual void Register(const GestureRequest& request) = 0;
-
- /**
- * Called by Dali to inform the adaptor that it no longer requires a GestureEvent when the state
- * gesture type is detected.
- * @param[in] request The gesture that is no longer required.
- */
- virtual void Unregister(const GestureRequest& request) = 0;
-
- /**
- * Called by Dali to inform the adaptor that the detection parameters of a previously requested
- * gesture have now changed.
- * @param[in] request The gesture and updated details.
- */
- virtual void Update(const GestureRequest& request) = 0;
-
-protected:
-
- /**
- * Virtual destructor, no deletion through this interface
- */
- virtual ~GestureManager() {}
-
-}; // class GestureManager
-
-} // namespace Integration
-
-} // namespace Dali
-
-#endif // DALI_INTEGRATION_GESTURE_MANAGER_H
*/
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();
}
}
}
// Signal that any messages received will be flushed soon
mUpdateManager->EventProcessingStarted();
+ // Scene could be added or removed while processing the events
+ // Copy the Scene container locally to avoid possibly invalid iterator
+ SceneContainer scenes = mScenes;
+
// process events in all scenes
- for( auto iter = mScenes.begin(); iter != mScenes.end(); ++iter )
+ for( auto scene : scenes )
{
- (*iter)->ProcessEvents();
+ scene->ProcessEvents();
}
mNotificationManager->ProcessMessages();
// Emit signal here to inform listeners that event processing has finished.
- for( auto iter = mScenes.begin(); iter != mScenes.end(); ++iter )
+ for( auto scene : scenes )
{
- (*iter)->EmitEventProcessingFinishedSignal();
+ scene->EmitEventProcessingFinishedSignal();
}
// Run any registered processors
mRelayoutController->Relayout();
// Rebuild depth tree after event processing has finished
- for( auto iter = mScenes.begin(); iter != mScenes.end(); ++iter )
+ for( auto scene : scenes )
{
- (*iter)->RebuildDepthTree();
+ scene->RebuildDepthTree();
}
// Flush any queued messages for the update-thread
OwnerPointer<GestureEventProcessor> mGestureEventProcessor; ///< The gesture event processor
Dali::Vector<Integration::Processor*> mProcessors; ///< Registered processors (not owned)
- std::vector<ScenePtr> mScenes; ///< A container of scenes that bound to a surface for rendering, owned by Core
+ using SceneContainer = std::vector<ScenePtr>;
+ SceneContainer mScenes; ///< A container of scenes that bound to a surface for rendering, owned by Core
// The object registry
ObjectRegistryPtr mObjectRegistry;
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();
+
+ /**
* @copydoc Dali::Integration::Scene::Discard
*/
void Discard();
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
/**
* Create a gesture event processor.
* @param[in] updateManager The update manager
- * @param[in] gestureManager The gesture manager
* @param[in] renderController The render controller
*/
GestureEventProcessor( SceneGraph::UpdateManager& updateManager, Integration::RenderController& renderController );
/**
* Create a pan gesture processor.
- * @param[in] gestureManager The gesture manager
* @param[in] updateManager The Update Manager
*/
PanGestureProcessor( SceneGraph::UpdateManager& updateManager );
/**
* Create a pinch gesture processor.
- * @param[in] gestureManager The gesture manager
*/
PinchGestureProcessor();
/**
* Create a tap gesture processor.
- * @param[in] gestureManager The gesture manager.
*/
TapGestureProcessor();
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
/**
namespace SceneGraph
{
+#if defined(DEBUG_ENABLED)
+namespace
+{
+Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RENDER_MANAGER" );
+} // unnamed namespace
+#endif
+
/**
* Structure to contain internal data
*/
const uint32_t count = mImpl->instructions.Count( mImpl->renderBufferIndex );
const bool haveInstructions = count > 0u;
+ DALI_LOG_INFO( gLogFilter, Debug::General,
+ "Render: haveInstructions(%s) || mImpl->lastFrameWasRendered(%s) || forceClear(%s)\n",
+ haveInstructions ? "true" : "false",
+ mImpl->lastFrameWasRendered ? "true" : "false",
+ forceClear ? "true" : "false" );
+
// Only render if we have instructions to render, or the last frame was rendered (and therefore a clear is required).
if( haveInstructions || mImpl->lastFrameWasRendered || forceClear )
{
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Render: Processing\n" );
+
// Mark that we will require a post-render step to be performed (includes swap-buffers).
status.SetNeedsPostRender( true );
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
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
#if defined(DEBUG_ENABLED)
extern Debug::Filter* gRenderTaskLogFilter;
+namespace
+{
+Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_UPDATE_MANAGER" );
+} // unnamed namespace
#endif
// Nodes must be sorted by pointer
Node* rawNode = node.Release();
+ DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] AddNode\n", rawNode );
+
Vector<Node*>::Iterator begin = mImpl->nodes.Begin();
for( Vector<Node*>::Iterator iter = mImpl->nodes.End()-1; iter >= begin; --iter )
{
DALI_ASSERT_ALWAYS( NULL != node );
DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
+ DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] ConnectNode\n", node );
+
parent->ConnectChild( node );
// Inform the frame-callback-processor, if set, about the node-hierarchy changing
void UpdateManager::DisconnectNode( Node* node )
{
+ DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DisconnectNode\n", node );
+
Node* parent = node->GetParent();
DALI_ASSERT_ALWAYS( NULL != parent );
parent->SetDirtyFlag( NodePropertyFlags::CHILD_DELETED ); // make parent dirty so that render items dont get reused
DALI_ASSERT_ALWAYS( NULL != node );
DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should have been disconnected
+ DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DestroyNode\n", node );
+
Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
Vector<Node*>::Iterator endIter = mImpl->nodes.End();
for(;iter!=endIter;++iter)
void UpdateManager::AddRenderer( OwnerPointer< Renderer >& renderer )
{
+ DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] AddRenderer\n", renderer.Get() );
+
renderer->ConnectToSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
mImpl->renderers.PushBack( renderer.Release() );
mImpl->renderersAdded = true;
void UpdateManager::RemoveRenderer( Renderer* renderer )
{
+ DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] RemoveRenderer\n", renderer );
+
// Find the renderer and destroy it
EraseUsingDiscardQueue( mImpl->renderers, renderer, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
// Need to remove the render object as well
isRenderingToFbo );
}
}
+
+ DALI_LOG_INFO( gLogFilter, Debug::General,
+ "Update: numberOfRenderTasks(%d), taskListCount(%d), Render Instructions(%d)\n",
+ numberOfRenderTasks, taskListCount, mImpl->renderInstructions.Count( bufferIndex ) );
+
+
+
+ // If any node is dirty, i.e. a property has changed or a child has been deleted, and we do not have any instructions to send, then generate a dummy instruction to force another render
+ if( ( mImpl->nodeDirtyFlags != NodePropertyFlags::NOTHING ) && ( mImpl->renderInstructions.Count( bufferIndex ) == 0 ) )
+ {
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Node flags dirty, creating dummy instruction\n" );
+ mImpl->renderInstructions.GetNextInstruction( bufferIndex ); // This creates and adds an empty instruction. We do not need to modify it.
+ }
}
}
const uint32_t CORE_MAJOR_VERSION = 1;
const uint32_t CORE_MINOR_VERSION = 4;
-const uint32_t CORE_MICRO_VERSION = 25;
+const uint32_t CORE_MICRO_VERSION = 26;
const char * const CORE_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Array( const std::initializer_list< Value >& values );
/**
- * @brief Copy Constructor.
+ * @brief Copy constructor.
*
* @SINCE_1_0.0
* @param[in] other The Array to copy from
Array( const Array& other );
/**
- * @brief Move Constructor.
+ * @brief Move constructor.
*
+ * A move constructor enables the resources owned by an r-value object to be moved into an l-value without copying.
* @SINCE_1_4.17
* @param[in] other The Array to move from
- * @note The other array is an r-value so becomes invalid and is no longer usable.
+ * @note After the @a other array is used, it becomes invalid and is no longer usable.
*/
Array( Array&& other );
Value& operator[]( SizeType index );
/**
- * @brief Assignment Operator.
+ * @brief Assignment operator.
*
* @SINCE_1_0.0
* @param[in] other The array to copy from
Array& operator=( const Array& other );
/**
- * @brief Move Assignment Operator.
+ * @brief Move assignment operator.
*
* @SINCE_1_4.17
* @param[in] other The array to copy from
*
* @return The moved array.
*
- * @note The other array is an r-value so becomes invalid and is no longer usable.
+ * @note After the @a other array is used, it becomes invalid and is no longer usable.
*/
Array& operator=( Array&& other );
Map( const std::initializer_list< KeyValuePair >& values );
/**
- * @brief Copy Constructor.
+ * @brief Copy constructor.
*
* @SINCE_1_0.0
* @param[in] other The Map to copy from
Map( const Map& other );
/**
- * @brief Move Constructor.
+ * @brief Move constructor.
*
* @SINCE_1_4.17
* @param[in] other The Map to move from
- * @note The other array is an r-value so becomes invalid and is no longer usable.
+ * @note After the @a other array is used, it becomes invalid and is no longer usable.
*/
Map( Map&& other );
Value& operator[]( Property::Index key );
/**
- * @brief Assignment Operator.
+ * @brief Assignment operator.
*
* @SINCE_1_0.0
* @param[in] other The map to copy from
Map& operator=( const Map& other );
/**
- * @brief Move Assignment Operator.
+ * @brief Move assignment operator.
*
* @SINCE_1_4.17
* @param[in] other The map to move from
/**
* @brief Move constructor.
*
+ * A move constructor enables the resources owned by an rvalue object to be moved into an lvalue without copying.
* @SINCE_1_4.16
* @param[in] value The property value to move from
*/
Name: dali
Summary: DALi 3D Engine
-Version: 1.4.25
+Version: 1.4.26
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-core.git / commitdiff