}
-
-template< typename T>
-ConstraintBase* CreateEqualConstraint(Object& target, Property::Index index, Internal::SourceContainer& sources )
-{
- typedef typename Dali::Internal::PropertyConstraintPtr< T >::Type PropertyConstraintPtrType;
-
- CallbackBase* callback = new Dali::Constraint::Function< T >( EqualToConstraint() );
- PropertyConstraintPtrType funcPtr( new Internal::PropertyConstraint< T >( reinterpret_cast< Dali::Constraint::Function< T >* >( callback ) ) );
-
- return Internal::Constraint< T >::New( target, index, sources, funcPtr );
-}
-
const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
attribute mediump vec3 aPosition;\n
attribute mediump vec2 aTexCoord;\n
unsigned int gridHeight = 1;
if( mShaderEffect )
{
- Dali::ShaderEffect::GeometryHints hints = mShaderEffect->GetGeometryHints();
- Property::Value gridDensityValue = mShaderEffect->GetDefaultProperty( Dali::ShaderEffect::Property::GRID_DENSITY );
- int gridDensity = Dali::ShaderEffect::DEFAULT_GRID_DENSITY;
- gridDensityValue.Get( gridDensity );
-
- if( ( hints & Dali::ShaderEffect::HINT_GRID_X ) )
- {
- gridWidth = size.width / gridDensity;
- }
- if( ( hints & Dali::ShaderEffect::HINT_GRID_Y ) )
- {
- gridHeight = size.height / gridDensity;
- }
+ Vector2 gridSize = mShaderEffect->GetGridSize( size );
//limit the grid size
- gridWidth = std::min( MAXIMUM_GRID_SIZE, gridWidth );
- gridHeight = std::min( MAXIMUM_GRID_SIZE, gridHeight );
+ gridWidth = std::min( MAXIMUM_GRID_SIZE, static_cast<unsigned int>(gridSize.width) );
+ gridHeight = std::min( MAXIMUM_GRID_SIZE, static_cast<unsigned int>(gridSize.height) );
}
unsigned int imageWidth = 1u;
imageHeight = image->GetHeight();
}
- GeometryPtr quad = gridWidth <= 1 && gridHeight <= 1 ?
- CreateQuadGeometry( size, imageWidth, imageHeight, mPixelArea ) :
- CreateGridGeometry( size, gridWidth, gridHeight, imageWidth, imageHeight, mPixelArea );
+ GeometryPtr geometry = gridWidth <= 1 && gridHeight <= 1 ?
+ CreateQuadGeometry( size, imageWidth, imageHeight, mPixelArea ) :
+ CreateGridGeometry( size, gridWidth, gridHeight, imageWidth, imageHeight, mPixelArea );
- mRenderer->SetGeometry( *quad );
+ mRenderer->SetGeometry( *geometry );
Vector4 textureRect( 0.f, 0.f, 1.f, 1.f );
if( mIsPixelAreaSet && image )
}
Material* material = mRenderer->GetMaterial();
- Property::Index index = material->GetPropertyIndex( "sTextureRect" );
- if( index != Property::INVALID_INDEX )
- {
- material->SetProperty( index, textureRect );
- }
- else
- {
- material->RegisterProperty( "sTextureRect", textureRect );
- }
+ material->RegisterProperty( "sTextureRect", textureRect );
}
unsigned int ImageActor::GetDefaultPropertyCount() const
mShaderEffect = ShaderEffectPtr( &effect );
effect.Connect( this );
- Dali::ShaderEffect::GeometryHints hints = effect.GetGeometryHints();
-
- int shaderHints = Dali::Shader::HINT_NONE;
-
- if( hints & Dali::ShaderEffect::HINT_DEPTH_BUFFER )
- {
- shaderHints |= Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST;
- }
- if( hints & Dali::ShaderEffect::HINT_BLENDING )
- {
- shaderHints |= Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT;
- }
- if( !(hints & Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY) )
- {
- shaderHints |= Dali::Shader::HINT_MODIFIES_GEOMETRY;
- }
-
- ShaderPtr shader = Shader::New( effect.GetVertexShader(), effect.GetFragmentShader(), static_cast< Dali::Shader::ShaderHints >( shaderHints ) );
+ ShaderPtr shader = mShaderEffect->GetShader();
mRenderer->GetMaterial()->SetShader( *shader );
- //get the uniforms and apply them to the renderer
- const ShaderEffect::UniformArray& uniforms = mShaderEffect->GetUniforms();
- for( ShaderEffect::UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it )
- {
- const ShaderEffect::Uniform& uniform = *it;
- EffectUniformUpdated( uniform );
- }
-
- if( mShaderEffect->GetEffectImage() )
- {
- EffectImageUpdated();
- }
-}
-
-void ImageActor::EffectUniformUpdated( const ShaderEffect::Uniform& uniform )
-{
- if( !mShaderEffect )
- {
- return;
- }
-
- Shader* shader = mRenderer->GetMaterial()->GetShader();
-
- Property::Index index = shader->GetPropertyIndex( uniform.mName );
- if( index == Property::INVALID_INDEX )
- {
- index = shader->RegisterProperty( uniform.mName, uniform.mValue );
-
- //Constrain the shader's uniform properties to the ShaderEffect properties
- Internal::ConstraintBase* constraint = NULL;
- Internal::SourceContainer sources;
-
- switch( uniform.mValue.GetType() )
- {
- case Property::INTEGER:
- case Property::FLOAT:
- {
- constraint = CreateEqualConstraint< float >(*shader, index, sources );
- break;
- }
- case Property::VECTOR2:
- {
- constraint = CreateEqualConstraint< Vector2 >(*shader, index, sources );
- break;
- }
- case Property::VECTOR3:
- {
- constraint = CreateEqualConstraint< Vector3 >(*shader, index, sources );
- break;
- }
- case Property::VECTOR4:
- {
- constraint = CreateEqualConstraint< Vector4 >(*shader, index, sources );
- break;
- }
- case Property::MATRIX3:
- {
- constraint = CreateEqualConstraint< Matrix3 >(*shader, index, sources );
- break;
- }
- case Property::MATRIX:
- {
- constraint = CreateEqualConstraint< Matrix >(*shader, index, sources );
- break;
- }
- case Property::BOOLEAN:
- case Property::ARRAY:
- case Property::ROTATION:
- case Property::STRING:
- case Property::RECTANGLE:
- case Property::MAP:
- case Property::NONE:
- //not supported
- break;
- }
-
- //constrain the renderers property to the ShaderEffect
- if( constraint )
- {
- Source source;
- source.sourceType = OBJECT_PROPERTY;
- source.propertyIndex = uniform.mIndex;
- source.object = mShaderEffect.Get();
-
- constraint->AddSource( source );
- constraint->Apply();
- }
- }
- else
- {
- shader->SetProperty( index, uniform.mValue );
- }
+ EffectImageUpdated();
}
ShaderEffectPtr ImageActor::GetShaderEffect() const
{
mShaderEffect->Disconnect( this );
- Dali::ShaderEffect::GeometryHints hints = mShaderEffect->GetGeometryHints();
- if( ( hints & Dali::ShaderEffect::HINT_GRID_X ) ||
- ( hints & Dali::ShaderEffect::HINT_GRID_Y ) )
+ if( mShaderEffect->GetGridSize( Vector2(INFINITY, INFINITY) ) != Vector2::ONE )
{
RelayoutRequest();
}
void GetFilterMode( FilterMode::Type& minFilter, FilterMode::Type& magFilter ) const;
/**
- * @brief Allows this ImageActor to respond to the event that the a shader effect's uniform has updated
- *
- * @param[in] uniform The shader effect uniform that has been updated
- */
- void EffectUniformUpdated( const ShaderEffect::Uniform& uniform );
-
- /**
* @brief Allows this ImageActor to respond to the eventa that the shader effect's effect texture has been changed
*/
void EffectImageUpdated();
// CLASS HEADER
#include <dali/internal/event/effects/shader-effect-impl.h>
+// EXTERNAL INCLUDES
+#include <cstring> // for strcmp
+
// INTERNAL INCLUDES
#include <dali/public-api/math/matrix.h>
#include <dali/public-api/math/matrix3.h>
#include <dali/public-api/shader-effects/shader-effect.h>
#include <dali/internal/event/actors/image-actor-impl.h>
#include <dali/internal/event/common/property-helper.h>
-#include <dali/internal/event/common/stage-impl.h>
-#include <dali/internal/event/common/thread-local-storage.h>
-#include <dali/internal/event/effects/shader-declarations.h>
-#include <dali/internal/event/effects/shader-factory.h>
#include <dali/internal/event/images/image-impl.h>
-#include <dali/internal/render/shaders/scene-graph-shader.h>
-#include <dali/internal/render/shaders/uniform-meta.h>
-#include <dali/internal/update/animation/scene-graph-constraint-base.h>
-#include <dali/internal/update/common/animatable-property.h>
-#include <dali/internal/update/manager/update-manager.h>
#include "dali-shaders.h"
-using Dali::Internal::SceneGraph::UpdateManager;
-using Dali::Internal::SceneGraph::UniformMeta;
-using Dali::Internal::SceneGraph::Shader;
-using Dali::Internal::SceneGraph::AnimatableProperty;
-using Dali::Internal::SceneGraph::PropertyBase;
-using Dali::Internal::SceneGraph::RenderQueue;
using std::string;
namespace Dali
return fragmentSource;
}
-std::string GetShader(const std::string& field, const Property::Value& property)
+std::string GetStringProperty(const std::string& field, const Property::Value& property)
{
std::string retval;
const Property::Map* map = property.GetMap();
return retval;
}
-} // unnamed namespace
-
-ShaderEffectPtr ShaderEffect::New( Dali::ShaderEffect::GeometryHints hints )
+Dali::Shader::ShaderHints ConvertHints( Dali::ShaderEffect::GeometryHints hints)
{
- Stage* stage = Stage::GetCurrent();
-
- if( stage )
+ int convertedHints = Dali::Shader::HINT_NONE;
+ if( hints & Dali::ShaderEffect::HINT_DEPTH_BUFFER )
{
- ShaderEffectPtr shaderEffect( new ShaderEffect( *stage, hints ) );
- shaderEffect->RegisterObject();
- return shaderEffect;
+ convertedHints |= Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST;
}
- else
+ if( hints & Dali::ShaderEffect::HINT_BLENDING )
+ {
+ convertedHints |= Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT;
+ }
+ if( !(hints & Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY) )
{
- return NULL;
+ convertedHints |= Dali::Shader::HINT_MODIFIES_GEOMETRY;
}
+
+ return Dali::Shader::ShaderHints( convertedHints );
}
-ShaderEffect::ShaderEffect( EventThreadServices& eventThreadServices, Dali::ShaderEffect::GeometryHints hints )
-: mEventThreadServices( eventThreadServices ),
- mGeometryHints( hints ),
- mGridDensity( Dali::ShaderEffect::DEFAULT_GRID_DENSITY )
+} // unnamed namespace
+
+ShaderEffectPtr ShaderEffect::New( Dali::ShaderEffect::GeometryHints hints )
{
- mSceneObject = new SceneGraph::Shader( hints );
- DALI_ASSERT_DEBUG( NULL != mSceneObject );
+ ShaderEffectPtr shaderEffect( new ShaderEffect( hints ) );
+ shaderEffect->RegisterObject();
+ return shaderEffect;
+}
- // Transfer shader ownership to a scene message
- AddShaderMessage( eventThreadServices.GetUpdateManager(), *mSceneObject );
+ShaderEffect::ShaderEffect( Dali::ShaderEffect::GeometryHints hints )
+: mGridDensity( Dali::ShaderEffect::DEFAULT_GRID_DENSITY ),
+ mGeometryHints( hints )
+{
}
ShaderEffect::~ShaderEffect()
{
// Guard to allow handle destruction after Core has been destroyed
- if ( Stage::IsInstalled() )
- {
- // Remove scene-object using a message to the UpdateManager
- if( mSceneObject )
- {
- RemoveShaderMessage( mEventThreadServices.GetUpdateManager(), *mSceneObject );
- }
- UnregisterObject();
- }
+ UnregisterObject();
}
void ShaderEffect::SetEffectImage( Dali::Image image )
void ShaderEffect::SetUniform( const std::string& name, Property::Value value, UniformCoordinateType uniformCoordinateType )
{
// Register the property if it does not exist
- Property::Index index = RegisterProperty( name, value );
-
- Uniform uniform = { name, index, value };
- mUniforms.push_back( uniform );
-
- //inform any connected actors
- for(std::vector< ActorPtr >::iterator it = mConnectedActors.begin(); it != mConnectedActors.end(); ++it)
- {
- ImageActor* imageActor = dynamic_cast< ImageActor* >( (*it).Get() );
- if( imageActor )
- {
- imageActor->EffectUniformUpdated( uniform );
- }
- }
+ mShader->RegisterProperty( name, value );
}
void ShaderEffect::SetPrograms( const string& vertexSource, const string& fragmentSource )
void ShaderEffect::SetPrograms( const std::string& vertexPrefix, const std::string& fragmentPrefix,
const std::string& vertexSource, const std::string& fragmentSource )
{
- mVertexSource = WrapVertexShader( vertexPrefix, vertexSource );
- mFragmentSource = WrapFragmentShader( fragmentPrefix, fragmentSource );
+ mShader = Shader::New( WrapVertexShader( vertexPrefix, vertexSource ),
+ WrapFragmentShader( fragmentPrefix, fragmentSource ),
+ ConvertHints( mGeometryHints ) );
+}
+
+Vector2 ShaderEffect::GetGridSize( const Vector2& size )
+{
+ Vector2 gridSize( 1.f, 1.f );
+
+ if( mGridDensity > 0 )
+ {
+ if( ( mGeometryHints & Dali::ShaderEffect::HINT_GRID_X ) )
+ {
+ gridSize.x = ceil( size.width / mGridDensity );
+ }
+ if( ( mGeometryHints & Dali::ShaderEffect::HINT_GRID_Y ) )
+ {
+ gridSize.y = ceil( size.height / mGridDensity );
+ }
+ }
+
+ return gridSize;
}
void ShaderEffect::Connect( ActorPtr actor )
}
}
+unsigned int ShaderEffect::GetPropertyCount() const
+{
+ return GetDefaultPropertyCount() + mShader->GetPropertyCount();
+}
+
+std::string ShaderEffect::GetPropertyName( Property::Index index ) const
+{
+ if ( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return GetDefaultPropertyName( index );
+ }
+ else
+ {
+ return mShader->GetPropertyName( index );
+ }
+}
+
+Property::Index ShaderEffect::GetPropertyIndex( const std::string& name ) const
+{
+ Property::Index index = GetDefaultPropertyIndex( name );
+ if( index == Property::INVALID_INDEX )
+ {
+ return mShader->GetPropertyIndex( name );
+ }
+ else
+ {
+ return index;
+ }
+}
+
+bool ShaderEffect::IsPropertyWritable( Property::Index index ) const
+{
+ if ( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return IsDefaultPropertyWritable( index );
+ }
+ else
+ {
+ return mShader->IsPropertyWritable( index );
+ }
+}
+
+bool ShaderEffect::IsPropertyAnimatable( Property::Index index ) const
+{
+ if ( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return IsDefaultPropertyAnimatable( index );
+ }
+ else
+ {
+ return mShader->IsPropertyAnimatable( index );
+ }
+}
+
+bool ShaderEffect::IsPropertyAConstraintInput( Property::Index index ) const
+{
+ if ( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return IsDefaultPropertyAConstraintInput( index );
+ }
+ else
+ {
+ return mShader->IsPropertyAConstraintInput( index );
+ }
+}
+
+Property::Type ShaderEffect::GetPropertyType( Property::Index index ) const
+{
+ if ( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return GetDefaultPropertyType( index );
+ }
+ return mShader->GetPropertyType( index );
+}
+
+void ShaderEffect::SetProperty( Property::Index index, const Property::Value& propertyValue )
+{
+ if ( index < DEFAULT_PROPERTY_COUNT )
+ {
+ SetDefaultProperty( index, propertyValue );
+ }
+ else
+ {
+ mShader->SetProperty( index, propertyValue );
+ }
+}
+
+Property::Value ShaderEffect::GetProperty( Property::Index index ) const
+{
+ if ( index < DEFAULT_PROPERTY_COUNT )
+ {
+ return GetDefaultProperty( index );
+ }
+ return mShader->GetProperty( index );
+}
+
+void ShaderEffect::GetPropertyIndices( Property::IndexContainer& indices ) const
+{
+ mShader->GetPropertyIndices( indices );
+ GetDefaultPropertyIndices( indices );
+}
+
+Property::Index ShaderEffect::RegisterProperty( const std::string& name, const Property::Value& propertyValue )
+{
+ return mShader->RegisterProperty( name, propertyValue );
+}
+
+Property::Index ShaderEffect::RegisterProperty( const std::string& name, const Property::Value& propertyValue, Property::AccessMode accessMode )
+{
+ return mShader->RegisterProperty( name, propertyValue, accessMode );
+}
+
+Dali::PropertyNotification ShaderEffect::AddPropertyNotification( Property::Index index,
+ int componentIndex,
+ const Dali::PropertyCondition& condition )
+{
+ return mShader->AddPropertyNotification( index, componentIndex, condition );
+}
+
+void ShaderEffect::RemovePropertyNotification( Dali::PropertyNotification propertyNotification )
+{
+ mShader->RemovePropertyNotification( propertyNotification );
+}
+
+void ShaderEffect::RemovePropertyNotifications()
+{
+ mShader->RemovePropertyNotifications();
+}
+
unsigned int ShaderEffect::GetDefaultPropertyCount() const
{
return DEFAULT_PROPERTY_COUNT;
void ShaderEffect::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
{
- indices.Reserve( DEFAULT_PROPERTY_COUNT );
+ indices.Reserve( indices.Size() + DEFAULT_PROPERTY_COUNT );
for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
case Dali::ShaderEffect::Property::PROGRAM:
{
- std::string vertexPrefix = GetShader("vertexPrefix", propertyValue);
- std::string fragmentPrefix = GetShader("fragmentPrefix", propertyValue);
- std::string vertex = GetShader("vertex", propertyValue);
- std::string fragment = GetShader("fragment", propertyValue);
+ std::string vertexPrefix = GetStringProperty("vertexPrefix", propertyValue);
+ std::string fragmentPrefix = GetStringProperty("fragmentPrefix", propertyValue);
+ std::string vertex = GetStringProperty("vertex", propertyValue);
+ std::string fragment = GetStringProperty("fragment", propertyValue);
SetPrograms( vertexPrefix, fragmentPrefix, vertex, fragment );
break;
const SceneGraph::PropertyOwner* ShaderEffect::GetSceneObject() const
{
- return mSceneObject;
+ return mShader->GetSceneObject();
}
-const PropertyBase* ShaderEffect::GetSceneObjectAnimatableProperty( Property::Index index ) const
+const SceneGraph::PropertyBase* ShaderEffect::GetSceneObjectAnimatableProperty( Property::Index index ) const
{
- PropertyMetadata* property = index >= PROPERTY_CUSTOM_START_INDEX ? static_cast<PropertyMetadata*>(FindCustomProperty( index )) : static_cast<PropertyMetadata*>(FindAnimatableProperty( index ));
- DALI_ASSERT_ALWAYS( property && "Property index is invalid" );
- return property->GetSceneGraphProperty();
+ return mShader->GetSceneObjectAnimatableProperty( index );
}
const PropertyInputImpl* ShaderEffect::GetSceneObjectInputProperty( Property::Index index ) const
{
- return GetSceneObjectAnimatableProperty( index );
+ return mShader->GetSceneObjectInputProperty( index );
+}
+
+int ShaderEffect::GetPropertyComponentIndex( Property::Index index ) const
+{
+ return mShader->GetPropertyComponentIndex( index );
}
} // namespace Internal
#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/effects/shader-declarations.h>
#include <dali/internal/event/common/object-impl.h>
-#include <dali/internal/event/resources/resource-ticket.h>
-#include <dali/internal/render/shaders/scene-graph-shader.h>
+#include <dali/internal/event/rendering/shader-impl.h>
namespace Dali
{
namespace Internal
{
-namespace SceneGraph
-{
-class UpdateManager;
-}
-
/**
* An abstract base class for a shader effect object.
* The corresponding scene-graph object is a collection of shader programs,
public:
typedef Dali::ShaderEffect::UniformCoordinateType UniformCoordinateType;
- struct Uniform
- {
- std::string mName;
- Property::Index mIndex;
- Property::Value mValue;
- };
-
- typedef std::vector< Uniform > UniformArray;
-
/**
* Create a new ShaderEffect with no programs
* @param hints GeometryHints to define the geometry of the rendered object
UniformCoordinateType uniformCoordinateType );
/**
- * Returns the uniforms set for the shaders
- *
- * @return Returns and array of uniforms set for the shaders
- */
- const UniformArray& GetUniforms() {return mUniforms;}
-
- /**
- * Returns the GeometryHints used
- *
- * @return Returns the GeometryHints used
- */
- Dali::ShaderEffect::GeometryHints GetGeometryHints() const {return mGeometryHints;}
-
- /**
* Add a GeometryType specific default program to this ShaderEffect
* @param[in] geometryType The GeometryType rendered by the shader program
* @param[in] vertexSource The source code for the vertex shader
/**
* @brief Notify ShaderEffect that it's being used by an Actor.
*
- * @param[in] actor The Actor that is connecting to this ShaderEffect
+ * @param[in] actor The Actor that is connecting to this ShaderEffect
*/
void Connect( ActorPtr actor );
/**
* @brief Notify ShaderEffect that an Actor is no longer using it.
*
- * @param[in] actor The Actor that is disconnecting from this ShaderEffect
+ * @param[in] actor The Actor that is disconnecting from this ShaderEffect
*/
void Disconnect( ActorPtr actor );
public:
/**
- * Returns the vertex shader for this ShaderEffect
+ * Returns the shader for this ShaderEffect
*
- * @return Returns the vertex shader for this ShaderEffect
+ * @return Returns the shader for this ShaderEffect
*/
- const std::string& GetVertexShader() const {return mVertexSource;}
+ ShaderPtr GetShader() const { return mShader; }
/**
- * Returns the fragment shader for this ShaderEffect
+ * Returns the geometry grid size.
*
- * @return Returns the fragment shader for this ShaderEffect
+ * @param[in] size The pixel area size.
+ * @return Returns the geometry grid size
*/
- const std::string& GetFragmentShader() const {return mFragmentSource;}
+ Vector2 GetGridSize( const Vector2& size );
/**
- * Returns the fragment shader for this ShaderEffect
+ * Returns the effect image for this ShaderEffect
*
- * @return Returns the fragment shader for this ShaderEffect
+ * @return Returns the effect image for this ShaderEffect
*/
- Dali::Image GetEffectImage() const {return mEffectImage;}
+ Dali::Image GetEffectImage() const { return mEffectImage; }
-public: // Default property extensions from Object
+public: // override property functions from Object
+
+ /**
+ * @copydoc Dali::Handle::GetPropertyCount()
+ */
+ virtual unsigned int GetPropertyCount() const;
+
+ /**
+ * @copydoc Dali::Handle::GetPropertyName()
+ */
+ virtual std::string GetPropertyName( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Handle::GetPropertyIndex()
+ */
+ virtual Property::Index GetPropertyIndex( const std::string& name ) const;
+
+ /**
+ * @copydoc Dali::Handle::IsPropertyWritable()
+ */
+ virtual bool IsPropertyWritable( Property::Index index ) const;
/**
+ * @copydoc Dali::Handle::IsPropertyAnimatable()
+ */
+ virtual bool IsPropertyAnimatable( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Handle::IsPropertyAConstraintInput()
+ */
+ virtual bool IsPropertyAConstraintInput( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Handle::GetPropertyType()
+ */
+ virtual Property::Type GetPropertyType( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Handle::SetProperty()
+ */
+ virtual void SetProperty( Property::Index index, const Property::Value& propertyValue );
+
+ /**
+ * @copydoc Dali::Handle::GetProperty()
+ */
+ virtual Property::Value GetProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Handle::GetPropertyIndices()
+ */
+ virtual void GetPropertyIndices( Property::IndexContainer& indices ) const;
+
+ /**
+ * @copydoc Dali::Handle::RegisterProperty()
+ */
+ virtual Property::Index RegisterProperty( const std::string& name, const Property::Value& propertyValue );
+
+ /**
+ * @copydoc Dali::Handle::RegisterProperty(std::string name, Property::Value propertyValue, Property::AccessMode accessMode)
+ */
+ virtual Property::Index RegisterProperty( const std::string& name, const Property::Value& propertyValue, Property::AccessMode accessMode );
+
+ /**
+ * @copydoc Dali::Handle::AddPropertyNotification()
+ */
+ virtual Dali::PropertyNotification AddPropertyNotification( Property::Index index,
+ int componentIndex,
+ const Dali::PropertyCondition& condition );
+
+ /**
+ * @copydoc Dali::Handle::RemovePropertyNotification()
+ */
+ virtual void RemovePropertyNotification( Dali::PropertyNotification propertyNotification );
+
+ /**
+ * @copydoc Dali::Handle::RemovePropertyNotifications()
+ */
+ virtual void RemovePropertyNotifications();
+
+public: // Default property extensions from Object
+ /**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
*/
virtual unsigned int GetDefaultPropertyCount() const;
*/
virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
+ */
+ virtual int GetPropertyComponentIndex( Property::Index index ) const;
+
protected:
/**
* Protected constructor.
- * @param[in] eventThreadServices the interface to use for sending messages to the update thread
* @param[in] hints Geometry hints
*/
- ShaderEffect( EventThreadServices& eventThreadServices, Dali::ShaderEffect::GeometryHints hints );
+ ShaderEffect( Dali::ShaderEffect::GeometryHints hints );
/**
* A reference counted object may only be deleted by calling Unreference()
private: // Data
std::vector< ActorPtr > mConnectedActors; ///< The array of actors that are currently connected to this ShaderEffect
- UniformArray mUniforms; ///< The array of uniforms set for this ShaderEffect
-
- std::string mVertexSource; ///< The vertex shader source
- std::string mFragmentSource; ///< The fragment shader source
-
- EventThreadServices& mEventThreadServices; ///< Event thread services, for sending messages
- SceneGraph::Shader* mSceneObject; ///< Pointer to the scene shader, should not be changed on this thread
+ ShaderPtr mShader; ///< The shader pointer
+ Dali::Image mEffectImage; ///< The Client-side handle to the effect image
+ float mGridDensity; ///< The grid denisty
+ Dali::ShaderEffect::GeometryHints mGeometryHints; ///< shader geometry hints for building the geometry
- Dali::Image mEffectImage; ///< The Client-side handle to the effect image
- Dali::ShaderEffect::GeometryHints mGeometryHints; ///< shader geometry hints for building the geometry
- float mGridDensity; ///< The grid denisty
};
} // namespace Internal
#include <dali/public-api/common/dali-vector.h>
#include <dali/internal/event/effects/shader-declarations.h>
#include <dali/internal/common/message.h>
+#include <dali/internal/common/shader-data.h>
#include <dali/internal/common/shader-saver.h>
namespace Dali
// Default Properties
/**
- * @brief An enumeration of properties belonging to the Path class.
+ * @brief An enumeration of properties belonging to the ShaderEffect class.
* Grid Density defines the spacing of vertex coordinates in world units.
* ie a larger actor will have more grids at the same spacing.
*
projects / platform / core / uifw / dali-core.git / commitdiff