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,
};
fragmentSource.append( customShaderWrappers[index].fragmentShaderPostfix );
}
- effect.SendProgramMessage( expectedGeometryType, SHADER_SUBTYPE_ALL, vertexSource, fragmentSource, modifiesGeometry );
+ effect.SendProgramMessage( expectedGeometryType, vertexSource, fragmentSource, modifiesGeometry );
}
}
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 )
{
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.
}
/**
* 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 );
{
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
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()
} // 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<GEOMETRY_TYPE_LAST>::value);
- for( unsigned int i = 0; i < Log<GEOMETRY_TYPE_LAST>::value; ++i)
- {
- mPrograms[ i ].Resize(SHADER_SUBTYPE_LAST);
- }
}
Shader::~Shader()
}
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,
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;
}
#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.
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<Program*> mSubPrograms; ///< The programs for each subtype
- bool mUseDefaultForAllSubtypes; ///< TRUE if the first program should be used for all subtypes
- };
-
- /**
* Constructor
* @param hints Geometry hints
*/
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,
/**
* 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
*/
/**
* 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
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.
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<ProgramContainer> mPrograms; ///< 2D array of Program*. Access by [Log<GEOMETRY_TYPE_XXX>::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
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" );
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 );
}
}
* 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.
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 )
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 );
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 );
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:
*
* @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
*/
* @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
*/
projects / platform / core / uifw / dali-core.git / commitdiff