* @param[in] localPoint Relative to the actor attached to the detector.
*/
void EmitTapSignal(
- Actor* actor,
- const GestureDetectorContainer& gestureDetectors,
- const Integration::TapGestureEvent& tapEvent,
- Vector2 localPoint)
+ Actor* actor,
+ const GestureDetectorContainer& gestureDetectors,
+ const Integration::TapGestureEvent& tapEvent,
+ Vector2 localPoint)
{
TapGesture tap;
tap.time = tapEvent.time;
$(internal_src_dir)/render/common/render-tracker.cpp \
$(internal_src_dir)/render/common/render-manager.cpp \
$(internal_src_dir)/render/common/texture-cache-dispatcher.cpp \
+ $(internal_src_dir)/render/data-providers/render-data-provider.cpp \
$(internal_src_dir)/render/gl-resources/bitmap-texture.cpp \
$(internal_src_dir)/render/gl-resources/context.cpp \
$(internal_src_dir)/render/gl-resources/frame-buffer-state-cache.cpp \
class SamplerDataProvider;
class Shader;
-
+/**
+ * Interface to provide data of the material to the renderer.
+ * This interface must not be used to pass object pointers.
+ */
class MaterialDataProvider
{
public:
- typedef Dali::Vector< const SamplerDataProvider* > Samplers;
-
/**
* Construtor
*/
{
}
- /**
- * @todo MESH_REWORK FIX ME Don't get objects through this interface. Send via message instead
- *
- * Returns the shader
- * @return The shader
- */
- virtual Shader* GetShader() const = 0;
-
- /**
- * @todo MESH_REWORK FIX ME Don't get objects through this interface. Send via message instead
- * Returns the list of samplers that this material provides
- * @return The list of samplers
- */
- virtual const Samplers& GetSamplers() const = 0;
-
protected:
/**
* Destructor. No deletion through this interface
--- /dev/null
+/*
+ * Copyright (c) 2015 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.
+ *
+ */
+
+#include "render-data-provider.h"
+
+namespace Dali
+{
+namespace Internal
+{
+namespace SceneGraph
+{
+
+RenderDataProvider::RenderDataProvider(
+ const GeometryDataProvider& geometryDataProvider,
+ const MaterialDataProvider& materialDataProvider,
+ const UniformMapDataProvider& uniformMapDataProvider,
+ Shader& shader,
+ const PropertyBuffer* indexBuffer,
+ const VertexBuffers& vertexBuffers,
+ const Samplers& samplers )
+
+: mGeometryDataProvider( &geometryDataProvider ),
+ mMaterialDataProvider( &materialDataProvider ),
+ mUniformMapDataProvider( &uniformMapDataProvider ),
+ mShader( &shader ),
+ mIndexBuffer( indexBuffer ),
+ mVertexBuffers( vertexBuffers ),
+ mSamplers( samplers )
+{
+}
+
+RenderDataProvider::~RenderDataProvider()
+{
+}
+
+void RenderDataProvider::SetGeometry( const GeometryDataProvider& geometryDataProvider )
+{
+ mGeometryDataProvider = &geometryDataProvider;
+}
+
+const GeometryDataProvider& RenderDataProvider::GetGeometry() const
+{
+ return *mGeometryDataProvider;
+}
+
+void RenderDataProvider::SetMaterial( const MaterialDataProvider& materialDataProvider )
+{
+ mMaterialDataProvider = &materialDataProvider;
+}
+
+const MaterialDataProvider& RenderDataProvider::GetMaterial() const
+{
+ return *mMaterialDataProvider;
+}
+
+void RenderDataProvider::SetUniformMap(const UniformMapDataProvider& uniformMapDataProvider)
+{
+ mUniformMapDataProvider = &uniformMapDataProvider;
+}
+
+const UniformMapDataProvider& RenderDataProvider::GetUniformMap() const
+{
+ return *mUniformMapDataProvider;
+}
+
+void RenderDataProvider::SetShader( Shader& shader )
+{
+ mShader = &shader;
+}
+
+Shader& RenderDataProvider::GetShader() const
+{
+ return *mShader;
+}
+
+void RenderDataProvider::SetIndexBuffer( const PropertyBuffer* indexBuffer )
+{
+ mIndexBuffer = indexBuffer;
+}
+
+const PropertyBuffer* RenderDataProvider::GetIndexBuffer() const
+{
+ return mIndexBuffer;
+}
+
+void RenderDataProvider::SetVertexBuffers( const RenderDataProvider::VertexBuffers& vertexBuffers)
+{
+ DALI_ASSERT_DEBUG( vertexBuffers.Count() > 0 && "Using empty vertex buffer" );
+ mVertexBuffers = vertexBuffers;
+}
+
+const RenderDataProvider::VertexBuffers& RenderDataProvider::GetVertexBuffers() const
+{
+ return mVertexBuffers;
+}
+
+void RenderDataProvider::SetSamplers( const RenderDataProvider::Samplers& samplers )
+{
+ mSamplers = samplers;
+}
+
+const RenderDataProvider::Samplers& RenderDataProvider::GetSamplers() const
+{
+ return mSamplers;
+}
+
+
+} // SceneGraph
+} // Internal
+} // Dali
--- /dev/null
+#ifndef __DALI_INTERNAL_SCENE_GRAPH_RENDER_DATA_PROVIDER_H__
+#define __DALI_INTERNAL_SCENE_GRAPH_RENDER_DATA_PROVIDER_H__
+
+/*
+ * Copyright (c) 2015 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.
+ *
+ */
+
+#include <dali/internal/render/data-providers/geometry-data-provider.h>
+#include <dali/internal/render/data-providers/material-data-provider.h>
+#include <dali/internal/render/data-providers/node-data-provider.h>
+#include <dali/internal/render/data-providers/sampler-data-provider.h>
+#include <dali/internal/render/data-providers/uniform-map-data-provider.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace SceneGraph
+{
+class PropertyBuffer;
+
+/**
+ * Wraps all the data providers for the renderer. This allows the
+ * individual providers to change connections in the update thread without affecting
+ * the current render. It essentially provides double buffering of the
+ * provider accessor through the message system. It does not take ownership
+ * of any objects.
+ *
+ * @todo - Add set of bools to state what changed (For improving performance)
+ */
+class RenderDataProvider
+{
+public:
+ typedef Dali::Vector< const PropertyBuffer* > VertexBuffers;
+ typedef Dali::Vector< const SamplerDataProvider* > Samplers;
+
+ /**
+ * Constructor.
+ */
+ RenderDataProvider( const GeometryDataProvider& mGeometryDataProvider,
+ const MaterialDataProvider& mMaterialDataProvider,
+ const UniformMapDataProvider& mUniformMapDataProvider,
+ Shader& mShader,
+ const PropertyBuffer* mIndexBuffer,
+ const VertexBuffers& mVertexBuffers,
+ const Samplers& mSamplers );
+
+ /**
+ * Destructor
+ */
+ ~RenderDataProvider();
+
+public:
+ /**
+ * Set the geometry data provider
+ * @param[in] geometryDataProvider The geometry data provider
+ */
+ void SetGeometry( const GeometryDataProvider& geometryDataProvider );
+
+ /**
+ * Get the geometry data provider
+ * @return the geometry data provider
+ */
+ const GeometryDataProvider& GetGeometry() const;
+
+ /**
+ * Set the material data provider
+ * @param[in] materialDataProvider The material data provider
+ */
+ void SetMaterial( const MaterialDataProvider& materialDataProvider );
+
+ /**
+ * Get the material data provider
+ * @return the material data provider
+ */
+ const MaterialDataProvider& GetMaterial() const;
+
+ /**
+ * Set the uniform map data provider
+ * @param[in] uniformMapDataProvider The uniform map data provider
+ */
+ void SetUniformMap(const UniformMapDataProvider& uniformMapDataProvider);
+
+ /**
+ * Get the uniform map data provider
+ */
+ const UniformMapDataProvider& GetUniformMap() const;
+
+ /**
+ * Set the shader data provider
+ * @param[in] shader The shader data provider
+ */
+ void SetShader( Shader& shader );
+
+ /**
+ * Returns the shader
+ * @return The shader
+ */
+ Shader& GetShader() const;
+
+ /**
+ * Set the index buffer
+ * @param[in] indexBuffer the index buffer to set
+ */
+ void SetIndexBuffer( const PropertyBuffer* indexBuffer );
+
+ /**
+ * Get the index buffer of the geometry
+ * @return A const reference to the index buffer
+ */
+ const PropertyBuffer* GetIndexBuffer() const;
+
+ /**
+ * Set the vertex buffers
+ * @param[in] vertexBuffers The vertex buffers
+ */
+ void SetVertexBuffers( const VertexBuffers& vertexBuffers );
+
+ /**
+ * Get the vertex buffers of the geometry
+ * @return A const reference to the vertex buffers
+ */
+ const VertexBuffers& GetVertexBuffers() const;
+
+ /**
+ * Set the sampler data providers
+ * @param[in] samplers The sampler data providers
+ */
+ void SetSamplers( const Samplers& samplers );
+
+ /**
+ * Returns the list of sampler data providers
+ * @return The list of samplers
+ */
+ const Samplers& GetSamplers() const;
+
+private:
+ const GeometryDataProvider* mGeometryDataProvider;
+ const MaterialDataProvider* mMaterialDataProvider;
+ const UniformMapDataProvider* mUniformMapDataProvider;
+ Shader* mShader;
+ const PropertyBuffer* mIndexBuffer;
+ VertexBuffers mVertexBuffers;
+ Samplers mSamplers;
+};
+
+} // SceneGraph
+} // Internal
+} // Dali
+
+#endif // __DALI_INTERNAL_SCENE_GRAPH_RENDER_DATA_PROVIDER_H__
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/update/geometry/scene-graph-geometry.h>
#include <dali/internal/update/common/scene-graph-property-buffer.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
#include <dali/internal/render/gl-resources/context.h>
#include <dali/internal/render/gl-resources/gpu-buffer.h>
#include <dali/internal/render/shaders/program.h>
Context& context,
Program& program,
BufferIndex bufferIndex,
- const GeometryDataProvider& geometryDataProvider )
+ const RenderDataProvider* dataProviders )
{
- UploadVertexData( context, bufferIndex, geometryDataProvider );
+ UploadVertexData( context, bufferIndex, dataProviders );
BindBuffers();
EnableVertexAttributes( context, program );
- Draw( context, bufferIndex, geometryDataProvider );
+ Draw( context, bufferIndex, dataProviders );
DisableVertexAttributes( context, program );
}
void RenderGeometry::UploadVertexData(
Context& context,
BufferIndex bufferIndex,
- const GeometryDataProvider& geometry )
+ const RenderDataProvider* dataProviders )
{
if( mDataNeedsUploading ) // @todo Or if any of the property buffers are dirty
{
- DoUpload( context, bufferIndex, geometry );
+ DoUpload( context, bufferIndex, dataProviders );
mDataNeedsUploading = false;
}
void RenderGeometry::DoUpload(
Context& context,
BufferIndex bufferIndex,
- const GeometryDataProvider& geometry)
+ const RenderDataProvider* dataProvider )
{
// Vertex buffer
- const Geometry::VertexBuffers& vertexBuffers = geometry.GetVertexBuffers();
+ RenderDataProvider::VertexBuffers vertexBuffers = dataProvider->GetVertexBuffers();
+
DALI_ASSERT_DEBUG( vertexBuffers.Count() > 0 && "Need vertex buffers to upload" );
for( unsigned int i=0; i<vertexBuffers.Count(); ++i)
}
// Index buffer
- const PropertyBuffer* indexBuffer = geometry.GetIndexBuffer();
+ const PropertyBuffer* indexBuffer = dataProvider->GetIndexBuffer();
if( indexBuffer )
{
GpuBuffer* indexGpuBuffer = new GpuBuffer( context, GpuBuffer::ELEMENT_ARRAY_BUFFER, GpuBuffer::STATIC_DRAW );
context.DisableVertexAttributeArray( textureCoordsLoc );
}
-void RenderGeometry::Draw( Context& context, BufferIndex bufferIndex, const GeometryDataProvider& geometry )
+void RenderGeometry::Draw( Context& context, BufferIndex bufferIndex, const RenderDataProvider* dataProvider )
{
+ const GeometryDataProvider& geometry = dataProvider->GetGeometry();
+ const PropertyBuffer* indexBuffer = dataProvider->GetIndexBuffer();
+
GeometryDataProvider::GeometryType type = geometry.GetGeometryType( bufferIndex );
unsigned int numIndices = 0;
- const PropertyBuffer* indexBuffer = geometry.GetIndexBuffer();
-
if( indexBuffer )
{
numIndices = /* TODO: MESH_REWORK remove this 2, should implement unsigned short properties */ 2 * indexBuffer->GetDataSize(bufferIndex) / indexBuffer->GetElementSize(bufferIndex);
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/common/owner-container.h>
#include <dali/internal/common/owner-pointer.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
namespace Dali
{
namespace SceneGraph
{
+class RenderDataProvider;
class GeometryDataProvider;
/**
* @param[in] context The GL context
* @param[in] program The shader program to query for attribute locations
* @param[in] bufferIndex The current buffer index
- * @param[in] geometryDataProvider The geometry data provider (to fetch geometry from)
+ * @param[in] dataProviders The data providers (to fetch geometry from)
*/
void UploadAndDraw(Context& context,
Program& program,
BufferIndex bufferIndex,
- const GeometryDataProvider& geometryDataProvider );
+ const RenderDataProvider* dataProviders );
/**
* Tell the object that the geometry has been updated.
*/
void UploadVertexData( Context& context,
BufferIndex bufferIndex,
- const GeometryDataProvider& geometryDataProvider );
-
+ const RenderDataProvider* dataProviders );
private:
/**
* Perform the upload of the geometry
* @param[in] context The GL context
* @param[in] bufferIndex The current buffer index
- * @param[in] geometryDataProvider The geometry data provider (to fetch geometry from)
+ * @param[in] dataProviders The data providers (to fetch geometry from)
*/
void DoUpload( Context& context,
BufferIndex bufferIndex,
- const GeometryDataProvider& geometryDataProvider );
+ const RenderDataProvider* dataProviders );
/**
* Bind the geometry buffers
* Perform the correct draw call corresponding to the geometry type
* @param[in] context The GL context
* @param[in] bufferIndex The current buffer index
- * @param[in] geometryDataProvider The geometry data provider (to fetch geometry from)
+ * @param[in] dataProviders The data providers (to fetch geometry from)
*/
void Draw( Context& context,
BufferIndex bufferIndex,
- const GeometryDataProvider& geometry );
+ const RenderDataProvider* dataProviders );
private:
GpuBuffers mVertexBuffers;
#include <dali/internal/common/image-sampler.h>
#include <dali/internal/event/common/property-input-impl.h>
#include <dali/internal/update/common/uniform-map.h>
-#include <dali/internal/update/common/uniform-map.h>
-#include <dali/internal/render/data-providers/geometry-data-provider.h>
-#include <dali/internal/render/data-providers/material-data-provider.h>
-#include <dali/internal/render/data-providers/node-data-provider.h>
-#include <dali/internal/render/data-providers/sampler-data-provider.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
#include <dali/internal/render/gl-resources/texture.h>
#include <dali/internal/render/gl-resources/texture-cache.h>
#include <dali/internal/render/shaders/program.h>
-
namespace Dali
{
namespace Internal
{
NewRenderer* NewRenderer::New( NodeDataProvider& nodeDataProvider,
- const UniformMapDataProvider& uniformMapDataProvider,
- const GeometryDataProvider* geometryDataProvider,
- const MaterialDataProvider* materialDataProvider)
+ RenderDataProvider* dataProvider )
{
- return new NewRenderer(nodeDataProvider, uniformMapDataProvider, geometryDataProvider, materialDataProvider);
+ return new NewRenderer(nodeDataProvider, dataProvider);
}
NewRenderer::NewRenderer( NodeDataProvider& nodeDataProvider,
- const UniformMapDataProvider& uniformMapDataProvider,
- const GeometryDataProvider* geometryDataProvider,
- const MaterialDataProvider* materialDataProvider)
+ RenderDataProvider* dataProvider )
: Renderer( nodeDataProvider ),
- mUniformMapDataProvider( uniformMapDataProvider ),
- //mShaderDataProvider( shaderDataProvider ), //@todo Add in after merge with parent class
- mMaterialDataProvider( materialDataProvider ),
- mGeometryDataProvider( geometryDataProvider )
+ mRenderDataProvider( dataProvider )
{
}
{
}
-// @todo MESH_REWORK Should we consider changing the providers, or should we instead
-// create a new renderer when these change?
-void NewRenderer::SetGeometryDataProvider( const GeometryDataProvider* geometryDataProvider )
+void NewRenderer::SetRenderDataProvider( RenderDataProvider* dataProvider )
{
- mGeometryDataProvider = geometryDataProvider;
+ mRenderDataProvider = dataProvider;
mRenderGeometry.GeometryUpdated();
}
-void NewRenderer::SetMaterialDataProvider( const MaterialDataProvider* materialDataProvider )
-{
- mMaterialDataProvider = materialDataProvider;
-}
-
-
// Note - this is currently called from UpdateThread, PrepareRenderInstructions,
// as an optimisation.
// @todo MESH_REWORK Should use Update thread objects only in PrepareRenderInstructions.
void NewRenderer::DoRender( Context& context, TextureCache& textureCache, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix )
{
- BindTextures( textureCache, bufferIndex, program, mMaterialDataProvider->GetSamplers() );
+ BindTextures( textureCache, bufferIndex, program, mRenderDataProvider->GetSamplers() );
SetUniforms( bufferIndex, program );
- mRenderGeometry.UploadAndDraw( context, program, bufferIndex, *mGeometryDataProvider );
+ mRenderGeometry.UploadAndDraw( context, program, bufferIndex, mRenderDataProvider.Get() );
}
void NewRenderer::GlContextDestroyed()
void NewRenderer::SetUniforms( BufferIndex bufferIndex, Program& program )
{
// Check if the map has changed
- if( mUniformMapDataProvider.GetUniformMapChanged( bufferIndex ) )
+ DALI_ASSERT_DEBUG( mRenderDataProvider && "No Uniform map data provider available" );
+
+ const UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap();
+
+ if( uniformMapDataProvider.GetUniformMapChanged( bufferIndex ) )
{
- const CollectedUniformMap& uniformMap = mUniformMapDataProvider.GetUniformMap( bufferIndex );
+ const CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap( bufferIndex );
unsigned int numberOfMaps = uniformMap.Count();
mUniformIndexMap.Clear(); // Clear contents, but keep memory if we don't change size
mUniformIndexMap.Resize( numberOfMaps );
// Remap uniform indexes to property value addresses
-
for( unsigned int mapIndex = 0 ; mapIndex < numberOfMaps ; ++mapIndex )
{
mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex]->propertyPtr;
}
void NewRenderer::BindTextures(
- TextureCache& textureCache,
- BufferIndex bufferIndex,
- Program& program,
- const MaterialDataProvider::Samplers& samplers )
+ TextureCache& textureCache,
+ BufferIndex bufferIndex,
+ Program& program,
+ const RenderDataProvider::Samplers& samplers )
{
// @todo MESH_REWORK Write a cache of texture units to commonly used sampler textures
unsigned int textureUnit = 0;
- for( MaterialDataProvider::Samplers::Iterator iter = samplers.Begin();
+ for( RenderDataProvider::Samplers::Iterator iter = samplers.Begin();
iter != samplers.End();
++iter )
{
*/
#include <dali/integration-api/resource-declarations.h> // For resource id
-#include <dali/internal/render/data-providers/material-data-provider.h>
-#include <dali/internal/render/data-providers/uniform-map-data-provider.h>
+#include <dali/internal/common/owner-pointer.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
#include <dali/internal/render/gl-resources/texture-units.h>
#include <dali/internal/render/renderers/scene-graph-renderer.h>
#include <dali/internal/render/renderers/render-geometry.h>
namespace SceneGraph
{
-class GeometryDataProvider;
-class MaterialDataProvider;
-class NodeDataProvider;
-class RenderGeometry;
-class SamplerDataProvider;
-class ShaderDataProvider;
-class UniformMapDataProvider;
/**
* The new geometry renderer.
/**
* Create a new renderer instance
* @param[in] nodeDataProvider The node data provider
- * @param[in] uniformMapDataProvider The uniform map data provider
- * @param[in] geometryDataProvider The geometry data provider
- * @param[in] materialDataProvider The material data provider
+ * @param[in] dataProviders The data providers for the renderer
*/
- static NewRenderer* New( NodeDataProvider& nodeDataProvider,
- const UniformMapDataProvider& uniformMapDataProvider,
- const GeometryDataProvider* geometryDataProvider,
- const MaterialDataProvider* materialDataProvider );
+ static NewRenderer* New( NodeDataProvider& nodeDataProvider, RenderDataProvider* dataProviders );
/**
* Constructor.
* @param[in] nodeDataProvider The node data provider
- * @param[in] uniformMapDataProvider The uniform map data provider
- * @param[in] geometryDataProvider The geometry data provider
- * @param[in] materialDataProvider The material data provider
+ * @param[in] dataProviders The data providers for the renderer
*/
- NewRenderer( NodeDataProvider& nodeDataProvider,
- const UniformMapDataProvider& uniformMapDataProvider,
- const GeometryDataProvider* geometryDataProvider,
- const MaterialDataProvider* materialDataProvider );
+ NewRenderer( NodeDataProvider& nodeDataProvider, RenderDataProvider* dataProviders );
virtual ~NewRenderer();
/**
- * Change the geometry data provider of the renderer
- * @param[in] geoemtryDataProvider The geometry data provider
+ * Change the data providers of the renderer
+ * @param[in] dataProviders The data providers
*/
- void SetGeometryDataProvider( const GeometryDataProvider* geometryDataProvider );
-
- /**
- * Change the material data provider of the renderer
- * @param[in] materialDataProvider The material data provider
- */
- void SetMaterialDataProvider( const MaterialDataProvider* materialDataProvider );
+ void SetRenderDataProvider( RenderDataProvider* dataProviders );
public: // Implementation of Renderer
/**
void BindTextures( TextureCache& textureCache,
BufferIndex bufferIndex,
Program& program,
- const MaterialDataProvider::Samplers& samplers );
+ const RenderDataProvider::Samplers& samplers );
/**
* Bind a material texture to a texture unit, and set the sampler's texture uniform
unsigned int GetTextureUnitUniformIndex( Program& program,
const SamplerDataProvider& sampler );
-
-public:
- // @todo MESH_REWORK Make private - add getters
- //const NodeDataProvider& mNodeDataProvider;
- //const ShaderDataProvider& mShaderDataProvider;
- const UniformMapDataProvider& mUniformMapDataProvider;
- const MaterialDataProvider* mMaterialDataProvider;
- const GeometryDataProvider* mGeometryDataProvider;
+public: //@todo MESH_REWORK make private after merge with SceneGraph::Renderer
+ OwnerPointer< RenderDataProvider > mRenderDataProvider;
private:
-
RenderGeometry mRenderGeometry;
struct TextureUnitUniformIndex
if( renderer )
{
// Get the shader from the material:
- mShader = renderer->mMaterialDataProvider->GetShader();
+ mShader = &renderer->mRenderDataProvider->GetShader();
}
// if mShader is NULL it means we're set to default
program->SetUniform1f( loc, frametime );
}
+ //@todo MESH_REWORK Remove after removing ImageRenderer
DoSetUniforms(context, bufferIndex, mShader, program, programIndex, subType );
// subclass rendering and actual draw call
protected:
- NodeDataProvider& mDataProvider;
+ NodeDataProvider& mDataProvider; // @todo MESH_REWORK rename to mNodeDataProvider. Shouldn't it be const?
Context* mContextDELETEME; // TODO: MESH_REWORK DELETE THIS
TextureCache* mTextureCacheDELETEME; // TODO: MESH_REWORK DELETE THIS
const SamplerDataProvider* samplerDataProvider = sampler;
bool found = false;
- Samplers::Iterator iter = mSamplers.Begin();
+ RenderDataProvider::Samplers::Iterator iter = mSamplers.Begin();
for( ; iter != mSamplers.End(); ++iter )
{
if( *iter == samplerDataProvider )
}
}
-const Material::Samplers& Material::GetSamplers() const
+const RenderDataProvider::Samplers& Material::GetSamplers() const
{
return mSamplers;
}
#include <dali/internal/update/common/property-owner.h>
#include <dali/internal/update/common/scene-graph-connection-observers.h>
#include <dali/internal/update/common/uniform-map.h>
-#include <dali/internal/render/data-providers/material-data-provider.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
namespace Dali
{
* Get the samplers this material uses.
* @return the samplers
*/
- virtual const Samplers& GetSamplers() const;
+ virtual const RenderDataProvider::Samplers& GetSamplers() const;
public: // UniformMap::Observer
/**
private:
const Shader* mShader;
- Samplers mSamplers; // Not owned
+ RenderDataProvider::Samplers mSamplers; // Not owned
ConnectionObservers mConnectionObservers;
// @todo MESH_REWORK add property values for cull face mode, blending options, blend color
*/
virtual void UniformMappingsChanged( const UniformMap& mappings );
-public: // GeometryDataProvider
/**
* Get the vertex buffers of the geometry
* @return A const reference to the vertex buffers
*/
- virtual const GeometryDataProvider::VertexBuffers& GetVertexBuffers() const;
+ const GeometryDataProvider::VertexBuffers& GetVertexBuffers() const;
/**
* Get the index buffer of the geometry
* @return A const pointer to the index buffer if it exists, or NULL if it doesn't.
*/
- virtual const PropertyBuffer* GetIndexBuffer() const;
+ const PropertyBuffer* GetIndexBuffer() const;
+public: // GeometryDataProvider
/**
* Get the type of geometry to draw
*/
#include <dali/internal/update/geometry/scene-graph-geometry.h>
#include <dali/internal/update/resources/complete-status-manager.h>
#include <dali/internal/update/resources/resource-manager.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
#include <dali/internal/render/queue/render-queue.h>
#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
mMaterial(NULL),
mGeometry(NULL),
mRegenerateUniformMap(REGENERATE_UNIFORM_MAP),
- mResendChildPointers(false),
+ mResendDataProviders(false),
mDepthIndex(0)
{
mUniformMapChanged[0]=false;
mParent->AddUniformMapObserver( *this );
DALI_ASSERT_DEBUG( mParent != NULL );
- mRenderer = NewRenderer::New( *mParent, *this, mGeometry, mMaterial );
+
+ RenderDataProvider* dataProvider = new RenderDataProvider( *mGeometry,
+ *mMaterial,
+ *this,
+ *mMaterial->GetShader(),
+ mGeometry->GetIndexBuffer(),
+ mGeometry->GetVertexBuffers(),
+ mMaterial->GetSamplers() );
+
+ mRenderer = NewRenderer::New( *mParent, dataProvider );
mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer );
}
mMaterial->AddConnectionObserver( *this );
mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
- // Tell renderer about a new provider
- if( mRenderer )
- {
- typedef MessageValue1< NewRenderer, const MaterialDataProvider*> DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &NewRenderer::SetMaterialDataProvider, material );
- }
+ mResendDataProviders = true;
}
const Material& RendererAttachment::GetMaterial() const
mGeometry->AddConnectionObserver( *this ); // Observe geometry connections / uniform mapping changes
mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
- // Tell renderer about a new provider
- if( mRenderer )
- {
- typedef MessageValue1< NewRenderer, const GeometryDataProvider*> DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &NewRenderer::SetGeometryDataProvider, geometry );
- }
+ mResendDataProviders = true;
}
const Geometry& RendererAttachment::GetGeometry() const
AddMappings( localMap, actorUniformMap );
AddMappings( localMap, mMaterial->GetUniformMap() );
- const MaterialDataProvider::Samplers& samplers = mMaterial->GetSamplers();
- for( MaterialDataProvider::Samplers::ConstIterator iter = samplers.Begin(), end = samplers.End();
+ const RenderDataProvider::Samplers& samplers = mMaterial->GetSamplers();
+ for( RenderDataProvider::Samplers::ConstIterator iter = samplers.Begin(), end = samplers.End();
iter != end ;
++iter )
{
mRegenerateUniformMap--;
}
- if( mResendChildPointers )
+ if( mResendDataProviders )
{
- //@todo MESH_REWORK If the children have changed, then supply the NewRenderer with the
- // new children. (Rather than accessing through the DataProvider interface)
- mResendChildPointers = false;
+ RenderDataProvider* dataProvider = new RenderDataProvider( *mGeometry,
+ *mMaterial,
+ *this,
+ *mMaterial->GetShader(),
+ mGeometry->GetIndexBuffer(),
+ mGeometry->GetVertexBuffers(),
+ mMaterial->GetSamplers() );
+
+ // Tell renderer about a new provider
+ // @todo MESH_REWORK Should we instead create a new renderer when these change?
+
+ typedef MessageValue1< NewRenderer, OwnerPointer<RenderDataProvider> > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &NewRenderer::SetRenderDataProvider, dataProvider );
+
+ mResendDataProviders = false;
}
}
unsigned int opaqueCount=0;
unsigned int affectingCount=0;
- const Material::Samplers& samplers = mMaterial->GetSamplers();
- for( Material::Samplers::ConstIterator iter = samplers.Begin();
+ const RenderDataProvider::Samplers& samplers = mMaterial->GetSamplers();
+ for( RenderDataProvider::Samplers::ConstIterator iter = samplers.Begin();
iter != samplers.End(); ++iter )
{
const Sampler* sampler = static_cast<const Sampler*>(*iter);
unsigned int neverCount = 0;
unsigned int frameBufferCount = 0;
- const Material::Samplers& samplers = mMaterial->GetSamplers();
- for( Material::Samplers::ConstIterator iter = samplers.Begin();
+ const RenderDataProvider::Samplers& samplers = mMaterial->GetSamplers();
+ for( RenderDataProvider::Samplers::ConstIterator iter = samplers.Begin();
iter != samplers.End(); ++iter )
{
const Sampler* sampler = static_cast<const Sampler*>(*iter);
mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
// Ensure the child object pointers get re-sent to the renderer
- mResendChildPointers = true;
+ mResendDataProviders = true;
}
void RendererAttachment::ConnectedUniformMapChanged()
#include <dali/internal/update/controllers/render-message-dispatcher.h>
#include <dali/internal/update/controllers/scene-controller.h>
#include <dali/internal/update/node-attachments/scene-graph-renderable-attachment.h>
-#include <dali/internal/render/data-providers/uniform-map-data-provider.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
namespace Dali
{
/**
* Add any new mappings from map into the current map.
* This doesn't override any existing mappings.
+ * @param[in] localMap The map of collected uniforms.
+ * @param[in] map The map to import into the local map
*/
void AddMappings( CollectedUniformMap& localMap, const UniformMap& map );
CollectedUniformMap mCollectedUniformMap[2];
int mRegenerateUniformMap; ///< 2 if the map should be regenerated, 1 if it should be copied.
bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame
- bool mResendChildPointers;
+ bool mResendDataProviders; ///< True if the data providers should be resent to the renderer
public: // Properties
}
FrameBufferImage::FrameBufferImage(Internal::FrameBufferImage* internal)
- : Image(internal)
+: Image(internal)
{
}
projects / platform / core / uifw / dali-core.git / commitdiff