#include <dali/devel-api/scripting/scripting.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
//Property names
const char * const PRIMITIVE_SHAPE( "shape" );
-const char * const SHAPE_COLOR( "shapeColor" );
+const char * const SHAPE_COLOR( "mixColor" );
const char * const SLICES( "slices" );
const char * const STACKS( "stacks" );
const char * const SCALE_TOP_RADIUS( "scaleTopRadius" );
const float DEFAULT_SCALE_RADIUS = 1.0; ///< For cylinders
const float DEFAULT_BEVEL_PERCENTAGE = 0.0; ///< For bevelled cubes
const float DEFAULT_BEVEL_SMOOTHNESS = 0.0; ///< For bevelled cubes
-const Vector4 DEFAULT_COLOR = Vector4( 0.5, 0.5, 0.5, 0.0 ); ///< Grey, for all.
+const Vector4 DEFAULT_COLOR = Vector4( 0.5, 0.5, 0.5, 1.0 ); ///< Grey, for all.
//Property limits
-const int MIN_SLICES = 1; ///< Minimum number of slices for spheres and conics
-const int MIN_STACKS = 1; ///< Minimum number of stacks for spheres and conics
+const int MIN_SLICES = 3; ///< Minimum number of slices for spheres and conics
+const int MIN_STACKS = 2; ///< Minimum number of stacks for spheres and conics
const int MAX_PARTITIONS = 255; ///< Maximum number of slices or stacks for spheres and conics
const float MIN_BEVEL_PERCENTAGE = 0.0; ///< Minimum bevel percentage for bevelled cubes
const float MAX_BEVEL_PERCENTAGE = 1.0; ///< Maximum bevel percentage for bevelled cubes
//Shader properties
const char * const OBJECT_MATRIX_UNIFORM_NAME( "uObjectMatrix" );
-const char * const COLOR_UNIFORM_NAME( "uColor" );
+const char * const COLOR_UNIFORM_NAME( "mixColor" );
const char * const OBJECT_DIMENSIONS_UNIFORM_NAME( "uObjectDimensions" );
const char * const STAGE_OFFSET_UNIFORM_NAME( "uStageOffset" );
precision mediump float;\n
varying mediump vec3 vIllumination;\n
uniform lowp vec4 uColor;\n
+ uniform lowp vec4 mixColor;\n
void main()\n
{\n
- gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a );\n
+ vec4 baseColor = mixColor * uColor;\n
+ gl_FragColor = vec4( vIllumination.rgb * baseColor.rgb, baseColor.a );\n
}\n
);
-} // namespace
+} // unnamed namespace
+
+PrimitiveVisualPtr PrimitiveVisual::New( VisualFactoryCache& factoryCache )
+{
+ return new PrimitiveVisual( factoryCache );
+}
PrimitiveVisual::PrimitiveVisual( VisualFactoryCache& factoryCache )
: Visual::Base( factoryCache ),
{
}
-void PrimitiveVisual::DoInitialize( Actor& actor, const Property::Map& propertyMap )
+void PrimitiveVisual::DoSetProperties( const Property::Map& propertyMap )
{
//Find out which shape to renderer.
Property::Value* primitiveTypeValue = propertyMap.Find( Toolkit::PrimitiveVisual::Property::SHAPE, PRIMITIVE_SHAPE );
//Read in other potential properties.
- Property::Value* color = propertyMap.Find( Toolkit::PrimitiveVisual::Property::COLOR, SHAPE_COLOR );
+ Property::Value* color = propertyMap.Find( Toolkit::PrimitiveVisual::Property::MIX_COLOR, SHAPE_COLOR );
if( color && !color->Get( mColor ) )
{
DALI_LOG_ERROR( "Invalid type for color in PrimitiveVisual.\n" );
if( mSlices > MAX_PARTITIONS )
{
mSlices = MAX_PARTITIONS;
+ DALI_LOG_WARNING( "Value for slices clamped.\n" );
}
else if ( mSlices < MIN_SLICES )
{
mSlices = MIN_SLICES;
+ DALI_LOG_WARNING( "Value for slices clamped.\n" );
}
}
else
if( mStacks > MAX_PARTITIONS )
{
mStacks = MAX_PARTITIONS;
+ DALI_LOG_WARNING( "Value for stacks clamped.\n" );
}
else if ( mStacks < MIN_STACKS )
{
mStacks = MIN_STACKS;
+ DALI_LOG_WARNING( "Value for stacks clamped.\n" );
}
}
else
if( mScaleDimensions.x <= 0.0 )
{
mScaleDimensions.x = 1.0;
+ DALI_LOG_WARNING( "Value for scale dimensions clamped. Must be greater than zero.\n" );
}
if( mScaleDimensions.y <= 0.0 )
{
mScaleDimensions.y = 1.0;
+ DALI_LOG_WARNING( "Value for scale dimensions clamped. Must be greater than zero.\n" );
}
if( mScaleDimensions.z <= 0.0 )
{
mScaleDimensions.z = 1.0;
+ DALI_LOG_WARNING( "Value for scale dimensions clamped. Must be greater than zero.\n" );
}
}
else
if( mBevelPercentage < MIN_BEVEL_PERCENTAGE )
{
mBevelPercentage = MIN_BEVEL_PERCENTAGE;
+ DALI_LOG_WARNING( "Value for bevel percentage clamped.\n" );
}
else if( mBevelPercentage > MAX_BEVEL_PERCENTAGE )
{
mBevelPercentage = MAX_BEVEL_PERCENTAGE;
+ DALI_LOG_WARNING( "Value for bevel percentage clamped.\n" );
}
}
else
if( mBevelSmoothness < MIN_SMOOTHNESS )
{
mBevelSmoothness = MIN_SMOOTHNESS;
+ DALI_LOG_WARNING( "Value for bevel smoothness clamped.\n" );
}
else if( mBevelSmoothness > MAX_SMOOTHNESS )
{
mBevelSmoothness = MAX_SMOOTHNESS;
+ DALI_LOG_WARNING( "Value for bevel smoothness clamped.\n" );
}
}
else
naturalSize.y = mObjectDimensions.y;
}
-void PrimitiveVisual::SetClipRect( const Rect<int>& clipRect )
-{
- Visual::Base::SetClipRect( clipRect );
-
- //ToDo: renderer responds to the clipRect change
-}
-
-void PrimitiveVisual::SetOffset( const Vector2& offset )
-{
- //ToDo: renderer applies the offset
-}
-
void PrimitiveVisual::DoSetOnStage( Actor& actor )
{
InitializeRenderer();
+
+ actor.AddRenderer( mImpl->mRenderer );
}
void PrimitiveVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::PRIMITIVE );
+ map.Insert( Toolkit::VisualProperty::TYPE, Toolkit::Visual::PRIMITIVE );
map.Insert( Toolkit::PrimitiveVisual::Property::SHAPE, mPrimitiveType );
- map.Insert( Toolkit::PrimitiveVisual::Property::COLOR, mColor );
+ map.Insert( Toolkit::PrimitiveVisual::Property::MIX_COLOR, mColor );
map.Insert( Toolkit::PrimitiveVisual::Property::SLICES, mSlices );
map.Insert( Toolkit::PrimitiveVisual::Property::STACKS, mStacks );
map.Insert( Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS, mScaleTopRadius );
map.Insert( Toolkit::PrimitiveVisual::Property::LIGHT_POSITION, mLightPosition );
}
+void PrimitiveVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
+{
+ // TODO
+}
+
+Dali::Property::Value PrimitiveVisual::DoGetProperty( Dali::Property::Index index )
+{
+ // TODO
+ return Dali::Property::Value();
+}
+
void PrimitiveVisual::InitializeRenderer()
{
if( !mGeometry )
mShader.RegisterProperty( STAGE_OFFSET_UNIFORM_NAME, Vector2( width, height ) / 2.0f );
mShader.RegisterProperty( LIGHT_POSITION_UNIFORM_NAME, mLightPosition );
mShader.RegisterProperty( OBJECT_MATRIX_UNIFORM_NAME, scaleMatrix );
- mShader.RegisterProperty( COLOR_UNIFORM_NAME, mColor );
+ mShader.RegisterProperty( Toolkit::PrimitiveVisual::Property::MIX_COLOR, COLOR_UNIFORM_NAME, mColor );
mShader.RegisterProperty( OBJECT_DIMENSIONS_UNIFORM_NAME, mObjectDimensions );
}
void PrimitiveVisual::CreateBevelledCube( Vector<Vertex>& vertices, Vector<unsigned short>& indices,
Vector3 dimensions, float bevelPercentage, float bevelSmoothness )
{
- dimensions.Normalize();
+ float maxDimension = std::max( std::max( dimensions.x, dimensions.y ), dimensions.z );
+ dimensions = dimensions / maxDimension;
if( bevelPercentage <= MIN_BEVEL_PERCENTAGE ) //No bevel, form a cube.
{
int normalIndex = 0; //Track progress through normals, as vertices are calculated per face.
float minDimension = std::min( std::min( dimensions.x, dimensions.y ), dimensions.z );
- float bevelScale = 1.0 - bevelPercentage;
- float bevelAmount = 0.5 * bevelScale * minDimension;
+ float bevelAmount = 0.5 * std::min( bevelPercentage, minDimension ); //Cap bevel amount if necessary.
+ //Distances from centre to outer edge points.
float outerX = 0.5 * dimensions.x;
float outerY = 0.5 * dimensions.y;
float outerZ = 0.5 * dimensions.z;
- float bevelX = outerX - ( 0.5 * minDimension - bevelAmount );
- float bevelY = outerY - ( 0.5 * minDimension - bevelAmount );
- float bevelZ = outerZ - ( 0.5 * minDimension - bevelAmount );
+ //Distances from centre to bevelled points.
+ float bevelX = outerX - bevelAmount;
+ float bevelY = outerY - bevelAmount;
+ float bevelZ = outerZ - bevelAmount;
Vector<Vector3> positions; //Holds object points, to be shared between vertexes.
positions.Resize( numPositions );
projects / platform / core / uifw / dali-toolkit.git / blobdiff