}
);
-Actor CreateMeshActorToStage( TestApplication& application, Vector3 parentOrigin = ParentOrigin::CENTER, Vector3 anchorPoint = AnchorPoint::CENTER, Shader::ShaderHints shaderHints = Shader::HINT_NONE )
+Actor CreateMeshActorToStage( TestApplication& application, Vector3 parentOrigin = ParentOrigin::CENTER, Vector3 anchorPoint = AnchorPoint::CENTER, Shader::Hint::Value shaderHints = Shader::Hint::NONE )
{
PixelBuffer* pixelBuffer = new PixelBuffer[ 4 ];
BufferImage image = BufferImage::New( pixelBuffer, 1, 1 );
TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
drawTrace.Enable( true );
- CreateMeshActorToStage( application, Vector3( 7.0f, 0.5f, 0.5f ), AnchorPoint::CENTER, Shader::HINT_MODIFIES_GEOMETRY );
+ CreateMeshActorToStage( application, Vector3( 7.0f, 0.5f, 0.5f ), AnchorPoint::CENTER, Shader::Hint::MODIFIES_GEOMETRY );
drawTrace.Reset();
application.SendNotification();
tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_TRANSPARENT renders with blending enabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_TRANSPARENT );
+ Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::Hint::OUTPUT_IS_TRANSPARENT );
Renderer renderer = Renderer::New( geometry, shader );
tet_infoline("Test get/set progam property");
Shader shader = Shader::New("", "");
- std::string hintSet = "HINT_MODIFIES_GEOMETRY";
+ std::string hintSet = "MODIFIES_GEOMETRY";
Property::Map map;
map["vertex"] = VertexSource;
std::string hintGot;
- hintSet = "HINT_OUTPUT_IS_TRANSPARENT,HINT_MODIFIES_GEOMETRY";
+ hintSet = "OUTPUT_IS_TRANSPARENT,MODIFIES_GEOMETRY";
map["hints"] = hintSet;
shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
value = shader.GetProperty(Shader::Property::PROGRAM);
hintGot = (*value.GetMap())["hints"].Get<std::string>();
DALI_TEST_CHECK( hintGot == hintSet );
- hintSet = "HINT_OUTPUT_IS_TRANSPARENT";
+ hintSet = "OUTPUT_IS_TRANSPARENT";
map["hints"] = hintSet;
shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
value = shader.GetProperty(Shader::Property::PROGRAM);
hintGot = (*value.GetMap())["hints"].Get<std::string>();
DALI_TEST_CHECK( hintGot == hintSet );
- hintSet = "HINT_NONE";
+ hintSet = "NONE";
map["hints"] = hintSet;
shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
value = shader.GetProperty(Shader::Property::PROGRAM);
shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
value = shader.GetProperty(Shader::Property::PROGRAM);
hintGot = (*value.GetMap())["hints"].Get<std::string>();
- DALI_TEST_CHECK( hintGot == "HINT_NONE" );
+ DALI_TEST_CHECK( hintGot == "NONE" );
END_TEST;
}
* @param[in] vertexSource Source code for vertex program
* @param[in] fragmentSource Source code for fragment program
*/
- ShaderData(const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::ShaderHints hints)
+ ShaderData(const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::Hint::Value hints)
: mShaderHash( -1 ),
mVertexShader(vertexSource),
mFragmentShader(fragmentSource),
/**
* @return the hints
*/
- Dali::Shader::ShaderHints GetHints() const
+ Dali::Shader::Hint::Value GetHints() const
{
return mHints;
}
size_t mShaderHash; ///< hash key created with vertex and fragment shader code
std::string mVertexShader; ///< source code for vertex program
std::string mFragmentShader; ///< source code for fragment program
- Dali::Shader::ShaderHints mHints; ///< take a hint
+ Dali::Shader::Hint::Value mHints; ///< take a hint
Dali::Vector<unsigned char> mBuffer; ///< buffer containing compiled binary bytecode
};
GeometryPtr quad = CreateGeometry( 1u, 1u, Vector2::ONE );
actor->mRenderer->SetGeometry( *quad );
- ShaderPtr shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, Dali::Shader::HINT_NONE );
+ ShaderPtr shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, Dali::Shader::Hint::NONE );
actor->mRenderer->SetShader( *shader );
TextureSetPtr textureSet = TextureSet::New();
actor->mRenderer->SetTextures( *textureSet );
{
mShaderEffect->Disconnect( this );
// change to the standard shader and quad geometry
- ShaderPtr shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, Dali::Shader::HINT_NONE );
+ ShaderPtr shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, Dali::Shader::Hint::NONE );
mRenderer->SetShader( *shader );
mShaderEffect.Reset();
return retval;
}
-Dali::Shader::ShaderHints ConvertHints( Dali::ShaderEffect::GeometryHints hints)
+Dali::Shader::Hint::Value ConvertHints( Dali::ShaderEffect::GeometryHints hints)
{
- int convertedHints = Dali::Shader::HINT_NONE;
+ int convertedHints = Dali::Shader::Hint::NONE;
if( hints & Dali::ShaderEffect::HINT_BLENDING )
{
- convertedHints |= Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT;
+ convertedHints |= Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT;
}
if( !(hints & Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY) )
{
- convertedHints |= Dali::Shader::HINT_MODIFIES_GEOMETRY;
+ convertedHints |= Dali::Shader::Hint::MODIFIES_GEOMETRY;
}
- return Dali::Shader::ShaderHints( convertedHints );
+ return Dali::Shader::Hint::Value( convertedHints );
}
} // unnamed namespace
}
}
-ShaderDataPtr ShaderFactory::Load( const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::ShaderHints hints, size_t& shaderHash )
+ShaderDataPtr ShaderFactory::Load( const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::Hint::Value hints, size_t& shaderHash )
{
// Work out the filename for the binary that the glsl source will be compiled and linked to:
shaderHash = CalculateHash( vertexSource.c_str(), fragmentSource.c_str() );
* a compiled shader program binary if one could be found, else an
* empty binary buffer cleared to size zero.
*/
- Internal::ShaderDataPtr Load( const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::ShaderHints hints, size_t& shaderHash );
+ Internal::ShaderDataPtr Load( const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::Hint::Value hints, size_t& shaderHash );
/**
* @brief Saves shader to memory cache and filesystem.
const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> SHADER_IMPL = { DEFAULT_PROPERTY_DETAILS };
Dali::Scripting::StringEnum ShaderHintsTable[] =
- { { "HINT_NONE", Dali::Shader::HINT_NONE},
- { "HINT_OUTPUT_IS_TRANSPARENT", Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT},
- { "HINT_MODIFIES_GEOMETRY", Dali::Shader::HINT_MODIFIES_GEOMETRY}
+ { { "NONE", Dali::Shader::Hint::NONE},
+ { "OUTPUT_IS_TRANSPARENT", Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT},
+ { "MODIFIES_GEOMETRY", Dali::Shader::Hint::MODIFIES_GEOMETRY}
};
const unsigned int ShaderHintsTableSize = sizeof( ShaderHintsTable ) / sizeof( ShaderHintsTable[0] );
to += append;
}
-Property::Value HintString(const Dali::Shader::ShaderHints& hints)
+Property::Value HintString(const Dali::Shader::Hint::Value& hints)
{
std::string s;
- if(hints == Dali::Shader::HINT_NONE)
+ if(hints == Dali::Shader::Hint::NONE)
{
- s = "HINT_NONE";
+ s = "NONE";
}
- if(hints & Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT)
+ if(hints & Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT)
{
- AppendString(s, "HINT_OUTPUT_IS_TRANSPARENT");
+ AppendString(s, "OUTPUT_IS_TRANSPARENT");
}
- if(hints & Dali::Shader::HINT_MODIFIES_GEOMETRY)
+ if(hints & Dali::Shader::Hint::MODIFIES_GEOMETRY)
{
- AppendString(s, "HINT_MODIFIES_GEOMETRY");
+ AppendString(s, "MODIFIES_GEOMETRY");
}
return Property::Value(s);
ShaderPtr Shader::New( const std::string& vertexShader,
const std::string& fragmentShader,
- Dali::Shader::ShaderHints hints )
+ Dali::Shader::Hint::Value hints )
{
ShaderPtr shader( new Shader() );
shader->Initialize( vertexShader, fragmentShader, hints );
{
std::string vertex;
std::string fragment;
- Dali::Shader::ShaderHints hints(Dali::Shader::HINT_NONE);
+ Dali::Shader::Hint::Value hints(Dali::Shader::Hint::NONE);
if( Property::Value* value = map->Find("vertex") )
{
if( Property::Value* value = map->Find("hints") )
{
static_cast<void>( // ignore return
- Scripting::GetEnumeration< Dali::Shader::ShaderHints >(value->Get<std::string>().c_str(),
+ Scripting::GetEnumeration< Dali::Shader::Hint::Value >(value->Get<std::string>().c_str(),
ShaderHintsTable, ShaderHintsTableSize, hints)
);
}
void Shader::Initialize(
const std::string& vertexSource,
const std::string& fragmentSource,
- Dali::Shader::ShaderHints hints )
+ Dali::Shader::Hint::Value hints )
{
EventThreadServices& eventThreadServices = GetEventThreadServices();
SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
mShaderData = shaderFactory.Load( vertexSource, fragmentSource, hints, shaderHash );
// Add shader program to scene-object using a message to the UpdateManager
- SetShaderProgramMessage( updateManager, *mSceneObject, mShaderData, (hints & Dali::Shader::HINT_MODIFIES_GEOMETRY) != 0x0 );
+ SetShaderProgramMessage( updateManager, *mSceneObject, mShaderData, (hints & Dali::Shader::Hint::MODIFIES_GEOMETRY) != 0x0 );
eventThreadServices.RegisterObject( this );
}
*/
static ShaderPtr New( const std::string& vertexShader,
const std::string& fragmentShader,
- Dali::Shader::ShaderHints hints );
+ Dali::Shader::Hint::Value hints );
/**
* @brief Get the shader scene object
/**
* Second stage initialization
*/
- void Initialize( const std::string& vertexShader, const std::string& fragmentShader, Dali::Shader::ShaderHints hints );
+ void Initialize( const std::string& vertexShader, const std::string& fragmentShader, Dali::Shader::Hint::Value hints );
protected:
/**
namespace SceneGraph
{
-Shader::Shader( Dali::Shader::ShaderHints& hints )
+Shader::Shader( Dali::Shader::Hint::Value& hints )
: mHints( hints ),
mProgram( NULL ),
mConnectionObservers()
* Constructor
* @param hints Shader hints
*/
- Shader( Dali::Shader::ShaderHints& hints );
+ Shader( Dali::Shader::Hint::Value& hints );
/**
* Virtual destructor
* @param[in] hint The hint to check.
* @return True if the given hint is set.
*/
- bool HintEnabled( Dali::Shader::ShaderHints hint ) const
+ bool HintEnabled( Dali::Shader::Hint::Value hint ) const
{
return mHints & hint;
}
private: // Data
- Dali::Shader::ShaderHints mHints;
+ Dali::Shader::Hint::Value mHints;
Program* mProgram;
bool cull )
{
bool inside( true );
- if ( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::HINT_MODIFIES_GEOMETRY ) )
+ if ( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
{
const Vector4& boundingSphere = renderable.mNode->GetBoundingSphere();
inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
}
case BlendMode::AUTO:
{
- bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT ) );
+ bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT ) );
if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) )
{
opacity = Renderer::TRANSLUCENT;
* @SINCE_1_0.0
* @param[in] cullMode True if the renderers should be culled.
* @note The default mode is to cull actors.
- * @note If the shader uses @ref Shader::HINT_MODIFIES_GEOMETRY then culling optimizations are disabled.
- * @see Shader::ShaderHints
+ * @note If the shader uses @ref Shader::Hint::MODIFIES_GEOMETRY then culling optimizations are disabled.
+ * @see Shader::Hint
*/
void SetCullMode( bool cullMode );
Shader Shader::New( const std::string& vertexShader,
const std::string& fragmentShader,
- ShaderHints hints )
+ Hint::Value hints )
{
Internal::ShaderPtr renderer = Internal::Shader::New( vertexShader, fragmentShader, hints );
return Shader( renderer.Get() );
public:
/**
- * @brief Hints for rendering/subdividing geometry.
- * @SINCE_1_1.43
+ * @brief Hints for rendering.
+ * @SINCE_1_1.45
*/
- enum ShaderHints
+ struct Hint
{
- HINT_NONE = 0x00, ///< No hints @SINCE_1_1.43
- HINT_OUTPUT_IS_TRANSPARENT = 0x01, ///< Might generate transparent alpha from opaque inputs @SINCE_1_1.43
- HINT_MODIFIES_GEOMETRY = 0x02, ///< Might change position of vertices, this option disables any culling optimizations @SINCE_1_1.43
+ enum Value
+ {
+ NONE = 0x00, ///< No hints @SINCE_1_1.43
+ OUTPUT_IS_TRANSPARENT = 0x01, ///< Might generate transparent alpha from opaque inputs @SINCE_1_1.43
+ MODIFIES_GEOMETRY = 0x02, ///< Might change position of vertices, this option disables any culling optimizations @SINCE_1_1.43
+ };
};
/**
*/
static Shader New( const std::string& vertexShader,
const std::string& fragmentShader,
- ShaderHints hints = ShaderHints( HINT_NONE ) );
+ Hint::Value hints = Hint::NONE );
/**
* @brief Default constructor, creates an empty handle