From: Adam Bialogonski Date: Tue, 19 Apr 2016 13:46:45 +0000 (+0100) Subject: Added setIndicesRange(offset, count) function to the Dali::Renderer which allows... X-Git-Tag: dali_1.1.32~7 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F84%2F66584%2F6;p=platform%2Fcore%2Fuifw%2Fdali-core.git Added setIndicesRange(offset, count) function to the Dali::Renderer which allows to render only a part of the index buffer. Update patchset 3: changed variable name for better code readability Update patchset 4: added two properties INDEXED_DRAW_FIRST_ELEMENT and INDEXED_DRAW_ELEMENTS_COUNT. the public api function setIndicesRange() wraps those properties now. Added simple test case to test setIndicesRange() function. added safeguard to make sure the indices won't go out of bounds. Update patchset 5: first element and count are not public vars anymore in the scene-graph-renderer.h Update patchset 6: compilation error Change-Id: I3102128c0fed753663ae2135fe11fb3a55652984 --- diff --git a/automated-tests/src/dali-devel/utc-Dali-Renderer.cpp b/automated-tests/src/dali-devel/utc-Dali-Renderer.cpp index 417a556..96fd229 100644 --- a/automated-tests/src/dali-devel/utc-Dali-Renderer.cpp +++ b/automated-tests/src/dali-devel/utc-Dali-Renderer.cpp @@ -18,6 +18,8 @@ #include #include +#include + using namespace Dali; #include @@ -1948,3 +1950,111 @@ int UtcDaliRendererRenderOrder2DLayerOverlay(void) END_TEST; } + +int UtcDaliRendererSetIndicesRange(void) +{ + std::string + vertexShader( + "attribute vec2 aPosition;\n" + "void main()\n" + "{\n" + " gl_Position = aPosition;\n" + "}" + ), + fragmentShader( + "void main()\n" + "{\n" + " gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0)\n" + "}\n" + ); + + TestApplication application; + tet_infoline("Test setting the range of indices to draw"); + + TestGlAbstraction& gl = application.GetGlAbstraction(); + gl.EnableDrawCallTrace( true ); + + Actor actor = Actor::New(); + actor.SetSize( 100, 100 ); + + // create geometry + Geometry geometry = Geometry::New(); + geometry.SetGeometryType( Geometry::LINE_LOOP ); + + // -------------------------------------------------------------------------- + // index buffer + unsigned indices[] = { 0, 2, 4, 6, 8, // offset = 0, count = 5 + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, // offset = 5, count = 10 + 1, 3, 5, 7, 9, 1 }; // offset = 15, count = 6 // line strip + Property::Map format; + format["indices"] = Property::INTEGER; + PropertyBuffer indexBuffer = PropertyBuffer::New( format ); + indexBuffer.SetData( indices, sizeof(indices)/sizeof(indices[0])); + + // -------------------------------------------------------------------------- + // vertex buffer + struct Vertex + { + Vector2 position; + }; + Vertex shapes[] = + { + // pentagon // star + { Vector2( 0.0f, 1.00f) }, { Vector2( 0.0f, -1.00f) }, + { Vector2( -0.95f, 0.31f) }, { Vector2( 0.59f, 0.81f) }, + { Vector2( -0.59f, -0.81f) }, { Vector2( -0.95f, -0.31f) }, + { Vector2( 0.59f, -0.81f) }, { Vector2( 0.95f, -0.31f) }, + { Vector2( 0.95f, 0.31f) }, { Vector2( -0.59f, 0.81f) }, + }; + Property::Map vertexFormat; + vertexFormat["aPosition"] = Property::VECTOR2; + PropertyBuffer vertexBuffer = PropertyBuffer::New( vertexFormat ); + vertexBuffer.SetData( shapes, sizeof(shapes)/sizeof(shapes[0])); + + // -------------------------------------------------------------------------- + geometry.SetIndexBuffer( indexBuffer ); + geometry.AddVertexBuffer( vertexBuffer ); + + // create shader + Shader shader = Shader::New( vertexShader,fragmentShader ); + Renderer renderer = Renderer::New( geometry, shader ); + actor.AddRenderer( renderer ); + + Stage stage = Stage::GetCurrent(); + stage.Add( actor ); + + char buffer[ 128 ]; + + // LINE_LOOP, first 0, count 5 + { + renderer.SetIndicesRange( 0, 5 ); + application.SendNotification(); + application.Render(); + sprintf( buffer, "%u, 5, %u, indices", GL_LINE_LOOP, GL_UNSIGNED_SHORT ); + bool result = gl.GetDrawTrace().FindMethodAndParams( "DrawElements" , buffer ); + DALI_TEST_CHECK( result ); + } + + // LINE_LOOP, first 5, count 10 + { + renderer.SetIndicesRange( 5, 10 ); + sprintf( buffer, "%u, 10, %u, indices", GL_LINE_LOOP, GL_UNSIGNED_SHORT ); + application.SendNotification(); + application.Render(); + bool result = gl.GetDrawTrace().FindMethodAndParams( "DrawElements" , buffer ); + DALI_TEST_CHECK( result ); + } + + // LINE_STRIP, first 15, count 6 + { + renderer.SetIndicesRange( 15, 6 ); + geometry.SetGeometryType( Geometry::LINE_STRIP ); + sprintf( buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT ); + application.SendNotification(); + application.Render(); + bool result = gl.GetDrawTrace().FindMethodAndParams( "DrawElements" , buffer ); + DALI_TEST_CHECK( result ); + } + + END_TEST; +} diff --git a/dali/devel-api/rendering/renderer.h b/dali/devel-api/rendering/renderer.h index e77a6c2..ff0d7ae 100644 --- a/dali/devel-api/rendering/renderer.h +++ b/dali/devel-api/rendering/renderer.h @@ -69,6 +69,8 @@ public: BLENDING_DEST_FACTOR_ALPHA, ///< name "destinationBlendFactorAlpha", type INTEGER BLENDING_COLOR, ///< name "blendingColor", type VECTOR4 BLEND_PRE_MULTIPLIED_ALPHA, ///< name "blendPreMultipledAlpha", type BOOLEAN + INDEXED_DRAW_FIRST_ELEMENT, ///< name "indexedDrawFirstElement", type INTEGER + INDEXED_DRAW_ELEMENTS_COUNT ///< name "indexedDrawElementsCount", type INTEGER }; }; @@ -129,6 +131,17 @@ public: Geometry GetGeometry() const; /** + * @brief Sets effective range of indices to draw from bound index buffer + * @param [in] firstElement first element to draw + * @param [in] elementsCount number of elements to draw + */ + inline void SetIndicesRange( int firstElement, int elementsCount ) + { + SetProperty( Property::INDEXED_DRAW_FIRST_ELEMENT, firstElement ); + SetProperty( Property::INDEXED_DRAW_ELEMENTS_COUNT, elementsCount ); + } + + /** * @brief Sets the texture set to be used by this renderer * * @param[in] textureSet The texture set to be used by this renderer diff --git a/dali/internal/event/rendering/renderer-impl.cpp b/dali/internal/event/rendering/renderer-impl.cpp index cd4887f..c1d6e98 100644 --- a/dali/internal/event/rendering/renderer-impl.cpp +++ b/dali/internal/event/rendering/renderer-impl.cpp @@ -50,6 +50,8 @@ DALI_PROPERTY( "sourceBlendFactorAlpha", INTEGER, true, false, false DALI_PROPERTY( "destinationBlendFactorAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLENDING_DEST_FACTOR_ALPHA ) DALI_PROPERTY( "blendingColor", VECTOR4, true, false, false, Dali::Renderer::Property::BLENDING_COLOR ) DALI_PROPERTY( "blendPreMultipliedAlpha", BOOLEAN, true, false, false, Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA ) +DALI_PROPERTY( "indexedDrawFirstElement", INTEGER, true, false, false, Dali::Renderer::Property::INDEXED_DRAW_FIRST_ELEMENT ) +DALI_PROPERTY( "indexedDrawElementsCount", INTEGER, true, false, false, Dali::Renderer::Property::INDEXED_DRAW_ELEMENTS_COUNT ) DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX ) const ObjectImplHelper RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS }; @@ -220,6 +222,25 @@ Vector4 Renderer::GetBlendColor() const return Color::TRANSPARENT; // GL default } +void Renderer::SetIndexedDrawFirstElement( size_t firstElement ) +{ + if( firstElement != mIndexedDrawFirstElement ) + { + mIndexedDrawFirstElement = firstElement; + SetIndexedDrawFirstElementMessage( GetEventThreadServices(), *mSceneObject, mIndexedDrawFirstElement ); + } +} + +void Renderer::SetIndexedDrawElementsCount( size_t elementsCount ) +{ + if( elementsCount != mIndexedDrawElementCount ) + { + mIndexedDrawElementCount = elementsCount; + SetIndexedDrawElementsCountMessage( GetEventThreadServices(), *mSceneObject, mIndexedDrawElementCount ); + } +} + + void Renderer::EnablePreMultipliedAlpha( bool preMultipled ) { if( mPremultipledAlphaEnabled != preMultipled ) @@ -419,6 +440,24 @@ void Renderer::SetDefaultProperty( Property::Index index, } break; } + case Dali::Renderer::Property::INDEXED_DRAW_FIRST_ELEMENT: + { + int firstElement; + if( propertyValue.Get( firstElement ) ) + { + SetIndexedDrawFirstElement( firstElement ); + } + break; + } + case Dali::Renderer::Property::INDEXED_DRAW_ELEMENTS_COUNT: + { + int elementsCount; + if( propertyValue.Get( elementsCount ) ) + { + SetIndexedDrawElementsCount( elementsCount ); + } + break; + } } } @@ -517,6 +556,16 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const value = IsPreMultipliedAlphaEnabled(); break; } + case Dali::Renderer::Property::INDEXED_DRAW_FIRST_ELEMENT: + { + value = static_cast( mIndexedDrawFirstElement ); + break; + } + case Dali::Renderer::Property::INDEXED_DRAW_ELEMENTS_COUNT: + { + value = static_cast( mIndexedDrawElementCount ); + break; + } } return value; } @@ -598,11 +647,13 @@ void Renderer::Disconnect() } Renderer::Renderer() -: mSceneObject(NULL), +: mSceneObject (NULL ), mBlendColor( NULL ), - mDepthIndex(0), - mOnStageCount(0), - mFaceCullingMode(Dali::Renderer::NONE), + mDepthIndex( 0 ), + mOnStageCount( 0 ), + mIndexedDrawFirstElement( 0 ), + mIndexedDrawElementCount( 0 ), + mFaceCullingMode( Dali::Renderer::NONE ), mBlendingMode( Dali::BlendingMode::AUTO ), mBlendingOptions(), mPremultipledAlphaEnabled( false ) diff --git a/dali/internal/event/rendering/renderer-impl.h b/dali/internal/event/rendering/renderer-impl.h index 7943a70..e66383e 100644 --- a/dali/internal/event/rendering/renderer-impl.h +++ b/dali/internal/event/rendering/renderer-impl.h @@ -158,6 +158,16 @@ public: Vector4 GetBlendColor() const; /** + * @copydoc Dali::Renderer::SetIndexedDrawFirstElement + */ + void SetIndexedDrawFirstElement( size_t firstElement ); + + /** + * @copydoc Dali::Renderer::SetIndexedDrawElementsCount + */ + void SetIndexedDrawElementsCount( size_t elementsCount ); + + /** * @brief Set whether the Pre-multiplied Alpha Blending is required * * @param[in] preMultipled whether alpha is pre-multiplied. @@ -301,6 +311,9 @@ private: // data int mDepthIndex; int mOnStageCount; + size_t mIndexedDrawFirstElement; ///< Offset of first element to draw from bound index buffer + size_t mIndexedDrawElementCount; ///< Number of elements to draw + Dali::Renderer::FaceCullingMode mFaceCullingMode; ///< Local copy of face culling mode BlendingMode::Type mBlendingMode; ///< Local copy of blending mode BlendingOptions mBlendingOptions; ///< Local copy of blending options bitmask diff --git a/dali/internal/render/renderers/render-geometry.cpp b/dali/internal/render/renderers/render-geometry.cpp index 0f26ea6..24a9522 100644 --- a/dali/internal/render/renderers/render-geometry.cpp +++ b/dali/internal/render/renderers/render-geometry.cpp @@ -116,7 +116,9 @@ void RenderGeometry::OnRenderFinished() void RenderGeometry::UploadAndDraw( Context& context, BufferIndex bufferIndex, - Vector& attributeLocation ) + Vector& attributeLocation, + size_t elementBufferOffset, + size_t elementBufferCount ) { if( !mHasBeenUpdated ) { @@ -157,9 +159,15 @@ void RenderGeometry::UploadAndDraw( //Bind index buffer unsigned int numIndices(0u); + intptr_t firstIndexOffset(0u); if( mIndexBuffer ) { numIndices = mIndexBuffer->GetDataSize() / mIndexBuffer->GetElementSize(); + if ( elementBufferCount ) + { + numIndices = elementBufferCount > numIndices ? numIndices : elementBufferCount; + } + firstIndexOffset = elementBufferOffset * sizeof(GLushort); } //Draw call @@ -169,7 +177,7 @@ void RenderGeometry::UploadAndDraw( { if( numIndices ) { - context.DrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, 0); + context.DrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast(firstIndexOffset) ); } else { @@ -182,7 +190,7 @@ void RenderGeometry::UploadAndDraw( { if( numIndices ) { - context.DrawElements(GL_LINES, numIndices, GL_UNSIGNED_SHORT, 0); + context.DrawElements(GL_LINES, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast(firstIndexOffset) ); } else { @@ -201,7 +209,7 @@ void RenderGeometry::UploadAndDraw( { if( numIndices ) { - context.DrawElements(GL_TRIANGLE_STRIP, numIndices, GL_UNSIGNED_SHORT, 0); + context.DrawElements(GL_TRIANGLE_STRIP, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast(firstIndexOffset) ); } else { @@ -214,7 +222,7 @@ void RenderGeometry::UploadAndDraw( { if( numIndices ) { - context.DrawElements(GL_TRIANGLE_FAN, numIndices, GL_UNSIGNED_SHORT, 0); + context.DrawElements(GL_TRIANGLE_FAN, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast(firstIndexOffset) ); } else { @@ -227,7 +235,7 @@ void RenderGeometry::UploadAndDraw( { if( numIndices ) { - context.DrawElements(GL_LINE_LOOP, numIndices, GL_UNSIGNED_SHORT, 0); + context.DrawElements(GL_LINE_LOOP, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast(firstIndexOffset) ); } else { @@ -240,7 +248,7 @@ void RenderGeometry::UploadAndDraw( { if( numIndices ) { - context.DrawElements(GL_LINE_STRIP, numIndices, GL_UNSIGNED_SHORT, 0); + context.DrawElements(GL_LINE_STRIP, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast(firstIndexOffset) ); } else { diff --git a/dali/internal/render/renderers/render-geometry.h b/dali/internal/render/renderers/render-geometry.h index 7ac3e75..549c827 100644 --- a/dali/internal/render/renderers/render-geometry.h +++ b/dali/internal/render/renderers/render-geometry.h @@ -141,10 +141,14 @@ public: * @param[in] context The GL context * @param[in] bufferIndex The current buffer index * @param[in] attributeLocation The location for the attributes in the shader + * @param[in] elementBufferOffset The index of first element to draw if index buffer bound + * @param[in] elementBufferCount Number of elements to draw if index buffer bound */ void UploadAndDraw(Context& context, BufferIndex bufferIndex, - Vector& attributeLocation ); + Vector& attributeLocation, + size_t elementBufferOffset, + size_t elementBufferCount ); private: diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp index b48e1d8..ab85957 100644 --- a/dali/internal/render/renderers/render-renderer.cpp +++ b/dali/internal/render/renderers/render-renderer.cpp @@ -135,6 +135,8 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider, mAttributesLocation(), mBlendingOptions(), mFaceCullingMode( faceCullingMode ), + mIndexedDrawFirstElement( 0 ), + mIndexedDrawElementsCount( 0 ), mSamplerBitfield( ImageSampler::PackBitfield( FilterMode::DEFAULT, FilterMode::DEFAULT ) ), mUpdateAttributesLocation( true ), mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ) @@ -417,6 +419,16 @@ void Renderer::SetBlendColor( const Vector4* color ) mBlendingOptions.SetBlendColor( *color ); } +void Renderer::SetIndexedDrawFirstElement( size_t firstElement ) +{ + mIndexedDrawFirstElement = firstElement; +} + +void Renderer::SetIndexedDrawElementsCount( size_t elementsCount ) +{ + mIndexedDrawElementsCount = elementsCount; +} + void Renderer::EnablePreMultipliedAlpha( bool enable ) { mPremultipledAlphaEnabled = enable; @@ -491,7 +503,7 @@ void Renderer::Render( Context& context, mUpdateAttributesLocation = false; } - mRenderGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation ); + mRenderGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation, mIndexedDrawFirstElement, mIndexedDrawElementsCount ); } } diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h index 29ba663..d1cd70b 100644 --- a/dali/internal/render/renderers/render-renderer.h +++ b/dali/internal/render/renderers/render-renderer.h @@ -148,6 +148,18 @@ public: void SetBlendColor( const Vector4* color ); /** + * Set the first element index to draw by the indexed draw + * @param[in] firstElement index of first element to draw + */ + void SetIndexedDrawFirstElement( size_t firstElement ); + + /** + * Set the number of elements to draw by the indexed draw + * @param[in] elementsCount number of elements to draw + */ + void SetIndexedDrawElementsCount( size_t elementsCount ); + + /** * @brief Set whether the Pre-multiplied Alpha Blending is required * * @param[in] preMultipled whether alpha is pre-multiplied. @@ -260,6 +272,9 @@ private: BlendingOptions mBlendingOptions; /// Blending options including blend color, blend func and blend equation Dali::Renderer::FaceCullingMode mFaceCullingMode; /// Mode of face culling + size_t mIndexedDrawFirstElement; /// Offset of first element to draw + size_t mIndexedDrawElementsCount; /// Number of elements to draw + unsigned int mSamplerBitfield; ///< Sampler options used for texture filtering bool mUpdateAttributesLocation:1; ///< Indicates attribute locations have changed bool mPremultipledAlphaEnabled:1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required diff --git a/dali/internal/update/rendering/scene-graph-renderer.cpp b/dali/internal/update/rendering/scene-graph-renderer.cpp index 6514401..a464224 100644 --- a/dali/internal/update/rendering/scene-graph-renderer.cpp +++ b/dali/internal/update/rendering/scene-graph-renderer.cpp @@ -95,7 +95,9 @@ enum Flags RESEND_FACE_CULLING_MODE = 1 << 2, RESEND_BLEND_COLOR = 1 << 3, RESEND_BLEND_BIT_MASK = 1 << 4, - RESEND_PREMULTIPLIED_ALPHA = 1 << 5 + RESEND_PREMULTIPLIED_ALPHA = 1 << 5, + RESEND_INDEXED_DRAW_FIRST_ELEMENT = 1 << 6, + RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 7, }; } @@ -113,24 +115,26 @@ Renderer* Renderer::New() } Renderer::Renderer() -:mSceneController(0), - mRenderer(NULL), - mTextureSet(NULL), - mGeometry(NULL), - mShader(NULL), - mBlendColor(NULL), - mBlendBitmask(0u), +:mSceneController( 0 ), + mRenderer( NULL ), + mTextureSet( NULL ), + mGeometry( NULL ), + mShader( NULL ), + mBlendColor( NULL ), + mBlendBitmask( 0u ), mFaceCullingMode( Dali::Renderer::NONE ), mBlendingMode( Dali::BlendingMode::AUTO ), - mReferenceCount(0), - mRegenerateUniformMap(0), - mResendFlag(0), - mResourcesReady(false), - mFinishedResourceAcquisition(false), - mDepthIndex(0) -{ - mUniformMapChanged[0]=false; - mUniformMapChanged[1]=false; + mReferenceCount( 0 ), + mRegenerateUniformMap( 0 ), + mResendFlag( 0 ), + mResourcesReady( false ), + mFinishedResourceAcquisition( false ), + mIndexedDrawFirstElement( 0 ), + mIndexedDrawElementsCount( 0 ), + mDepthIndex( 0 ) +{ + mUniformMapChanged[0] = false; + mUniformMapChanged[1] = false; // Observe our own PropertyOwner's uniform map AddUniformMapObserver( *this ); @@ -280,6 +284,24 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex ) new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled ); mResendFlag &= ~RESEND_PREMULTIPLIED_ALPHA; } + + if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT ) + { + typedef MessageValue1< Render::Renderer, size_t > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement ); + mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT; + } + + if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT ) + { + typedef MessageValue1< Render::Renderer, size_t > DerivedType; + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount ); + mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT; + } + + } void Renderer::SetTextures( TextureSet* textureSet ) @@ -370,6 +392,18 @@ void Renderer::SetBlendColor( const Vector4& 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; diff --git a/dali/internal/update/rendering/scene-graph-renderer.h b/dali/internal/update/rendering/scene-graph-renderer.h index a9f64c1..890eb45 100644 --- a/dali/internal/update/rendering/scene-graph-renderer.h +++ b/dali/internal/update/rendering/scene-graph-renderer.h @@ -156,6 +156,18 @@ public: void SetBlendColor( const Vector4& blendColor ); /** + * Set the index of first element for indexed draw + * @param[in] firstElement index of first element to draw + */ + void SetIndexedDrawFirstElement( size_t firstElement ); + + /** + * Set the number of elements to draw by indexed draw + * @param[in] elementsCount number of elements to draw + */ + void SetIndexedDrawElementsCount( size_t elementsCount ); + + /** * @brief Set whether the Pre-multiplied Alpha Blending is required * * @param[in] preMultipled whether alpha is pre-multiplied. @@ -318,6 +330,9 @@ private: bool mFinishedResourceAcquisition; ///< Set during DoPrepareResources; true if ready & all resource acquisition has finished (successfully or otherwise) bool mPremultipledAlphaEnabled; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required + size_t mIndexedDrawFirstElement; ///< first element index to be drawn using indexed draw + size_t mIndexedDrawElementsCount; ///< number of elements to be drawn using indexed draw + public: int mDepthIndex; ///< Used only in PrepareRenderInstructions }; @@ -408,6 +423,26 @@ inline void SetBlendColorMessage( EventThreadServices& eventThreadServices, cons new (slot) LocalType( &renderer, &Renderer::SetBlendColor, blendColor ); } +inline void SetIndexedDrawFirstElementMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, size_t firstElement ) +{ + typedef MessageValue1< Renderer, size_t > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetIndexedDrawFirstElement, firstElement ); +} + +inline void SetIndexedDrawElementsCountMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, size_t elementsCount ) +{ + typedef MessageValue1< Renderer, size_t > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetIndexedDrawElementsCount, elementsCount ); +} + inline void SetEnablePreMultipliedAlphaMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, bool preMultiplied ) { typedef MessageValue1< Renderer, bool > LocalType;