From e6fd83ef385abeeee0a9f0202811a94216152f67 Mon Sep 17 00:00:00 2001 From: Andrew Cox Date: Mon, 1 Jun 2015 17:23:58 +0100 Subject: [PATCH] Remove multiple programs from SceneGraph::Shader Change-Id: Ib523cb7ce27be9689a3c54372c562f2ad9ee7606 Signed-off-by: Andrew Cox --- dali/internal/event/effects/shader-declarations.h | 11 +--- dali/internal/event/effects/shader-effect-impl.cpp | 8 +-- dali/internal/event/effects/shader-effect-impl.h | 3 +- dali/internal/event/effects/shader-factory.cpp | 34 +---------- dali/internal/event/effects/shader-impl.cpp | 2 +- .../internal/render/shaders/scene-graph-shader.cpp | 52 ++++------------ dali/internal/render/shaders/scene-graph-shader.h | 69 +++++----------------- dali/internal/update/manager/update-manager.cpp | 8 +-- dali/internal/update/manager/update-manager.h | 8 +-- dali/public-api/shader-effects/shader-effect.cpp | 2 + dali/public-api/shader-effects/shader-effect.h | 10 +++- 11 files changed, 52 insertions(+), 155 deletions(-) diff --git a/dali/internal/event/effects/shader-declarations.h b/dali/internal/event/effects/shader-declarations.h index 7dbca62..9806f37 100644 --- a/dali/internal/event/effects/shader-declarations.h +++ b/dali/internal/event/effects/shader-declarations.h @@ -33,16 +33,7 @@ namespace Internal enum ShaderSubTypes { SHADER_DEFAULT = 0, ///< Use default shader for geometry type - - // for mesh shader ///< Default shader is scene lit - SHADER_EVENLY_LIT = 1, - SHADER_RIGGED_AND_LIT, ///< Use rigged & scene lit - SHADER_RIGGED_AND_EVENLY_LIT, - SHADER_RIGGED_AND_VERTEX_COLOR, - SHADER_VERTEX_COLOR, ///< Use only vertex color - TOTAL_MESH_SHADERS, - - SHADER_SUBTYPE_LAST = TOTAL_MESH_SHADERS, + SHADER_SUBTYPE_LAST, SHADER_SUBTYPE_ALL = 0xFF, }; diff --git a/dali/internal/event/effects/shader-effect-impl.cpp b/dali/internal/event/effects/shader-effect-impl.cpp index 5e49a01..171a73f 100644 --- a/dali/internal/event/effects/shader-effect-impl.cpp +++ b/dali/internal/event/effects/shader-effect-impl.cpp @@ -173,7 +173,7 @@ void WrapAndSetProgram( Internal::ShaderEffect& effect, fragmentSource.append( customShaderWrappers[index].fragmentShaderPostfix ); } - effect.SendProgramMessage( expectedGeometryType, SHADER_SUBTYPE_ALL, vertexSource, fragmentSource, modifiesGeometry ); + effect.SendProgramMessage( expectedGeometryType, vertexSource, fragmentSource, modifiesGeometry ); } } @@ -334,7 +334,7 @@ void ShaderEffect::SetPrograms( GeometryType geometryType, WrapAndSetProgram( *this, geometryType, GEOMETRY_TYPE_UNTEXTURED_MESH, vertexPrefix, fragmentPrefix, vertexSource, fragmentSource, modifiesGeometry ); } -void ShaderEffect::SendProgramMessage( GeometryType geometryType, ShaderSubTypes subType, +void ShaderEffect::SendProgramMessage( GeometryType geometryType, const string& vertexSource, const string& fragmentSource, bool modifiesGeometry ) { @@ -344,10 +344,10 @@ void ShaderEffect::SendProgramMessage( GeometryType geometryType, ShaderSubTypes ResourceTicketPtr ticket( shaderFactory.Load(vertexSource, fragmentSource, shaderHash) ); - DALI_LOG_INFO( Debug::Filter::gShader, Debug::General, "ShaderEffect: SetProgram(geometryType %d subType:%d ticket.id:%d)\n", geometryType, subType, ticket->GetId() ); + DALI_LOG_INFO( Debug::Filter::gShader, Debug::General, "ShaderEffect: SetProgram(geometryType %d ticket.id:%d)\n", geometryType, ticket->GetId() ); // Add shader program to scene-object using a message to the UpdateManager - SetShaderProgramMessage( mEventThreadServices.GetUpdateManager(), *mSceneObject, geometryType, subType, ticket->GetId(), shaderHash, modifiesGeometry ); + SetShaderProgramMessage( mEventThreadServices.GetUpdateManager(), *mSceneObject, geometryType, ticket->GetId(), shaderHash, modifiesGeometry ); mTickets.push_back(ticket); // add ticket to collection to keep it alive. } diff --git a/dali/internal/event/effects/shader-effect-impl.h b/dali/internal/event/effects/shader-effect-impl.h index 249cbc8..6e9096f 100644 --- a/dali/internal/event/effects/shader-effect-impl.h +++ b/dali/internal/event/effects/shader-effect-impl.h @@ -112,12 +112,11 @@ public: /** * Send shader program to scene-graph object. * @param[in] geometryType The GeometryType rendered by the shader program - * @param[in] subType The subtype, one of ShaderSubTypes. * @param[in] vertexSource The source code for the vertex shader * @param[in] fragmentSource The source code for the fragment shader * @param[in] modifiesGeometry True if the shader modifies geometry */ - void SendProgramMessage( GeometryType geometryType, ShaderSubTypes subType, + void SendProgramMessage( GeometryType geometryType, const std::string& vertexSource, const std::string& fragmentSource, bool modifiesGeometry ); diff --git a/dali/internal/event/effects/shader-factory.cpp b/dali/internal/event/effects/shader-factory.cpp index 9d5fce1..a3b819c 100644 --- a/dali/internal/event/effects/shader-factory.cpp +++ b/dali/internal/event/effects/shader-factory.cpp @@ -118,39 +118,7 @@ void ShaderFactory::LoadDefaultShaders() { mDefaultShader = ShaderEffect::New(); - mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_IMAGE, SHADER_DEFAULT, ImageVertex, ImageFragment, false ); - - // Untextured meshes - mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_EVENLY_LIT, - UntexturedMeshVertex, - UntexturedMeshFragment, - false ); - - mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_RIGGED_AND_EVENLY_LIT, - std::string( SHADER_DEF_USE_BONES ) + UntexturedMeshVertex, - UntexturedMeshFragment, - true ); - - mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_RIGGED_AND_VERTEX_COLOR, - std::string( SHADER_DEF_USE_BONES SHADER_DEF_USE_COLOR ) + UntexturedMeshVertex, - std::string( SHADER_DEF_USE_COLOR ) + UntexturedMeshFragment, - true ); - - mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_UNTEXTURED_MESH, SHADER_VERTEX_COLOR, - std::string( SHADER_DEF_USE_COLOR ) + UntexturedMeshVertex, - std::string( SHADER_DEF_USE_COLOR ) + UntexturedMeshFragment, - false ); - - // Textured meshes - mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_TEXTURED_MESH, SHADER_EVENLY_LIT, - TexturedMeshVertex, - TexturedMeshFragment, - false ); - - mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_TEXTURED_MESH, SHADER_RIGGED_AND_EVENLY_LIT, - std::string( SHADER_DEF_USE_BONES ) + TexturedMeshVertex, - TexturedMeshFragment, - true ); + mDefaultShader->SendProgramMessage( GEOMETRY_TYPE_IMAGE, ImageVertex, ImageFragment, false ); } } // namespace Internal diff --git a/dali/internal/event/effects/shader-impl.cpp b/dali/internal/event/effects/shader-impl.cpp index c6b49c6..73817c9 100644 --- a/dali/internal/event/effects/shader-impl.cpp +++ b/dali/internal/event/effects/shader-impl.cpp @@ -278,7 +278,7 @@ void Shader::Initialize( mTicket = ResourceTicketPtr( shaderFactory.Load(vertexSource, fragmentSource, shaderHash) ); // Add shader program to scene-object using a message to the UpdateManager - SetShaderProgramMessage( updateManager, *mSceneObject, GEOMETRY_TYPE_IMAGE, SHADER_SUBTYPE_ALL, mTicket->GetId(), shaderHash, false ); + SetShaderProgramMessage( updateManager, *mSceneObject, GEOMETRY_TYPE_IMAGE, mTicket->GetId(), shaderHash, false ); } Shader::~Shader() diff --git a/dali/internal/render/shaders/scene-graph-shader.cpp b/dali/internal/render/shaders/scene-graph-shader.cpp index 2aee2b3..fed282e 100644 --- a/dali/internal/render/shaders/scene-graph-shader.cpp +++ b/dali/internal/render/shaders/scene-graph-shader.cpp @@ -98,23 +98,16 @@ inline unsigned int GetGeometryTypeIndex(GeometryType type) } // unnamed namespace - - Shader::Shader( Dali::ShaderEffect::GeometryHints& hints ) : mGeometryHints( hints ), mGridDensity( Dali::ShaderEffect::DEFAULT_GRID_DENSITY ), mTexture( NULL ), mRenderTextureId( 0 ), mUpdateTextureId( 0 ), - mRenderQueue(NULL), - mTextureCache(NULL) + mProgram( NULL ), + mRenderQueue( NULL ), + mTextureCache( NULL ) { - // Create enough size for all default types and sub-types - mPrograms.resize(Log::value); - for( unsigned int i = 0; i < Log::value; ++i) - { - mPrograms[ i ].Resize(SHADER_SUBTYPE_LAST); - } } Shader::~Shader() @@ -236,42 +229,22 @@ void Shader::SetCoordinateTypeInRender( unsigned int index, Dali::ShaderEffect:: } void Shader::SetProgram( GeometryType geometryType, - ShaderSubTypes subType, Integration::ResourceId resourceId, Integration::ShaderDataPtr shaderData, ProgramCache* programCache, bool modifiesGeometry ) { - DALI_LOG_TRACE_METHOD_FMT(Debug::Filter::gShader, "%d %d\n", (int)geometryType, resourceId); - - Program* program = Program::New( *programCache, shaderData, modifiesGeometry ); - - ShaderSubTypes theSubType = subType; - if( subType == SHADER_SUBTYPE_ALL ) - { - theSubType = SHADER_DEFAULT; - } + DALI_LOG_TRACE_METHOD_FMT(Debug::Filter::gShader, "%d\n", resourceId); - const unsigned int geometryIndex = GetGeometryTypeIndex( geometryType ); - if(subType == SHADER_SUBTYPE_ALL) - { - mPrograms[geometryIndex].Resize(1); - mPrograms[geometryIndex][theSubType] = program; - mPrograms[geometryIndex].mUseDefaultForAllSubtypes = true; - } - else - { - mPrograms[geometryIndex][theSubType] = program; - mPrograms[geometryIndex].mUseDefaultForAllSubtypes = false; - } + mProgram = Program::New( *programCache, shaderData, modifiesGeometry ); + // Implement: mProgram = programCache->GetProgram( shaderData, modifiesGeometry ); + // The program cache owns the Program object so we don't need to worry here. } bool Shader::AreSubtypesRequired(GeometryType geometryType) { DALI_ASSERT_DEBUG(geometryType < GEOMETRY_TYPE_LAST); - unsigned int programType = GetGeometryTypeIndex( geometryType ); - - return ! mPrograms[ programType ].mUseDefaultForAllSubtypes; + return false; } Program* Shader::GetProgram( Context& context, @@ -282,11 +255,12 @@ Program* Shader::GetProgram( Context& context, DALI_ASSERT_DEBUG(type < GEOMETRY_TYPE_LAST); DALI_DEBUG_OSTREAM(debugStream); - programIndex = GetGeometryTypeIndex( type ); - - DALI_ASSERT_DEBUG((unsigned int)subType < mPrograms[ programIndex ].Count()); + return mProgram; +} - return mPrograms[ programIndex ][ subType ]; +Program* Shader::GetProgram() +{ + return mProgram; } diff --git a/dali/internal/render/shaders/scene-graph-shader.h b/dali/internal/render/shaders/scene-graph-shader.h index b0653c6..1c88575 100644 --- a/dali/internal/render/shaders/scene-graph-shader.h +++ b/dali/internal/render/shaders/scene-graph-shader.h @@ -2,7 +2,7 @@ #define __DALI_INTERNAL_SCENE_GRAPH_SHADER_H__ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2014-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. @@ -67,55 +67,6 @@ class Shader : public PropertyOwner public: /** - * This container contains pointers to the programs for each sub-type of a given geometry type. - * If a custom shader has overridden the subtypes (e.g. mesh custom shader), - * then the flag is used to indicate that there is only one shader in the - * vector that should be used. - * Note, it does not own the Programs it contains. - */ - struct ProgramContainer - { - public: - /** - * Constructor - */ - ProgramContainer() - : mUseDefaultForAllSubtypes(false) - { - } - - /** - * Array lookup - * @param[in] position The array index - */ - Program*& operator[]( size_t position ) - { - return mSubPrograms[position]; - } - - /** - * Resize the container - * @param[in] length The new size of the container - */ - void Resize(size_t length) - { - mSubPrograms.Resize( length, NULL ); - } - - /** - * Get the number of elements in the container - * @return count of the number of elements in the container - */ - size_t Count() const - { - return mSubPrograms.Count(); - } - - Dali::Vector mSubPrograms; ///< The programs for each subtype - bool mUseDefaultForAllSubtypes; ///< TRUE if the first program should be used for all subtypes - }; - - /** * Constructor * @param hints Geometry hints */ @@ -287,16 +238,15 @@ public: void SetCoordinateTypeInRender( unsigned int index, Dali::ShaderEffect::UniformCoordinateType type ); /** - * Set the program for a geometry type and subtype + * @brief Set the program for a geometry type. * @param[in] geometryType The type of the object (geometry) that is to be rendered. - * @param[in] subType The subtype, one of ShaderSubTypes. * @param[in] resourceId The resource ID for the program. * @param[in] shaderData The program's vertex/fragment source and optionally compiled bytecode * @param[in] programCache Owner of the Programs * @param[in] modifiesGeometry True if the vertex shader changes geometry */ - void SetProgram( GeometryType geometryType, - Internal::ShaderSubTypes subType, + void SetProgram( /** @deprecated This is currently ignored and will soon disappear. */ + GeometryType geometryType, Integration::ResourceId resourceId, Integration::ShaderDataPtr shaderData, ProgramCache* programCache, @@ -304,6 +254,7 @@ public: /** * Determine if subtypes are required for the given geometry type + * @deprecated * @param[in] geometryType The type of the object (geometry) that is to be rendered. * @return TRUE if subtypes are required, FALSE if there is only one subtype available */ @@ -311,6 +262,7 @@ public: /** * Get the program associated with the given type and subtype + * @deprecated * @param[in] context the context used to render. * @param[in] type the type of the object (geometry) that is being rendered. * @param[in] subType Identifier for geometry types with specialised default shaders @@ -323,6 +275,13 @@ public: unsigned int& programIndex ); /** + * Get the program built for this shader + * @deprecated + * @return the program to use. + */ + Program* GetProgram(); + + /** * Sets the shader specific uniforms including custom uniforms * @pre The shader has been initialized. * @pre This method is not thread-safe, and should only be called from the render-thread. @@ -346,7 +305,7 @@ private: // Data Integration::ResourceId mRenderTextureId; ///< Copy of the texture ID for the render thread Integration::ResourceId mUpdateTextureId; ///< Copy of the texture ID for update thread - std::vector mPrograms; ///< 2D array of Program*. Access by [Log::value][index]. An index of 0 selects the default program for that geometry type. + Program* mProgram; typedef OwnerContainer< UniformMeta* > UniformMetaContainer; UniformMetaContainer mUniformMetadata; ///< A container of owned UniformMeta values; one for each property in PropertyOwner::mDynamicProperties diff --git a/dali/internal/update/manager/update-manager.cpp b/dali/internal/update/manager/update-manager.cpp index d564481..e106262 100644 --- a/dali/internal/update/manager/update-manager.cpp +++ b/dali/internal/update/manager/update-manager.cpp @@ -613,9 +613,9 @@ void UpdateManager::RemoveShader( Shader* shader ) DALI_ASSERT_DEBUG(false); } -void UpdateManager::SetShaderProgram( Shader* shader, GeometryType geometryType, ShaderSubTypes subType, ResourceId resourceId, size_t shaderHash, bool modifiesGeometry ) +void UpdateManager::SetShaderProgram( Shader* shader, GeometryType geometryType, ResourceId resourceId, size_t shaderHash, bool modifiesGeometry ) { - DALI_LOG_TRACE_METHOD_FMT(Debug::Filter::gShader, " - (geometryType:%d subType:%d id:%d hash:%d)\n", geometryType, subType, resourceId, shaderHash); + DALI_LOG_TRACE_METHOD_FMT(Debug::Filter::gShader, " - (geometryType:%d id:%d hash:%d)\n", geometryType, resourceId, shaderHash); DALI_ASSERT_ALWAYS( NULL != shader && "shader is uninitialized" ); @@ -625,13 +625,13 @@ void UpdateManager::SetShaderProgram( Shader* shader, GeometryType geometryType, shaderData->SetHashValue( shaderHash ); shaderData->SetResourceId( resourceId ); - typedef MessageValue6< Shader, GeometryType, Internal::ShaderSubTypes, Integration::ResourceId, Integration::ShaderDataPtr, ProgramCache*, bool> DerivedType; + typedef MessageValue5< Shader, GeometryType, Integration::ResourceId, Integration::ShaderDataPtr, ProgramCache*, bool> DerivedType; // Reserve some memory inside the render queue unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( shader, &Shader::SetProgram, geometryType, subType, resourceId, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry ); + new (slot) DerivedType( shader, &Shader::SetProgram, geometryType, resourceId, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry ); } } diff --git a/dali/internal/update/manager/update-manager.h b/dali/internal/update/manager/update-manager.h index 803573e..da8a493 100644 --- a/dali/internal/update/manager/update-manager.h +++ b/dali/internal/update/manager/update-manager.h @@ -309,12 +309,11 @@ public: * Set the shader program for a specified GeometryType to a Shader object * @param[in] shader The shader to modify * @param[in] geometryType The GeometryType to map to the program - * @param[in] subType The program subtype * @param[in] resourceId A ResourceManager ticket ID for the program data (source and compiled binary) * @param[in] shaderHash hash key created with vertex and fragment shader code * @param[in] modifiesGeometry True if the vertex shader modifies geometry */ - void SetShaderProgram( Shader* shader, GeometryType geometryType, ShaderSubTypes subType, Integration::ResourceId resourceId, size_t shaderHash, bool modifiesGeometry ); + void SetShaderProgram( Shader* shader, GeometryType geometryType, Integration::ResourceId resourceId, size_t shaderHash, bool modifiesGeometry ); /** * Add a newly created gesture. @@ -729,18 +728,17 @@ inline void RemoveShaderMessage( UpdateManager& manager, Shader& shader ) inline void SetShaderProgramMessage( UpdateManager& manager, Shader& shader, GeometryType geometryType, - ShaderSubTypes subType, Integration::ResourceId resourceId, size_t shaderHash, bool modifiesGeometry ) { - typedef MessageValue6< UpdateManager, Shader*, GeometryType, ShaderSubTypes, Integration::ResourceId, size_t, bool > LocalType; + typedef MessageValue5< UpdateManager, Shader*, GeometryType, Integration::ResourceId, size_t, bool > 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::SetShaderProgram, &shader, geometryType, subType, resourceId, shaderHash, modifiesGeometry ); + new (slot) LocalType( &manager, &UpdateManager::SetShaderProgram, &shader, geometryType, resourceId, shaderHash, modifiesGeometry ); } inline void SetBackgroundColorMessage( UpdateManager& manager, const Vector4& color ) diff --git a/dali/public-api/shader-effects/shader-effect.cpp b/dali/public-api/shader-effects/shader-effect.cpp index 9f1ff9c..e639ce6 100644 --- a/dali/public-api/shader-effects/shader-effect.cpp +++ b/dali/public-api/shader-effects/shader-effect.cpp @@ -62,6 +62,7 @@ ShaderEffect& ShaderEffect::operator=(const ShaderEffect& rhs) ShaderEffect ShaderEffect::New( const std::string& vertexShader, const std::string& fragmentShader, GeometryType type, GeometryHints hints) { + // @todo MESH_REWORK - Assert only image geometry type is passed. Internal::ShaderEffectPtr internal = Internal::ShaderEffect::New( hints ); internal->SetPrograms( type, vertexShader, fragmentShader ); @@ -76,6 +77,7 @@ ShaderEffect ShaderEffect::NewWithPrefix( const std::string& vertexShaderPrefix, GeometryType type, GeometryHints hints) { + // @todo MESH_REWORK - Assert only image geometry type is passed. Internal::ShaderEffectPtr internal = Internal::ShaderEffect::New( hints ); internal->SetPrograms( type, vertexShaderPrefix, fragmentShaderPrefix, vertexShader, fragmentShader ); diff --git a/dali/public-api/shader-effects/shader-effect.h b/dali/public-api/shader-effects/shader-effect.h index 0310d59..a779883 100644 --- a/dali/public-api/shader-effects/shader-effect.h +++ b/dali/public-api/shader-effects/shader-effect.h @@ -69,11 +69,15 @@ enum GeometryType GEOMETRY_TYPE_UNTEXTURED_MESH = 0x02, ///< Complex meshes, with flat color GEOMETRY_TYPE_TEXTURED_MESH = 0x04, ///< Complex meshes, with texture GEOMETRY_TYPE_LAST = 0x08 + // @todo MESH_REWORK - Remove these geometry types. }; /** * @brief Shader effects provide a visual effect for actors. * + * @deprecated Use classes Dali::Shader, Dali::Material, and Dali::Sampler to implement + * any new programmable shading effects. + * * For a Custom shader you can provide the vertex and fragment shader code as strings. * These shader snippets get concatenated with the default attributes and uniforms. * For a vertex shader this part contains the following code: @@ -206,7 +210,8 @@ public: * * @param vertexShader code for the effect. If you pass in an empty string, the default version will be used * @param fragmentShader code for the effect. If you pass in an empty string, the default version will be used - * @param type GeometryType to define the shape of the geometry + * @param type GeometryType to define the shape of the geometry. Only GEOMETRY_TYPE_IMAGE is accepted for this + * parameter. Any other value will lead to an error. * @param hints GeometryHints to define the geometry of the rendered object * @return A handle to a shader effect */ @@ -221,7 +226,8 @@ public: * @param vertexShader code for the effect. If you pass in an empty string, the default version will be used * @param fragmentShaderPrefix code for the effect. It will be inserted before the default uniforms (ideal for \#defines) * @param fragmentShader code for the effect. If you pass in an empty string, the default version will be used - * @param type GeometryType to define the shape of the geometry + * @param type GeometryType to define the shape of the geometry. Only GEOMETRY_TYPE_IMAGE is accepted for this + * parameter. Any other value will lead to an error. * @param hints GeometryHints to define the geometry of the rendered object * @return A handle to a shader effect */ -- 2.7.4