--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/actors/renderer-impl.h> // Dali::Internal::Renderer
+
+// INTERNAL INCLUDES
+#include <dali/public-api/actors/renderer.h> // Dali::Renderer
+#include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
+#include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
+
+namespace Dali
+{
+namespace Internal
+{
+
+namespace
+{
+
+/**
+ * |name |type |writable|animatable|constraint-input|enum for index-checking|
+ */
+DALI_PROPERTY_TABLE_BEGIN
+DALI_PROPERTY( "depth-index", INTEGER, true, true, true, Dali::Renderer::Property::DEPTH_INDEX )
+DALI_PROPERTY_TABLE_END( DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX )
+
+const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS };
+
+} // unnamed namespace
+
+RendererPtr Renderer::New()
+{
+ return RendererPtr( new Renderer() );
+}
+
+void Renderer::SetGeometry( Geometry& geometry )
+{
+ mGeometryConnector.Set( geometry, OnStage() );
+}
+
+void Renderer::SetMaterial( Material& material )
+{
+ mMaterialConnector.Set( material, OnStage() );
+}
+
+void Renderer::SetDepthIndex( int depthIndex )
+{
+ //SceneGraph::NodePropertyMessage<Vector3>::Send( mStage->GetUpdateManager(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::Bake, position );
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+unsigned int Renderer::GetDefaultPropertyCount() const
+{
+ return RENDERER_IMPL.GetDefaultPropertyCount();
+}
+
+void Renderer::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
+{
+ RENDERER_IMPL.GetDefaultPropertyIndices( indices );
+}
+
+const char* Renderer::GetDefaultPropertyName(Property::Index index) const
+{
+ return RENDERER_IMPL.GetDefaultPropertyName( index );
+}
+
+Property::Index Renderer::GetDefaultPropertyIndex( const std::string& name ) const
+{
+ return RENDERER_IMPL.GetDefaultPropertyIndex( name );
+}
+
+bool Renderer::IsDefaultPropertyWritable( Property::Index index ) const
+{
+ return RENDERER_IMPL.IsDefaultPropertyWritable( index );
+}
+
+bool Renderer::IsDefaultPropertyAnimatable( Property::Index index ) const
+{
+ return RENDERER_IMPL.IsDefaultPropertyAnimatable( index );
+}
+
+bool Renderer::IsDefaultPropertyAConstraintInput( Property::Index index ) const
+{
+ return RENDERER_IMPL.IsDefaultPropertyAConstraintInput( index );
+}
+
+Property::Type Renderer::GetDefaultPropertyType( Property::Index index ) const
+{
+ return RENDERER_IMPL.GetDefaultPropertyType( index );
+}
+
+void Renderer::SetDefaultProperty( Property::Index index,
+ const Property::Value& propertyValue )
+{
+ RENDERER_IMPL.SetDefaultProperty( index, propertyValue );
+}
+
+void Renderer::SetSceneGraphProperty( Property::Index index,
+ const CustomProperty& entry,
+ const Property::Value& value )
+{
+ RENDERER_IMPL.SetSceneGraphProperty( index, entry, value );
+}
+
+Property::Value Renderer::GetDefaultProperty( Property::Index index ) const
+{
+ return RENDERER_IMPL.GetDefaultProperty( index );
+}
+
+const SceneGraph::PropertyOwner* Renderer::GetPropertyOwner() const
+{
+ return RENDERER_IMPL.GetPropertyOwner();
+}
+
+const SceneGraph::PropertyOwner* Renderer::GetSceneObject() const
+{
+ return RENDERER_IMPL.GetSceneObject();
+}
+
+const SceneGraph::PropertyBase* Renderer::GetSceneObjectAnimatableProperty( Property::Index index ) const
+{
+ return RENDERER_IMPL.GetSceneObjectAnimatableProperty( index );
+}
+
+const PropertyInputImpl* Renderer::GetSceneObjectInputProperty( Property::Index index ) const
+{
+ return RENDERER_IMPL.GetSceneObjectInputProperty( index );
+}
+
+int Renderer::GetPropertyComponentIndex( Property::Index index ) const
+{
+ return RENDERER_IMPL.GetPropertyComponentIndex( index );
+}
+
+bool Renderer::OnStage() const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return false;
+}
+
+void Renderer::Connect()
+{
+ // TODO: MESH_REWORK : check this
+ mGeometryConnector.OnStageConnect();
+ mMaterialConnector.OnStageConnect();
+}
+
+void Renderer::Disconnect()
+{
+ // TODO: MESH_REWORK : check this
+ mGeometryConnector.OnStageDisconnect();
+ mMaterialConnector.OnStageDisconnect();
+}
+
+Renderer::Renderer()
+{
+}
+
+} // namespace Internal
+} // namespace Dali
+
--- /dev/null
+#ifndef DALI_INTERNAL_RENDERER_H
+#define DALI_INTERNAL_RENDERER_H
+
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/actors/renderer.h> // Dali::Renderer
+#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
+#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
+#include <dali/internal/event/common/connectable.h> // Dali::Internal::Connectable
+#include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
+#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
+#include <dali/internal/event/effects/material-impl.h> // Dali::Internal::Material
+#include <dali/internal/event/geometry/geometry-impl.h> // Dali::Internal::Geometry
+
+namespace Dali
+{
+namespace Internal
+{
+
+class Renderer;
+typedef IntrusivePtr<Renderer> RendererPtr;
+
+/**
+ * Renderer is an object that can be used to show content by combining a Geometry with a material.
+ */
+class Renderer : public Object, public Connectable
+{
+public:
+
+ /**
+ * Create a new Renderer.
+ * @return A smart-pointer to the newly allocated Renderer.
+ */
+ static RendererPtr New();
+
+ /**
+ * @copydoc Dali::Renderer::SetGeometry()
+ */
+ void SetGeometry( Geometry& geometry );
+
+ /**
+ * @copydoc Dali::Renderer::SetMaterial()
+ */
+ void SetMaterial( Material& material );
+
+ /**
+ * @copydoc Dali::Renderer::SetDepthIndex()
+ */
+ void SetDepthIndex( int depthIndex );
+
+public: // Default property extensions from Object
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
+ */
+ virtual unsigned int GetDefaultPropertyCount() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
+ */
+ virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
+ */
+ virtual const char* GetDefaultPropertyName(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
+ */
+ virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
+ */
+ virtual bool IsDefaultPropertyWritable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
+ */
+ virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
+ */
+ virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
+ */
+ virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::SetDefaultProperty()
+ */
+ virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+
+ /**
+ * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
+ */
+ virtual void SetSceneGraphProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value );
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultProperty()
+ */
+ virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyOwner()
+ */
+ virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObject()
+ */
+ virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
+ */
+ virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
+ */
+ virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
+ */
+ virtual int GetPropertyComponentIndex( Property::Index index ) const;
+
+public: // Functions from Connectable
+ /**
+ * @copydoc Dali::Internal::Connectable::OnStage()
+ */
+ virtual bool OnStage() const;
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Connect()
+ */
+ virtual void Connect();
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Disconnect()
+ */
+ virtual void Disconnect();
+
+private: // implementation
+ Renderer();
+
+private: // unimplemented methods
+ Renderer( const Renderer& );
+ Renderer& operator=( const Renderer& );
+
+private: // data
+ ObjectConnector<Geometry> mGeometryConnector; ///< Connector that holds the geometry used by this renderer
+ ObjectConnector<Material> mMaterialConnector; ///< Connector that holds the material used by this renderer
+
+};
+
+} // namespace Internal
+
+// Helpers for public-api forwarding methods
+inline Internal::Renderer& GetImplementation( Dali::Renderer& handle )
+{
+ DALI_ASSERT_ALWAYS(handle && "Renderer handle is empty");
+
+ BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<Internal::Renderer&>(object);
+}
+
+inline const Internal::Renderer& GetImplementation( const Dali::Renderer& handle )
+{
+ DALI_ASSERT_ALWAYS(handle && "Renderer handle is empty");
+
+ const BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<const Internal::Renderer&>(object);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_RENDERER_H
--- /dev/null
+#ifndef DALI_INTERNAL_CONNECTABLE_H
+#define DALI_INTERNAL_CONNECTABLE_H
+
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+
+namespace Dali
+{
+namespace Internal
+{
+
+/**
+ * @brief Interface for objects that can be connected to the stage.
+ */
+class Connectable
+{
+public:
+
+ /**
+ * @brief Destructor
+ */
+ virtual ~Connectable() {}
+
+ /**
+ * @brief Check if the object is on stage
+ */
+ virtual bool OnStage() const = 0;
+
+ /**
+ * @brief Notify this objects that it has been connected to the stage.
+ */
+ virtual void Connect() = 0;
+
+ /**
+ * @brief Notify this objects that it has been disconnected to the stage.
+ */
+ virtual void Disconnect() = 0;
+
+};
+
+} // namespace Internal
+} // namespace Dali
+
+#endif // DALI_INTERNAL_CONNECTABLE_H
--- /dev/null
+#ifndef DALI_INTERNAL_OBJECT_CONNECTOR_H
+#define DALI_INTERNAL_OBJECT_CONNECTOR_H
+
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/intrusive-ptr.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+/**
+ * @brief Wrapper class which helps managing intrusive pointer assignments and Connect / Disconnect.
+ *
+ * Should be used with objects that implement Dali::Internal::Connectable
+ */
+template<typename Object>
+class ObjectConnector
+{
+public:
+ typedef IntrusivePtr<Object> ObjectPtr;
+
+ /**
+ * @brief Default constructor.
+ */
+ ObjectConnector() {}
+
+ /**
+ * @brief Destructor.
+ */
+ ~ObjectConnector() {}
+
+ /**
+ * @brief Copy constructor
+ */
+ ObjectConnector( const ObjectConnector& connector )
+ : mObject( connector.mObject )
+ {
+ }
+
+ /**
+ * @brief Assignment operator
+ */
+ ObjectConnector& operator=( const ObjectConnector& connector )
+ {
+ this->mObject = connector.mObject;
+ return *this;
+ }
+
+ /**
+ * @brief Returns a smart pointer to the object
+ * @return a smart pointer to the object
+ */
+ ObjectPtr Get() const
+ {
+ return mObject;
+ }
+
+ /**
+ * @brief Assigns the object, calling Connect and Disconnect methods accordingly, taking onStage into account.
+ * @param [in] object smart pointer to a object
+ * @param [in] onStage whether the object is used on stage or not
+ */
+ void Set( Object& object, bool onStage )
+ {
+ if ( mObject.Get() != &object )
+ {
+ // Disconnect from old object
+ if ( mObject && onStage )
+ {
+ mObject->Disconnect();
+ }
+
+ mObject = &object;
+
+ // Connect to new object
+ if ( mObject && onStage )
+ {
+ mObject->Connect();
+ }
+ }
+ }
+
+ /**
+ * @brief Manages connection reference count.
+ *
+ * Must be called from owner when connected to stage.
+ */
+ void OnStageConnect()
+ {
+ if ( mObject )
+ {
+ mObject->Connect();
+ }
+ }
+
+ /**
+ * @brief Manages connection reference count.
+ *
+ * Must be called from owner when disconnecting from stage.
+ */
+ void OnStageDisconnect()
+ {
+ if ( mObject )
+ {
+ mObject->Disconnect();
+ }
+ }
+
+private: //data
+ ObjectPtr mObject; ///< intrusive pointer to the Object. ObjectConnector owns this.
+
+};
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_OBJECT_CONNECTOR_H
--- /dev/null
+#ifndef DALI_INTERNAL_OBJECT_IMPL_HELPER_H
+#define DALI_INTERNAL_OBJECT_IMPL_HELPER_H
+
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/object/property.h> // Dali::Property
+#include <dali/public-api/object/property-index-ranges.h> // DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX
+#include <dali/internal/event/common/property-helper.h> // Dali::Internal::PropertyDetails
+
+namespace Dali
+{
+namespace Internal
+{
+
+class CustomProperty;
+class PropertyInputImpl;
+
+namespace SceneGraph
+{
+
+class PropertyBase;
+class PropertyOwner;
+
+
+} // namespace SceneGraph
+
+/**
+ * Helper template class to be used by class that implement Object
+ *
+ * Example:
+ *<pre>
+ * typename ObjectImplHelper<DEFAULT_PROPERTY_COUNT, DEFAULT_PROPERTY_DETAILS> MyObjectImpl;
+ *
+ * MyObjectImpl::GetDefaultPropertyCount();
+ * </pre>
+ */
+
+template<size_t DEFAULT_PROPERTY_COUNT>
+struct ObjectImplHelper
+{
+ const PropertyDetails* DEFAULT_PROPERTY_DETAILS;
+
+ unsigned int GetDefaultPropertyCount() const
+ {
+ return DEFAULT_PROPERTY_COUNT;
+ }
+
+ void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
+ {
+ indices.reserve( DEFAULT_PROPERTY_COUNT );
+
+ for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
+ {
+ indices.push_back( DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX + i );
+ }
+ }
+
+ const char* GetDefaultPropertyName( Property::Index index ) const
+ {
+ const char* name = NULL;
+
+ if( index >= DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX && index < DEFAULT_PROPERTY_COUNT )
+ {
+ name = DEFAULT_PROPERTY_DETAILS[index].name;
+ }
+
+ return name;
+ }
+
+ Property::Index GetDefaultPropertyIndex( const std::string& name ) const
+ {
+ Property::Index index = Property::INVALID_INDEX;
+
+ // Look for name in default properties
+ for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
+ {
+ const Internal::PropertyDetails* property = &DEFAULT_PROPERTY_DETAILS[ i ];
+ if( 0 == strcmp( name.c_str(), property->name ) ) // dont want to convert rhs to string
+ {
+ index = i;
+ break;
+ }
+ }
+
+ return index;
+ }
+
+ bool IsDefaultPropertyWritable( Property::Index index ) const
+ {
+ bool isWritable = false;
+
+ if( index >= DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX && index < DEFAULT_PROPERTY_COUNT )
+ {
+ isWritable = DEFAULT_PROPERTY_DETAILS[index].writable;
+ }
+
+ return isWritable;
+ }
+
+ bool IsDefaultPropertyAnimatable( Property::Index index ) const
+ {
+ bool isAnimatable = false;
+
+ if( index >= DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX && index < DEFAULT_PROPERTY_COUNT )
+ {
+ isAnimatable = DEFAULT_PROPERTY_DETAILS[index].animatable;
+ }
+
+ return isAnimatable;
+ }
+
+ bool IsDefaultPropertyAConstraintInput( Property::Index index ) const
+ {
+ bool isConstraintInput = false;
+
+ if( index >= DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX && index < DEFAULT_PROPERTY_COUNT )
+ {
+ isConstraintInput = DEFAULT_PROPERTY_DETAILS[index].constraintInput;
+ }
+
+ return isConstraintInput;
+ }
+
+ Property::Type GetDefaultPropertyType( Property::Index index ) const
+ {
+ Property::Type type = Property::NONE;
+
+ if( index >= DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX && index < DEFAULT_PROPERTY_COUNT )
+ {
+ type = DEFAULT_PROPERTY_DETAILS[index].type;
+ }
+
+ return type;
+ }
+
+ void SetDefaultProperty( Property::Index index,
+ const Property::Value& property ) const
+ {
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ }
+
+ void SetSceneGraphProperty( Property::Index index,
+ const CustomProperty& entry,
+ const Property::Value& value ) const
+ {
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ }
+
+ Property::Value GetDefaultProperty( Property::Index index ) const
+ {
+ Property::Value value;
+
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+
+ return value;
+ }
+
+ const SceneGraph::PropertyOwner* GetPropertyOwner() const
+ {
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return 0;
+ }
+
+ const SceneGraph::PropertyOwner* GetSceneObject() const
+ {
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return 0;
+ }
+
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const
+ {
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return 0;
+ }
+
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const
+ {
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return 0;
+ }
+
+ int GetPropertyComponentIndex( Property::Index index ) const
+ {
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return 0;
+ }
+
+};
+
+
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_OBJECT_IMPL_HELPER_H
+
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/common/property-buffer-impl.h> // Dali::Internal::PropertyBuffer
+
+// INTERNAL INCLUDES
+#include <dali/public-api/object/property-buffer.h> // Dali::Internal::PropertyBuffer
+#include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
+#include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
+
+
+namespace Dali
+{
+namespace Internal
+{
+
+namespace
+{
+
+/**
+ * |name |type |writable|animatable|constraint-input|enum for index-checking|
+ */
+DALI_PROPERTY_TABLE_BEGIN
+DALI_PROPERTY( "size", UNSIGNED_INTEGER, true, false, true, Dali::PropertyBuffer::Property::SIZE )
+DALI_PROPERTY( "buffer-format", MAP, false, false, false, Dali::PropertyBuffer::Property::BUFFER_FORMAT )
+DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
+
+const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> PROPERTY_BUFFER_IMPL = { DEFAULT_PROPERTY_DETAILS };
+
+} // unnamed namespace
+
+PropertyBufferPtr PropertyBuffer::New()
+{
+ return PropertyBufferPtr( new PropertyBuffer() );
+}
+
+void PropertyBuffer::SetSize( std::size_t size )
+{
+ //TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "MESH_REWORK" );
+}
+
+std::size_t PropertyBuffer::GetSize() const
+{
+ //TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "MESH_REWORK" );
+
+ return 0;
+}
+
+void PropertyBuffer::SetData( void* data )
+{
+ //TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "MESH_REWORK" );
+}
+
+Dali::Property::Index PropertyBuffer::GetPropertyIndex( const std::string name, std::size_t index )
+{
+ //TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "MESH_REWORK" );
+ return 0;
+}
+
+unsigned int PropertyBuffer::GetDefaultPropertyCount() const
+{
+ return PROPERTY_BUFFER_IMPL.GetDefaultPropertyCount();
+}
+
+void PropertyBuffer::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
+{
+ PROPERTY_BUFFER_IMPL.GetDefaultPropertyIndices( indices );
+}
+
+const char* PropertyBuffer::GetDefaultPropertyName(Property::Index index) const
+{
+ return PROPERTY_BUFFER_IMPL.GetDefaultPropertyName( index );
+}
+
+Property::Index PropertyBuffer::GetDefaultPropertyIndex( const std::string& name ) const
+{
+ return PROPERTY_BUFFER_IMPL.GetDefaultPropertyIndex( name );
+}
+
+bool PropertyBuffer::IsDefaultPropertyWritable( Property::Index index ) const
+{
+ return PROPERTY_BUFFER_IMPL.IsDefaultPropertyWritable( index );
+}
+
+bool PropertyBuffer::IsDefaultPropertyAnimatable( Property::Index index ) const
+{
+ return PROPERTY_BUFFER_IMPL.IsDefaultPropertyAnimatable( index );
+}
+
+bool PropertyBuffer::IsDefaultPropertyAConstraintInput( Property::Index index ) const
+{
+ return PROPERTY_BUFFER_IMPL.IsDefaultPropertyAConstraintInput( index );
+}
+
+Property::Type PropertyBuffer::GetDefaultPropertyType( Property::Index index ) const
+{
+ return PROPERTY_BUFFER_IMPL.GetDefaultPropertyType( index );
+}
+
+void PropertyBuffer::SetDefaultProperty( Property::Index index,
+ const Property::Value& propertyValue )
+{
+ PROPERTY_BUFFER_IMPL.SetDefaultProperty( index, propertyValue );
+}
+
+void PropertyBuffer::SetSceneGraphProperty( Property::Index index,
+ const CustomProperty& entry,
+ const Property::Value& value )
+{
+ PROPERTY_BUFFER_IMPL.SetSceneGraphProperty( index, entry, value );
+}
+
+Property::Value PropertyBuffer::GetDefaultProperty( Property::Index index ) const
+{
+ return PROPERTY_BUFFER_IMPL.GetDefaultProperty( index );
+}
+
+const SceneGraph::PropertyOwner* PropertyBuffer::GetPropertyOwner() const
+{
+ return PROPERTY_BUFFER_IMPL.GetPropertyOwner();
+}
+
+const SceneGraph::PropertyOwner* PropertyBuffer::GetSceneObject() const
+{
+ return PROPERTY_BUFFER_IMPL.GetSceneObject();
+}
+
+const SceneGraph::PropertyBase* PropertyBuffer::GetSceneObjectAnimatableProperty( Property::Index index ) const
+{
+ return PROPERTY_BUFFER_IMPL.GetSceneObjectAnimatableProperty( index );
+}
+
+const PropertyInputImpl* PropertyBuffer::GetSceneObjectInputProperty( Property::Index index ) const
+{
+ return PROPERTY_BUFFER_IMPL.GetSceneObjectInputProperty( index );
+}
+
+int PropertyBuffer::GetPropertyComponentIndex( Property::Index index ) const
+{
+ return PROPERTY_BUFFER_IMPL.GetPropertyComponentIndex( index );
+}
+
+bool PropertyBuffer::OnStage() const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return false;
+}
+
+void PropertyBuffer::Connect()
+{
+ // TODO: MESH_REWORK
+}
+
+void PropertyBuffer::Disconnect()
+{
+ // TODO: MESH_REWORK
+}
+
+PropertyBuffer::PropertyBuffer()
+{
+}
+
+} // namespace Internal
+} // namespace Dali
+
--- /dev/null
+#ifndef DALI_INTERNAL_PROPERTY_BUFFER_H
+#define DALI_INTERNAL_PROPERTY_BUFFER_H
+
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
+#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
+#include <dali/public-api/object/property-buffer.h> // Dali::PropertyBuffer
+#include <dali/internal/event/common/connectable.h> // Dali::Internal::Connectable
+#include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
+#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
+
+namespace Dali
+{
+namespace Internal
+{
+
+class PropertyBuffer;
+typedef IntrusivePtr<PropertyBuffer> PropertyBufferPtr;
+
+/**
+ * PropertyBuffer is an object that contains an array of structures of values that
+ * can be accessed as properties.
+ */
+class PropertyBuffer : public Object, public Connectable
+{
+public:
+
+ /**
+ * @copydoc PropertBuffer::New()
+ */
+ static PropertyBufferPtr New();
+
+ /**
+ * @copydoc PropertBuffer::SetSize()
+ */
+ void SetSize( std::size_t size );
+
+ /**
+ * @copydoc PropertBuffer::GetSize()
+ */
+ std::size_t GetSize() const;
+
+ /**
+ * @copydoc PropertBuffer::SetData()
+ */
+ void SetData( void* data );
+
+ /**
+ * @copydoc PropertBuffer::GetPropertyIndex()
+ */
+ Dali::Property::Index GetPropertyIndex( const std::string name, std::size_t index );
+
+public: // Default property extensions from Object
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
+ */
+ virtual unsigned int GetDefaultPropertyCount() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
+ */
+ virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
+ */
+ virtual const char* GetDefaultPropertyName(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
+ */
+ virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
+ */
+ virtual bool IsDefaultPropertyWritable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
+ */
+ virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
+ */
+ virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
+ */
+ virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::SetDefaultProperty()
+ */
+ virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+
+ /**
+ * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
+ */
+ virtual void SetSceneGraphProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value );
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultProperty()
+ */
+ virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyOwner()
+ */
+ virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObject()
+ */
+ virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
+ */
+ virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
+ */
+ virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
+ */
+ virtual int GetPropertyComponentIndex( Property::Index index ) const;
+
+public: // Functions from Connectable
+ /**
+ * @copydoc Dali::Internal::Connectable::OnStage()
+ */
+ virtual bool OnStage() const;
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Connect()
+ */
+ virtual void Connect();
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Disconnect()
+ */
+ virtual void Disconnect();
+
+private: // implementation
+ PropertyBuffer();
+
+private: // unimplemented methods
+ PropertyBuffer( const PropertyBuffer& );
+ PropertyBuffer& operator=( const PropertyBuffer& );
+
+};
+
+} // namespace Internal
+
+// Helpers for public-api forwarding methods
+inline Internal::PropertyBuffer& GetImplementation(Dali::PropertyBuffer& handle)
+{
+ DALI_ASSERT_ALWAYS(handle && "PropertyBuffer handle is empty");
+
+ BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<Internal::PropertyBuffer&>(object);
+}
+
+inline const Internal::PropertyBuffer& GetImplementation(const Dali::PropertyBuffer& handle)
+{
+ DALI_ASSERT_ALWAYS(handle && "PropertyBuffer handle is empty");
+
+ const BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<const Internal::PropertyBuffer&>(object);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_PROPERTY_BUFFER_H
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/effects/material-impl.h> // Dali::Internal::Material
+
+// INTERNAL INCLUDES
+#include <dali/public-api/shader-effects/material.h> // Dali::Internal::Material
+#include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
+#include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
+
+
+namespace Dali
+{
+namespace Internal
+{
+
+namespace
+{
+
+/**
+ * |name |type |writable|animatable|constraint-input|enum for index-checking|
+ */
+DALI_PROPERTY_TABLE_BEGIN
+DALI_PROPERTY( "color", VECTOR4, true, true, true, Dali::Material::Property::COLOR )
+DALI_PROPERTY( "face-culling-mode", STRING, true, false, true, Dali::Material::Property::FACE_CULLING_MODE )
+DALI_PROPERTY( "blending-mode", STRING, true, false, true, Dali::Material::Property::BLENDING_MODE )
+DALI_PROPERTY( "blend-equation", STRING, true, false, true, Dali::Material::Property::BLEND_EQUATION )
+DALI_PROPERTY( "source-blend-factor-rgb", STRING, true, false, true, Dali::Material::Property::BLENDING_SRC_FACTOR_RGB )
+DALI_PROPERTY( "destination-blend-factor-rgb", STRING, true, false, true, Dali::Material::Property::BLENDING_DEST_FACTOR_RGB )
+DALI_PROPERTY( "source-blend-factor-alpha", STRING, true, false, true, Dali::Material::Property::BLENDING_SRC_FACTOR_ALPHA )
+DALI_PROPERTY( "destination-blend-factor-alpha", STRING, true, false, true, Dali::Material::Property::BLENDING_DEST_FACTOR_ALPHA )
+DALI_PROPERTY( "blend-color", VECTOR4, true, true, true, Dali::Material::Property::BLEND_COLOR )
+DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
+
+const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> MATERIAL_IMPL = { DEFAULT_PROPERTY_DETAILS };
+
+} // unnamed namespace
+
+MaterialPtr Material::New()
+{
+ return MaterialPtr( new Material() );
+}
+
+void Material::SetShader( Shader& shader )
+{
+ mShaderConnector.Set( shader, OnStage() );
+}
+
+void Material::AddSampler( Sampler& sampler )
+{
+ SamplerConnector connector;
+ connector.Set( sampler, OnStage() );
+ mSamplerConnectors.push_back( connector );
+}
+
+std::size_t Material::GetNumberOfSamplers() const
+{
+ return mSamplerConnectors.size();
+}
+
+void Material::RemoveSampler( std::size_t index )
+{
+ mSamplerConnectors.erase( mSamplerConnectors.begin() + index );
+}
+
+void Material::SetFaceCullingMode( Dali::Material::FaceCullingMode cullingMode )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Material::SetBlendMode( BlendingMode::Type mode )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+BlendingMode::Type Material::GetBlendMode() const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return BlendingMode::AUTO;
+}
+
+void Material::SetBlendFunc( BlendingFactor::Type srcFactorRgba, BlendingFactor::Type destFactorRgba )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Material::SetBlendFunc( BlendingFactor::Type srcFactorRgb,
+ BlendingFactor::Type destFactorRgb,
+ BlendingFactor::Type srcFactorAlpha,
+ BlendingFactor::Type destFactorAlpha )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Material::GetBlendFunc( BlendingFactor::Type& srcFactorRgb,
+ BlendingFactor::Type& destFactorRgb,
+ BlendingFactor::Type& srcFactorAlpha,
+ BlendingFactor::Type& destFactorAlpha ) const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Material::SetBlendEquation( BlendingEquation::Type equationRgba )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Material::SetBlendEquation( BlendingEquation::Type equationRgb,
+ BlendingEquation::Type equationAlpha )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Material::GetBlendEquation( BlendingEquation::Type& equationRgb,
+ BlendingEquation::Type& equationAlpha ) const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Material::SetBlendColor( const Vector4& color )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+const Vector4& Material::GetBlendColor() const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return Color::WHITE;
+}
+
+unsigned int Material::GetDefaultPropertyCount() const
+{
+ return MATERIAL_IMPL.GetDefaultPropertyCount();
+}
+
+void Material::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
+{
+ MATERIAL_IMPL.GetDefaultPropertyIndices( indices );
+}
+
+const char* Material::GetDefaultPropertyName(Property::Index index) const
+{
+ return MATERIAL_IMPL.GetDefaultPropertyName( index );
+}
+
+Property::Index Material::GetDefaultPropertyIndex( const std::string& name ) const
+{
+ return MATERIAL_IMPL.GetDefaultPropertyIndex( name );
+}
+
+bool Material::IsDefaultPropertyWritable( Property::Index index ) const
+{
+ return MATERIAL_IMPL.IsDefaultPropertyWritable( index );
+}
+
+bool Material::IsDefaultPropertyAnimatable( Property::Index index ) const
+{
+ return MATERIAL_IMPL.IsDefaultPropertyAnimatable( index );
+}
+
+bool Material::IsDefaultPropertyAConstraintInput( Property::Index index ) const
+{
+ return MATERIAL_IMPL.IsDefaultPropertyAConstraintInput( index );
+}
+
+Property::Type Material::GetDefaultPropertyType( Property::Index index ) const
+{
+ return MATERIAL_IMPL.GetDefaultPropertyType( index );
+}
+
+void Material::SetDefaultProperty( Property::Index index,
+ const Property::Value& propertyValue )
+{
+ MATERIAL_IMPL.SetDefaultProperty( index, propertyValue );
+}
+
+void Material::SetSceneGraphProperty( Property::Index index,
+ const CustomProperty& entry,
+ const Property::Value& value )
+{
+ MATERIAL_IMPL.SetSceneGraphProperty( index, entry, value );
+}
+
+Property::Value Material::GetDefaultProperty( Property::Index index ) const
+{
+ return MATERIAL_IMPL.GetDefaultProperty( index );
+}
+
+const SceneGraph::PropertyOwner* Material::GetPropertyOwner() const
+{
+ return MATERIAL_IMPL.GetPropertyOwner();
+}
+
+const SceneGraph::PropertyOwner* Material::GetSceneObject() const
+{
+ return MATERIAL_IMPL.GetSceneObject();
+}
+
+const SceneGraph::PropertyBase* Material::GetSceneObjectAnimatableProperty( Property::Index index ) const
+{
+ return MATERIAL_IMPL.GetSceneObjectAnimatableProperty( index );
+}
+
+const PropertyInputImpl* Material::GetSceneObjectInputProperty( Property::Index index ) const
+{
+ return MATERIAL_IMPL.GetSceneObjectInputProperty( index );
+}
+
+int Material::GetPropertyComponentIndex( Property::Index index ) const
+{
+ return MATERIAL_IMPL.GetPropertyComponentIndex( index );
+}
+
+bool Material::OnStage() const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return false;
+}
+
+void Material::Connect()
+{
+ SamplerConnectorContainer::const_iterator end = mSamplerConnectors.end();
+ for( SamplerConnectorContainer::iterator it = mSamplerConnectors.begin();
+ it < end;
+ ++it )
+ {
+ it->OnStageConnect();
+ }
+}
+
+void Material::Disconnect()
+{
+ SamplerConnectorContainer::const_iterator end = mSamplerConnectors.end();
+ for( SamplerConnectorContainer::iterator it = mSamplerConnectors.begin();
+ it < end;
+ ++it )
+ {
+ it->OnStageDisconnect();
+ }
+}
+
+Material::Material()
+{
+}
+
+} // namespace Internal
+} // namespace Dali
+
--- /dev/null
+#ifndef DALI_INTERNAL_MATERIAL_H
+#define DALI_INTERNAL_MATERIAL_H
+
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/common/vector-wrapper.h> // std::vector
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
+#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
+#include <dali/public-api/shader-effects/material.h> // Dali::Material
+#include <dali/internal/event/common/connectable.h> // Dali::Internal::Connectable
+#include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
+#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
+#include <dali/internal/event/common/property-buffer-impl.h> // Dali::Internal::PropertyBuffer
+#include <dali/internal/event/effects/sampler-impl.h> // Dali::Internal::Sampler
+#include <dali/internal/event/effects/shader-impl.h> // Dali::Internal::Shader
+
+namespace Dali
+{
+namespace Internal
+{
+
+class Material;
+typedef IntrusivePtr<Material> MaterialPtr;
+
+/**
+ * Material is an object that connects a Shader with Samplers and can be used
+ * to shade a Geometry.
+ */
+class Material : public Object, public Connectable
+{
+public:
+
+ /**
+ * @copydoc Dali::Material::New()
+ */
+ static MaterialPtr New();
+
+ /**
+ * @copydoc Dali::Material::SetShader()
+ */
+ void SetShader( Shader& shader );
+
+ /**
+ * @copydoc Dali::Material::AddSampler()
+ */
+ void AddSampler( Sampler& sampler );
+
+ /**
+ * @copydoc Dali::Material::GetNumberOfSamplers()
+ */
+ std::size_t GetNumberOfSamplers() const;
+
+ /**
+ * @copydoc Dali::Material::RemoveSampler()
+ */
+ void RemoveSampler( std::size_t index );
+
+ /**
+ * @copydoc Dali::Material::SetFaceCullingMode()
+ */
+ void SetFaceCullingMode( Dali::Material::FaceCullingMode cullingMode );
+
+ /**
+ * @copydoc Dali::Material::SetBlendMode()
+ */
+ void SetBlendMode( BlendingMode::Type mode );
+
+ /**
+ * @copydoc Dali::Material::GetBlendMode()
+ */
+ BlendingMode::Type GetBlendMode() const;
+
+ /**
+ * @copydoc Dali::Material::SetBlendFunc()
+ */
+ void SetBlendFunc( BlendingFactor::Type srcFactorRgba, BlendingFactor::Type destFactorRgba );
+
+ /**
+ * @copydoc Dali::Material::SetBlendFunc()
+ */
+ void SetBlendFunc( BlendingFactor::Type srcFactorRgb, BlendingFactor::Type destFactorRgb,
+ BlendingFactor::Type srcFactorAlpha, BlendingFactor::Type destFactorAlpha );
+
+ /**
+ * @copydoc Dali::Material::GetBlendFunc()
+ */
+ void GetBlendFunc( BlendingFactor::Type& srcFactorRgb, BlendingFactor::Type& destFactorRgb,
+ BlendingFactor::Type& srcFactorAlpha, BlendingFactor::Type& destFactorAlpha ) const;
+
+ /**
+ * @copydoc Dali::Material::SetBlendEquation()
+ */
+ void SetBlendEquation( BlendingEquation::Type equationRgba );
+
+ /**
+ * @copydoc Dali::Material::SetBlendEquation()
+ */
+ void SetBlendEquation( BlendingEquation::Type equationRgb, BlendingEquation::Type equationAlpha );
+
+ /**
+ * @copydoc Dali::Material::GetBlendEquation()
+ */
+ void GetBlendEquation( BlendingEquation::Type& equationRgb, BlendingEquation::Type& equationAlpha ) const;
+
+ /**
+ * @copydoc Dali::Material::SetBlendColor()
+ */
+ void SetBlendColor( const Vector4& color );
+
+ /**
+ * @copydoc Dali::Material::GetBlendColor()
+ */
+ const Vector4& GetBlendColor() const;
+
+public: // Default property extensions from Object
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
+ */
+ virtual unsigned int GetDefaultPropertyCount() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
+ */
+ virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
+ */
+ virtual const char* GetDefaultPropertyName(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
+ */
+ virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
+ */
+ virtual bool IsDefaultPropertyWritable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
+ */
+ virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
+ */
+ virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
+ */
+ virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::SetDefaultProperty()
+ */
+ virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+
+ /**
+ * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
+ */
+ virtual void SetSceneGraphProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value );
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultProperty()
+ */
+ virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyOwner()
+ */
+ virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObject()
+ */
+ virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
+ */
+ virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
+ */
+ virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
+ */
+ virtual int GetPropertyComponentIndex( Property::Index index ) const;
+
+public: // Functions from Connectable
+ /**
+ * @copydoc Dali::Internal::Connectable::OnStage()
+ */
+ virtual bool OnStage() const;
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Connect()
+ */
+ virtual void Connect();
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Disconnect()
+ */
+ virtual void Disconnect();
+
+private: // implementation
+ Material();
+
+private: // unimplemented methods
+ Material( const Material& );
+ Material& operator=( const Material& );
+
+private: //data
+ typedef ObjectConnector<Shader> ShaderConnector;
+ ShaderConnector mShaderConnector; ///< Connector that holds the shader used by this material
+
+ typedef ObjectConnector<Sampler> SamplerConnector;
+ typedef std::vector< SamplerConnector > SamplerConnectorContainer;
+ SamplerConnectorContainer mSamplerConnectors; ///< Vector of connectors that hold the samplers used by this material
+
+};
+
+} // namespace Internal
+
+// Helpers for public-api forwarding methods
+inline Internal::Material& GetImplementation( Dali::Material& handle )
+{
+ DALI_ASSERT_ALWAYS(handle && "Material handle is empty");
+
+ BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<Internal::Material&>(object);
+}
+
+inline const Internal::Material& GetImplementation( const Dali::Material& handle )
+{
+ DALI_ASSERT_ALWAYS(handle && "Material handle is empty");
+
+ const BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<const Internal::Material&>(object);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_MATERIAL_H
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/effects/sampler-impl.h> // Dali::Internal::Sampler
+
+// INTERNAL INCLUDES
+#include <dali/public-api/shader-effects/sampler.h> // Dali::Internal::Sampler
+#include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
+#include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
+
+
+namespace Dali
+{
+namespace Internal
+{
+
+namespace
+{
+
+/**
+ * |name |type |writable|animatable|constraint-input|enum for index-checking|
+ */
+DALI_PROPERTY_TABLE_BEGIN
+DALI_PROPERTY( "minification-filter", STRING, true, false, true, Dali::Sampler::Property::MINIFICATION_FILTER )
+DALI_PROPERTY( "magnification-filter", STRING, true, false, true, Dali::Sampler::Property::MAGNIGICATION_FILTER )
+DALI_PROPERTY( "u-wrap", STRING, true, false, true, Dali::Sampler::Property::U_WRAP )
+DALI_PROPERTY( "v-wrap", STRING, true, false, true, Dali::Sampler::Property::V_WRAP )
+DALI_PROPERTY( "affects-transparency", BOOLEAN, true, false, true, Dali::Sampler::Property::AFFECTS_TRANSPARENCY )
+DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
+
+const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> SAMPLER_IMPL = { DEFAULT_PROPERTY_DETAILS };
+
+} // unnamed namespace
+
+SamplerPtr Sampler::New()
+{
+ return SamplerPtr( new Sampler() );
+}
+
+void Sampler::SetUniformName( const std::string& name )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Sampler::SetImage( Image& image )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Sampler::SetFilterMode( Dali::Sampler::FilterMode minFilter, Dali::Sampler::FilterMode magFilter )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Sampler::SetWrapMode( Dali::Sampler::WrapMode uWrap, Dali::Sampler::WrapMode vWrap )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+void Sampler::SetAffectsTransparency( bool affectsTransparency )
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+}
+
+unsigned int Sampler::GetDefaultPropertyCount() const
+{
+ return SAMPLER_IMPL.GetDefaultPropertyCount();
+}
+
+void Sampler::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
+{
+ SAMPLER_IMPL.GetDefaultPropertyIndices( indices );
+}
+
+const char* Sampler::GetDefaultPropertyName(Property::Index index) const
+{
+ return SAMPLER_IMPL.GetDefaultPropertyName( index );
+}
+
+Property::Index Sampler::GetDefaultPropertyIndex( const std::string& name ) const
+{
+ return SAMPLER_IMPL.GetDefaultPropertyIndex( name );
+}
+
+bool Sampler::IsDefaultPropertyWritable( Property::Index index ) const
+{
+ return SAMPLER_IMPL.IsDefaultPropertyWritable( index );
+}
+
+bool Sampler::IsDefaultPropertyAnimatable( Property::Index index ) const
+{
+ return SAMPLER_IMPL.IsDefaultPropertyAnimatable( index );
+}
+
+bool Sampler::IsDefaultPropertyAConstraintInput( Property::Index index ) const
+{
+ return SAMPLER_IMPL.IsDefaultPropertyAConstraintInput( index );
+}
+
+Property::Type Sampler::GetDefaultPropertyType( Property::Index index ) const
+{
+ return SAMPLER_IMPL.GetDefaultPropertyType( index );
+}
+
+void Sampler::SetDefaultProperty( Property::Index index,
+ const Property::Value& propertyValue )
+{
+ SAMPLER_IMPL.SetDefaultProperty( index, propertyValue );
+}
+
+void Sampler::SetSceneGraphProperty( Property::Index index,
+ const CustomProperty& entry,
+ const Property::Value& value )
+{
+ SAMPLER_IMPL.SetSceneGraphProperty( index, entry, value );
+}
+
+Property::Value Sampler::GetDefaultProperty( Property::Index index ) const
+{
+ return SAMPLER_IMPL.GetDefaultProperty( index );
+}
+
+const SceneGraph::PropertyOwner* Sampler::GetPropertyOwner() const
+{
+ return SAMPLER_IMPL.GetPropertyOwner();
+}
+
+const SceneGraph::PropertyOwner* Sampler::GetSceneObject() const
+{
+ return SAMPLER_IMPL.GetSceneObject();
+}
+
+const SceneGraph::PropertyBase* Sampler::GetSceneObjectAnimatableProperty( Property::Index index ) const
+{
+ return SAMPLER_IMPL.GetSceneObjectAnimatableProperty( index );
+}
+
+const PropertyInputImpl* Sampler::GetSceneObjectInputProperty( Property::Index index ) const
+{
+ return SAMPLER_IMPL.GetSceneObjectInputProperty( index );
+}
+
+int Sampler::GetPropertyComponentIndex( Property::Index index ) const
+{
+ return SAMPLER_IMPL.GetPropertyComponentIndex( index );
+}
+
+bool Sampler::OnStage() const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return false;
+}
+
+void Sampler::Connect()
+{
+ mImageConnector.OnStageConnect();
+}
+
+void Sampler::Disconnect()
+{
+ mImageConnector.OnStageDisconnect();
+}
+
+Sampler::Sampler()
+{
+}
+
+} // namespace Internal
+} // namespace Dali
+
--- /dev/null
+#ifndef DALI_INTERNAL_SAMPLER_H
+#define DALI_INTERNAL_SAMPLER_H
+
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
+#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
+#include <dali/public-api/shader-effects/sampler.h> // Dali::Sampler
+#include <dali/internal/event/common/connectable.h> // Dali::Internal::Connectable
+#include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
+#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
+#include <dali/internal/event/images/image-connector.h> // Dali::Internal::ImageConnector
+
+namespace Dali
+{
+namespace Internal
+{
+
+class Sampler;
+typedef IntrusivePtr<Sampler> SamplerPtr;
+
+/**
+ * Sampler is an object that contains an array of structures of values that
+ * can be accessed as properties.
+ */
+class Sampler : public Object, public Connectable
+{
+public:
+
+ /**
+ * Create a new Sampler.
+ * @return A smart-pointer to the newly allocated Sampler.
+ */
+ static SamplerPtr New();
+
+ /**
+ * @copydoc Dali::Sampler::SetUniformName()
+ */
+ void SetUniformName( const std::string& name );
+
+ /**
+ * @copydoc Dali::Sampler::SetImage()
+ */
+ void SetImage( Image& image );
+
+ /**
+ * @copydoc Dali::Sampler::SetFilterMode()
+ */
+ void SetFilterMode( Dali::Sampler::FilterMode minFilter, Dali::Sampler::FilterMode magFilter );
+
+ /**
+ * @copydoc Dali::Sampler::SetWrapMode()
+ */
+ void SetWrapMode( Dali::Sampler::WrapMode uWrap, Dali::Sampler::WrapMode vWrap );
+
+ /**
+ * @copydoc Dali::Sampler::SetAffectsTransparency()
+ */
+ void SetAffectsTransparency( bool affectsTransparency );
+
+public: // Default property extensions from Object
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
+ */
+ virtual unsigned int GetDefaultPropertyCount() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
+ */
+ virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
+ */
+ virtual const char* GetDefaultPropertyName(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
+ */
+ virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
+ */
+ virtual bool IsDefaultPropertyWritable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
+ */
+ virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
+ */
+ virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
+ */
+ virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::SetDefaultProperty()
+ */
+ virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+
+ /**
+ * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
+ */
+ virtual void SetSceneGraphProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value );
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultProperty()
+ */
+ virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyOwner()
+ */
+ virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObject()
+ */
+ virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
+ */
+ virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
+ */
+ virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
+ */
+ virtual int GetPropertyComponentIndex( Property::Index index ) const;
+
+public: // Functions from Connectable
+ /**
+ * @copydoc Dali::Internal::Connectable::OnStage()
+ */
+ virtual bool OnStage() const;
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Connect()
+ */
+ virtual void Connect();
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Disconnect()
+ */
+ virtual void Disconnect();
+
+private:
+ Sampler();
+
+private: // data
+ //TODO: MESH_REWORK : change to ObjectConnector
+ ImageConnector mImageConnector;
+};
+
+} // namespace Internal
+
+// Helpers for public-api forwarding methods
+inline Internal::Sampler& GetImplementation(Dali::Sampler& handle)
+{
+ DALI_ASSERT_ALWAYS(handle && "Sampler handle is empty");
+
+ BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<Internal::Sampler&>(object);
+}
+
+inline const Internal::Sampler& GetImplementation(const Dali::Sampler& handle)
+{
+ DALI_ASSERT_ALWAYS(handle && "Sampler handle is empty");
+
+ const BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<const Internal::Sampler&>(object);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_SAMPLER_H
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/effects/shader-impl.h> // Dali::Internal::Shader
+
+// INTERNAL INCLUDES
+#include <dali/public-api/shader-effects/shader.h> // Dali::Internal::Shader
+#include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
+#include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
+
+
+namespace Dali
+{
+namespace Internal
+{
+
+namespace
+{
+
+/**
+ * |name |type |writable|animatable|constraint-input|enum for index-checking|
+ */
+DALI_PROPERTY_TABLE_BEGIN
+DALI_PROPERTY( "program", MAP, true, false, false, Dali::Shader::Property::PROGRAM )
+DALI_PROPERTY( "shader-hints", UNSIGNED_INTEGER, true, false, true, Dali::Shader::Property::SHADER_HINTS )
+DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
+
+const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> SHADER_IMPL = { DEFAULT_PROPERTY_DETAILS };
+
+} // unnamed namespace
+
+ShaderPtr Shader::New( const std::string& vertexShader,
+ const std::string& fragmentShader,
+ Dali::Shader::ShaderHints hints )
+{
+ //TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS(false && "MESH REWORK");
+ return ShaderPtr( new Shader() );
+}
+
+unsigned int Shader::GetDefaultPropertyCount() const
+{
+ return SHADER_IMPL.GetDefaultPropertyCount();
+}
+
+void Shader::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
+{
+ SHADER_IMPL.GetDefaultPropertyIndices( indices );
+}
+
+const char* Shader::GetDefaultPropertyName(Property::Index index) const
+{
+ return SHADER_IMPL.GetDefaultPropertyName( index );
+}
+
+Property::Index Shader::GetDefaultPropertyIndex( const std::string& name ) const
+{
+ return SHADER_IMPL.GetDefaultPropertyIndex( name );
+}
+
+bool Shader::IsDefaultPropertyWritable( Property::Index index ) const
+{
+ return SHADER_IMPL.IsDefaultPropertyWritable( index );
+}
+
+bool Shader::IsDefaultPropertyAnimatable( Property::Index index ) const
+{
+ return SHADER_IMPL.IsDefaultPropertyAnimatable( index );
+}
+
+bool Shader::IsDefaultPropertyAConstraintInput( Property::Index index ) const
+{
+ return SHADER_IMPL.IsDefaultPropertyAConstraintInput( index );
+}
+
+Property::Type Shader::GetDefaultPropertyType( Property::Index index ) const
+{
+ return SHADER_IMPL.GetDefaultPropertyType( index );
+}
+
+void Shader::SetDefaultProperty( Property::Index index,
+ const Property::Value& propertyValue )
+{
+ SHADER_IMPL.SetDefaultProperty( index, propertyValue );
+}
+
+void Shader::SetSceneGraphProperty( Property::Index index,
+ const CustomProperty& entry,
+ const Property::Value& value )
+{
+ SHADER_IMPL.SetSceneGraphProperty( index, entry, value );
+}
+
+Property::Value Shader::GetDefaultProperty( Property::Index index ) const
+{
+ return SHADER_IMPL.GetDefaultProperty( index );
+}
+
+const SceneGraph::PropertyOwner* Shader::GetPropertyOwner() const
+{
+ return SHADER_IMPL.GetPropertyOwner();
+}
+
+const SceneGraph::PropertyOwner* Shader::GetSceneObject() const
+{
+ return SHADER_IMPL.GetSceneObject();
+}
+
+const SceneGraph::PropertyBase* Shader::GetSceneObjectAnimatableProperty( Property::Index index ) const
+{
+ return SHADER_IMPL.GetSceneObjectAnimatableProperty( index );
+}
+
+const PropertyInputImpl* Shader::GetSceneObjectInputProperty( Property::Index index ) const
+{
+ return SHADER_IMPL.GetSceneObjectInputProperty( index );
+}
+
+int Shader::GetPropertyComponentIndex( Property::Index index ) const
+{
+ return SHADER_IMPL.GetPropertyComponentIndex( index );
+}
+
+bool Shader::OnStage() const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return false;
+}
+
+void Shader::Connect()
+{
+}
+
+void Shader::Disconnect()
+{
+}
+
+Shader::Shader()
+{
+}
+
+} // namespace Internal
+} // namespace Dali
+
--- /dev/null
+#ifndef DALI_INTERNAL_SHADER_H
+#define DALI_INTERNAL_SHADER_H
+
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
+#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
+#include <dali/public-api/shader-effects/shader.h> // Dali::Shader
+#include <dali/internal/event/common/connectable.h> // Dali::Internal::Connectable
+#include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
+#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
+
+namespace Dali
+{
+namespace Internal
+{
+
+class Shader;
+typedef IntrusivePtr<Shader> ShaderPtr;
+
+/**
+ * Shader is an object that contains an array of structures of values that
+ * can be accessed as properties.
+ */
+class Shader : public Object, public Connectable
+{
+public:
+
+ /**
+ * @copydoc Dali::Shader::New()
+ */
+ static ShaderPtr New( const std::string& vertexShader,
+ const std::string& fragmentShader,
+ Dali::Shader::ShaderHints hints );
+
+public: // Default property extensions from Object
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
+ */
+ virtual unsigned int GetDefaultPropertyCount() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
+ */
+ virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
+ */
+ virtual const char* GetDefaultPropertyName(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
+ */
+ virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
+ */
+ virtual bool IsDefaultPropertyWritable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
+ */
+ virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
+ */
+ virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
+ */
+ virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::SetDefaultProperty()
+ */
+ virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+
+ /**
+ * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
+ */
+ virtual void SetSceneGraphProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value );
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultProperty()
+ */
+ virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyOwner()
+ */
+ virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObject()
+ */
+ virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
+ */
+ virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
+ */
+ virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
+ */
+ virtual int GetPropertyComponentIndex( Property::Index index ) const;
+
+public: // Functions from Connectable
+ /**
+ * @copydoc Dali::Internal::Connectable::OnStage()
+ */
+ virtual bool OnStage() const;
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Connect()
+ */
+ virtual void Connect();
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Disconnect()
+ */
+ virtual void Disconnect();
+
+private: // implementation
+ Shader();
+
+private: // unimplemented methods
+ Shader( const Shader& );
+ Shader& operator=( const Shader& );
+
+};
+
+} // namespace Internal
+
+// Helpers for public-api forwarding methods
+inline Internal::Shader& GetImplementation( Dali::Shader& handle )
+{
+ DALI_ASSERT_ALWAYS(handle && "Shader handle is empty");
+
+ BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<Internal::Shader&>(object);
+}
+
+inline const Internal::Shader& GetImplementation( const Dali::Shader& handle )
+{
+ DALI_ASSERT_ALWAYS(handle && "Shader handle is empty");
+
+ const BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<const Internal::Shader&>(object);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_SHADER_H
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/geometry/geometry-impl.h> // Dali::Internal::Geometry
+
+// INTERNAL INCLUDES
+#include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
+#include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
+
+
+namespace Dali
+{
+namespace Internal
+{
+
+namespace
+{
+
+/**
+ * |name |type |writable|animatable|constraint-input|enum for index-checking|
+ */
+DALI_PROPERTY_TABLE_BEGIN
+DALI_PROPERTY( "geometry-type", STRING, true, false, true, Dali::Geometry::Property::GEOMETRY_TYPE )
+DALI_PROPERTY( "geometry-center", VECTOR3, true, true, true, Dali::Geometry::Property::GEOMETRY_CENTER )
+DALI_PROPERTY( "geometry-half-extents", VECTOR3, true, true, true, Dali::Geometry::Property::GEOMETRY_HALF_EXTENTS )
+DALI_PROPERTY( "requires-depth-test", BOOLEAN, true, false, true, Dali::Geometry::Property::REQUIRES_DEPTH_TEST )
+DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
+
+const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> GEOMETRY_IMPL = { DEFAULT_PROPERTY_DETAILS };
+
+} // unnamed namespace
+
+GeometryPtr Geometry::New()
+{
+ return GeometryPtr( new Geometry() );
+}
+
+std::size_t Geometry::AddVertexBuffer( PropertyBuffer& vertexBuffer )
+{
+ PropertyBufferConnector connector;
+ connector.Set( vertexBuffer, OnStage() );
+ mVertexBufferConnectors.push_back( connector );
+ return mVertexBufferConnectors.size() - 1u;
+}
+
+std::size_t Geometry::GetNumberOfVertexBuffers() const
+{
+ return mVertexBufferConnectors.size();
+}
+
+void Geometry::RemoveVertexBuffer( std::size_t index )
+{
+ mVertexBufferConnectors.erase( mVertexBufferConnectors.begin() + index );
+}
+
+void Geometry::SetIndexBuffer( PropertyBuffer& indexBuffer )
+{
+ mIndexBufferConnector.Set( indexBuffer, OnStage() );
+}
+
+void Geometry::SetGeometryType( Dali::Geometry::GeometryType geometryType )
+{
+ //TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "MESH REWORK" );
+}
+
+Dali::Geometry::GeometryType Geometry::GetGeometryType() const
+{
+ //TODO: MESH_REWORK
+ return Dali::Geometry::TRIANGLES;
+}
+
+void Geometry::SetRequiresDepthTesting( bool requiresDepthTest )
+{
+ //TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "MESH REWORK" );
+}
+
+bool Geometry::GetRequiresDepthTesting() const
+{
+ //TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "MESH REWORK" );
+ return false;
+}
+
+unsigned int Geometry::GetDefaultPropertyCount() const
+{
+ return GEOMETRY_IMPL.GetDefaultPropertyCount();
+}
+
+void Geometry::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
+{
+ GEOMETRY_IMPL.GetDefaultPropertyIndices( indices );
+}
+
+const char* Geometry::GetDefaultPropertyName(Property::Index index) const
+{
+ return GEOMETRY_IMPL.GetDefaultPropertyName( index );
+}
+
+Property::Index Geometry::GetDefaultPropertyIndex( const std::string& name ) const
+{
+ return GEOMETRY_IMPL.GetDefaultPropertyIndex( name );
+}
+
+bool Geometry::IsDefaultPropertyWritable( Property::Index index ) const
+{
+ return GEOMETRY_IMPL.IsDefaultPropertyWritable( index );
+}
+
+bool Geometry::IsDefaultPropertyAnimatable( Property::Index index ) const
+{
+ return GEOMETRY_IMPL.IsDefaultPropertyAnimatable( index );
+}
+
+bool Geometry::IsDefaultPropertyAConstraintInput( Property::Index index ) const
+{
+ return GEOMETRY_IMPL.IsDefaultPropertyAConstraintInput( index );
+}
+
+Property::Type Geometry::GetDefaultPropertyType( Property::Index index ) const
+{
+ return GEOMETRY_IMPL.GetDefaultPropertyType( index );
+}
+
+void Geometry::SetDefaultProperty( Property::Index index,
+ const Property::Value& propertyValue )
+{
+ GEOMETRY_IMPL.SetDefaultProperty( index, propertyValue );
+}
+
+void Geometry::SetSceneGraphProperty( Property::Index index,
+ const CustomProperty& entry,
+ const Property::Value& value )
+{
+ GEOMETRY_IMPL.SetSceneGraphProperty( index, entry, value );
+}
+
+Property::Value Geometry::GetDefaultProperty( Property::Index index ) const
+{
+ return GEOMETRY_IMPL.GetDefaultProperty( index );
+}
+
+const SceneGraph::PropertyOwner* Geometry::GetPropertyOwner() const
+{
+ return GEOMETRY_IMPL.GetPropertyOwner();
+}
+
+const SceneGraph::PropertyOwner* Geometry::GetSceneObject() const
+{
+ return GEOMETRY_IMPL.GetSceneObject();
+}
+
+const SceneGraph::PropertyBase* Geometry::GetSceneObjectAnimatableProperty( Property::Index index ) const
+{
+ return GEOMETRY_IMPL.GetSceneObjectAnimatableProperty( index );
+}
+
+const PropertyInputImpl* Geometry::GetSceneObjectInputProperty( Property::Index index ) const
+{
+ return GEOMETRY_IMPL.GetSceneObjectInputProperty( index );
+}
+
+int Geometry::GetPropertyComponentIndex( Property::Index index ) const
+{
+ return GEOMETRY_IMPL.GetPropertyComponentIndex( index );
+}
+
+bool Geometry::OnStage() const
+{
+ // TODO: MESH_REWORK
+ DALI_ASSERT_ALWAYS( false && "TODO: MESH_REWORK" );
+ return false;
+}
+
+void Geometry::Connect()
+{
+ PropertyBufferConnectorContainer::const_iterator end = mVertexBufferConnectors.end();
+ for( PropertyBufferConnectorContainer::iterator it = mVertexBufferConnectors.begin();
+ it < end;
+ ++it )
+ {
+ it->OnStageConnect();
+ }
+ mIndexBufferConnector.OnStageConnect();
+}
+
+void Geometry::Disconnect()
+{
+ PropertyBufferConnectorContainer::const_iterator end = mVertexBufferConnectors.end();
+ for( PropertyBufferConnectorContainer::iterator it = mVertexBufferConnectors.begin();
+ it < end;
+ ++it )
+ {
+ it->OnStageDisconnect();
+ }
+ mIndexBufferConnector.OnStageDisconnect();
+}
+
+Geometry::Geometry()
+{
+}
+
+} // namespace Internal
+} // namespace Dali
+
--- /dev/null
+#ifndef DALI_INTERNAL_GEOMETRY_H
+#define DALI_INTERNAL_GEOMETRY_H
+
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/common/vector-wrapper.h> // std::vector
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
+#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
+#include <dali/public-api/geometry/geometry.h> // Dali::Geometry
+#include <dali/internal/event/common/connectable.h> // Dali::Internal::Connectable
+#include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
+#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
+#include <dali/internal/event/common/property-buffer-impl.h> // Dali::Internal::PropertyBuffer
+
+namespace Dali
+{
+namespace Internal
+{
+
+class Geometry;
+typedef IntrusivePtr<Geometry> GeometryPtr;
+
+/**
+ * Geometry is an object that contains an array of structures of values that
+ * can be accessed as properties.
+ */
+class Geometry : public Object, public Connectable
+{
+public:
+
+ /**
+ * Create a new Geometry.
+ * @return A smart-pointer to the newly allocated Geometry.
+ */
+ static GeometryPtr New();
+
+ /**
+ * @copydoc Dali::Geometry::AddVertexBuffer()
+ */
+ std::size_t AddVertexBuffer( PropertyBuffer& vertexBuffer );
+
+ /**
+ * @copydoc Dali::Geometry::GetNumberOfVertexBuffers()
+ */
+ std::size_t GetNumberOfVertexBuffers() const;
+
+ /**
+ * @copydoc Dali::Geometry::RemoveVertexBuffer()
+ */
+ void RemoveVertexBuffer( std::size_t index );
+
+ /**
+ * @copydoc Dali::Geometry::SetIndexBuffer()
+ */
+ void SetIndexBuffer( PropertyBuffer& indexBuffer );
+
+ /**
+ * @copydoc Dali::Geometry::SetGeometryType()
+ */
+ void SetGeometryType( Dali::Geometry::GeometryType geometryType );
+
+ /**
+ * @copydoc Dali::Geometry::GetGeometryType()
+ */
+ Dali::Geometry::GeometryType GetGeometryType() const;
+
+ /**
+ * @copydoc Dali::Geometry::SetRequiresDepthTesting()
+ */
+ void SetRequiresDepthTesting( bool requiresDepthTest );
+
+ /**
+ * @copydoc Dali::Geometry::GetRequiresDepthTesting()
+ */
+ bool GetRequiresDepthTesting() const;
+
+public: // Default property extensions from Object
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
+ */
+ virtual unsigned int GetDefaultPropertyCount() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
+ */
+ virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
+ */
+ virtual const char* GetDefaultPropertyName(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
+ */
+ virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
+ */
+ virtual bool IsDefaultPropertyWritable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
+ */
+ virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
+ */
+ virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
+ */
+ virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::SetDefaultProperty()
+ */
+ virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+
+ /**
+ * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
+ */
+ virtual void SetSceneGraphProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value );
+
+ /**
+ * @copydoc Dali::Internal::Object::GetDefaultProperty()
+ */
+ virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyOwner()
+ */
+ virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObject()
+ */
+ virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
+ */
+ virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
+ */
+ virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+
+ /**
+ * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
+ */
+ virtual int GetPropertyComponentIndex( Property::Index index ) const;
+
+public: // Functions from Connectable
+ /**
+ * @copydoc Dali::Internal::Connectable::OnStage()
+ */
+ virtual bool OnStage() const;
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Connect()
+ */
+ virtual void Connect();
+
+ /**
+ * @copydoc Dali::Internal::Connectable::Disconnect()
+ */
+ virtual void Disconnect();
+
+private: // implementation
+ Geometry();
+
+private: // unimplemented methods
+ Geometry( const Geometry& );
+ Geometry& operator=( const Geometry& );
+
+private: // data
+ typedef ObjectConnector<PropertyBuffer> PropertyBufferConnector;
+ typedef std::vector< PropertyBufferConnector > PropertyBufferConnectorContainer;
+ PropertyBufferConnectorContainer mVertexBufferConnectors; ///< Vector of connectors that hold the property buffers used by this geometry
+ PropertyBufferConnector mIndexBufferConnector; ///< Connector that holds the index buffer used by this geometry
+};
+
+} // namespace Internal
+
+// Helpers for public-api forwarding methods
+inline Internal::Geometry& GetImplementation(Dali::Geometry& handle)
+{
+ DALI_ASSERT_ALWAYS(handle && "Geometry handle is empty");
+
+ BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<Internal::Geometry&>(object);
+}
+
+inline const Internal::Geometry& GetImplementation(const Dali::Geometry& handle)
+{
+ DALI_ASSERT_ALWAYS(handle && "Geometry handle is empty");
+
+ const BaseObject& object = handle.GetBaseObject();
+
+ return static_cast<const Internal::Geometry&>(object);
+}
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_GEOMETRY_H
$(internal_src_dir)/event/actors/image-actor-impl.cpp \
$(internal_src_dir)/event/actors/layer-impl.cpp \
$(internal_src_dir)/event/actors/layer-list.cpp \
+ $(internal_src_dir)/event/actors/renderer-impl.cpp \
$(internal_src_dir)/event/actors/text-actor-impl.cpp \
$(internal_src_dir)/event/actors/camera-actor-impl.cpp \
$(internal_src_dir)/event/actors/renderable-actor-impl.cpp \
$(internal_src_dir)/event/common/object-impl.cpp \
$(internal_src_dir)/event/common/object-registry-impl.cpp \
$(internal_src_dir)/event/common/projection.cpp \
- $(internal_src_dir)/event/common/property-notification-manager.cpp \
+ $(internal_src_dir)/event/common/property-buffer-impl.cpp \
$(internal_src_dir)/event/common/property-conditions-impl.cpp \
$(internal_src_dir)/event/common/property-notification-impl.cpp \
+ $(internal_src_dir)/event/common/property-notification-manager.cpp \
$(internal_src_dir)/event/common/stage-impl.cpp \
$(internal_src_dir)/event/common/system-overlay-impl.cpp \
$(internal_src_dir)/event/common/thread-local-storage.cpp \
$(internal_src_dir)/event/common/type-info-impl.cpp \
$(internal_src_dir)/event/common/type-registry-impl.cpp \
+ $(internal_src_dir)/event/effects/material-impl.cpp \
+ $(internal_src_dir)/event/effects/sampler-impl.cpp \
+ $(internal_src_dir)/event/effects/shader-impl.cpp \
$(internal_src_dir)/event/effects/shader-effect-impl.cpp \
$(internal_src_dir)/event/effects/shader-factory.cpp \
$(internal_src_dir)/event/events/actor-gesture-data.cpp \
$(internal_src_dir)/event/events/tap-gesture-detector-impl.cpp \
$(internal_src_dir)/event/events/tap-gesture-processor.cpp \
$(internal_src_dir)/event/events/touch-event-processor.cpp \
+ $(internal_src_dir)/event/geometry/geometry-impl.cpp \
$(internal_src_dir)/event/images/atlas-impl.cpp \
$(internal_src_dir)/event/images/bitmap-external.cpp \
$(internal_src_dir)/event/images/bitmap-packed-pixel.cpp \
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/public-api/actors/renderer.h> // Dali::Renderer
+
+// INTERNAL INCLUDES
+#include <dali/internal/event/actors/renderer-impl.h> // Dali::Internal::Renderer
+
+namespace Dali
+{
+
+Renderer Renderer::New( Geometry geometry, Material material )
+{
+ Internal::RendererPtr renderer = Internal::Renderer::New( );
+ return Renderer( renderer.Get() );
+}
+
+Renderer::Renderer()
+{
+}
+
+Renderer::~Renderer()
+{
+}
+
+Renderer::Renderer( const Renderer& handle )
+: Handle( handle )
+{
+}
+
+Renderer& Renderer::operator=( const Renderer& handle )
+{
+ BaseHandle::operator=( handle );
+ return *this;
+}
+
+void Renderer::SetGeometry( Geometry geometry )
+{
+ GetImplementation(*this).SetGeometry( GetImplementation(geometry) );
+}
+
+void Renderer::SetMaterial( Material material )
+{
+ GetImplementation(*this).SetMaterial( GetImplementation(material) );
+}
+
+void Renderer::SetDepthIndex( int depthIndex )
+{
+ GetImplementation(*this).SetDepthIndex( depthIndex );
+}
+
+Renderer::Renderer( Internal::Renderer* pointer )
+: Handle( pointer )
+{
+}
+
+} //namespace Dali
$(public_api_src_dir)/actors/custom-actor-impl.cpp \
$(public_api_src_dir)/actors/image-actor.cpp \
$(public_api_src_dir)/actors/layer.cpp \
+ $(public_api_src_dir)/actors/renderer.cpp \
$(public_api_src_dir)/actors/text-actor.cpp \
$(public_api_src_dir)/actors/renderable-actor.cpp \
$(public_api_src_dir)/animation/active-constraint.cpp \
$(public_api_src_dir)/events/tap-gesture-detector.cpp \
$(public_api_src_dir)/events/touch-point.cpp \
$(public_api_src_dir)/events/touch-event.cpp \
+ $(public_api_src_dir)/geometry/geometry.cpp \
$(public_api_src_dir)/geometry/spline.cpp \
$(public_api_src_dir)/images/atlas.cpp \
$(public_api_src_dir)/images/distance-field.cpp \
$(public_api_src_dir)/object/base-object.cpp \
$(public_api_src_dir)/object/object-registry.cpp \
$(public_api_src_dir)/object/property.cpp \
+ $(public_api_src_dir)/object/property-buffer.cpp \
$(public_api_src_dir)/object/property-conditions.cpp \
$(public_api_src_dir)/object/property-input.cpp \
$(public_api_src_dir)/object/property-map.cpp \
$(public_api_src_dir)/object/ref-object.cpp \
$(public_api_src_dir)/render-tasks/render-task.cpp \
$(public_api_src_dir)/render-tasks/render-task-list.cpp \
+ $(public_api_src_dir)/shader-effects/material.cpp \
+ $(public_api_src_dir)/shader-effects/sampler.cpp \
+ $(public_api_src_dir)/shader-effects/shader.cpp \
$(public_api_src_dir)/shader-effects/shader-effect.cpp \
$(public_api_src_dir)/scripting/scripting.cpp \
$(public_api_src_dir)/signals/callback.cpp \
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/public-api/geometry/geometry.h> // Dali::Geometry
+
+// INTERNAL INCLUDES
+#include <dali/internal/event/geometry/geometry-impl.h> // Dali::Internal::Geometry
+
+namespace Dali
+{
+
+Geometry Geometry::New()
+{
+ Internal::GeometryPtr renderer = Internal::Geometry::New();
+ return Geometry( renderer.Get() );
+}
+
+Geometry::Geometry()
+{
+}
+
+Geometry::~Geometry()
+{
+}
+
+Geometry::Geometry( const Geometry& handle )
+: Handle( handle )
+{
+}
+
+Geometry& Geometry::operator=( const Geometry& handle )
+{
+ BaseHandle::operator=( handle );
+ return *this;
+}
+
+std::size_t Geometry::AddVertexBuffer( PropertyBuffer vertexBuffer )
+{
+ return GetImplementation(*this).AddVertexBuffer( GetImplementation( vertexBuffer ) );
+}
+
+std::size_t Geometry::GetNumberOfVertexBuffers() const
+{
+ return GetImplementation(*this).GetNumberOfVertexBuffers();
+}
+
+void Geometry::RemoveVertexBuffer( std::size_t index )
+{
+ GetImplementation(*this).RemoveVertexBuffer( index );
+}
+
+void Geometry::SetIndexBuffer( PropertyBuffer indexBuffer )
+{
+ GetImplementation(*this).SetIndexBuffer( GetImplementation( indexBuffer ) );
+}
+
+void Geometry::SetGeometryType( GeometryType geometryType )
+{
+ GetImplementation(*this).SetGeometryType( geometryType );
+}
+
+Geometry::GeometryType Geometry::GetGeometryType() const
+{
+ return GetImplementation(*this).GetGeometryType();
+}
+
+void Geometry::SetRequiresDepthTesting( bool requiresDepthTest )
+{
+ GetImplementation(*this).SetRequiresDepthTesting( requiresDepthTest );
+}
+
+bool Geometry::GetRequiresDepthTesting() const
+{
+ return GetImplementation(*this).GetRequiresDepthTesting();
+}
+
+Geometry::Geometry( Internal::Geometry* pointer )
+: Handle( pointer )
+{
+}
+
+} //namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/public-api/object/property-buffer.h> // Dali::PropertyBuffer
+
+// INTERNAL INCLUDES
+#include <dali/public-api/object/property-map.h> // Dali::Property::Map
+#include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
+#include <dali/internal/event/common/property-buffer-impl.h> // Dali::Internal::PropertyBuffer
+
+namespace Dali
+{
+
+PropertyBuffer PropertyBuffer::New( Type type, Dali::Property::Map bufferFormat, std::size_t size )
+{
+ Internal::PropertyBufferPtr renderer = Internal::PropertyBuffer::New();
+ return PropertyBuffer( renderer.Get() );
+}
+
+PropertyBuffer::PropertyBuffer()
+{
+}
+
+PropertyBuffer::~PropertyBuffer()
+{
+}
+
+PropertyBuffer::PropertyBuffer( const PropertyBuffer& handle )
+: Handle( handle )
+{
+}
+
+PropertyBuffer& PropertyBuffer::operator=( const PropertyBuffer& handle )
+{
+ BaseHandle::operator=( handle );
+ return *this;
+}
+
+void PropertyBuffer::SetSize( std::size_t size )
+{
+ GetImplementation(*this).SetSize( size );
+}
+
+std::size_t PropertyBuffer::GetSize() const
+{
+ return GetImplementation(*this).GetSize();
+}
+
+void PropertyBuffer::SetData( void* data )
+{
+ GetImplementation(*this).SetData( data );
+}
+
+Dali::Property::Index PropertyBuffer::GetPropertyIndex( const std::string name, std::size_t index )
+{
+ return GetImplementation(*this).GetPropertyIndex( name, index );
+}
+
+PropertyBuffer::PropertyBuffer( Internal::PropertyBuffer* pointer )
+: Handle( pointer )
+{
+}
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/public-api/shader-effects/material.h> // Dali::Material
+
+// INTERNAL INCLUDES
+#include <dali/internal/event/effects/material-impl.h> // Dali::Internal::Material
+#include <dali/internal/event/effects/sampler-impl.h> // Dali::Internal::Sampler
+#include <dali/internal/event/effects/shader-impl.h> // Dali::Internal::Shader
+
+namespace Dali
+{
+
+Material Material::New( Shader shader )
+{
+ Internal::MaterialPtr material = Internal::Material::New();
+ return Material( material.Get() );
+}
+
+Material::Material()
+{
+}
+
+Material::~Material()
+{
+}
+
+Material::Material( const Material& handle )
+: Handle( handle )
+{
+}
+
+Material& Material::operator=( Material& handle )
+{
+ BaseHandle::operator=( handle );
+ return *this;
+}
+
+void Material::SetShader( Shader shader )
+{
+ GetImplementation(*this).SetShader( GetImplementation( shader ) );
+}
+
+void Material::AddSampler( Sampler sampler )
+{
+ GetImplementation(*this).AddSampler( GetImplementation( sampler ) );
+}
+
+std::size_t Material::GetNumberOfSamplers() const
+{
+ return GetImplementation(*this).GetNumberOfSamplers();
+}
+
+void Material::RemoveSampler( std::size_t index )
+{
+ GetImplementation(*this).RemoveSampler( index );
+}
+
+void Material::SetFaceCullingMode( FaceCullingMode cullingMode )
+{
+ GetImplementation(*this).SetFaceCullingMode( cullingMode );
+}
+
+void Material::SetBlendMode( BlendingMode::Type mode )
+{
+ GetImplementation(*this).SetBlendMode( mode );
+}
+
+BlendingMode::Type Material::GetBlendMode() const
+{
+ return GetImplementation(*this).GetBlendMode();
+}
+
+void Material::SetBlendFunc( BlendingFactor::Type srcFactorRgba,
+ BlendingFactor::Type destFactorRgba )
+{
+ GetImplementation(*this).SetBlendFunc( srcFactorRgba, destFactorRgba );
+}
+
+void Material::SetBlendFunc( BlendingFactor::Type srcFactorRgb,
+ BlendingFactor::Type destFactorRgb,
+ BlendingFactor::Type srcFactorAlpha,
+ BlendingFactor::Type destFactorAlpha )
+{
+ GetImplementation(*this).SetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
+}
+
+void Material::GetBlendFunc( BlendingFactor::Type& srcFactorRgb,
+ BlendingFactor::Type& destFactorRgb,
+ BlendingFactor::Type& srcFactorAlpha,
+ BlendingFactor::Type& destFactorAlpha ) const
+{
+ GetImplementation(*this).GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
+}
+
+void Material::SetBlendEquation( BlendingEquation::Type equationRgba )
+{
+ GetImplementation(*this).SetBlendEquation( equationRgba );
+}
+
+void Material::SetBlendEquation( BlendingEquation::Type equationRgb,
+ BlendingEquation::Type equationAlpha )
+{
+ GetImplementation(*this).SetBlendEquation( equationRgb, equationAlpha );
+}
+
+void Material::GetBlendEquation( BlendingEquation::Type& equationRgb,
+ BlendingEquation::Type& equationAlpha ) const
+{
+ GetImplementation(*this).GetBlendEquation( equationRgb, equationAlpha );
+}
+
+void Material::SetBlendColor( const Vector4& color )
+{
+ GetImplementation(*this).SetBlendColor( color );
+}
+
+const Vector4& Material::GetBlendColor() const
+{
+ return GetImplementation(*this).GetBlendColor();
+}
+
+Material::Material( Internal::Material* pointer )
+: Handle( pointer )
+{
+}
+
+} //namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/public-api/shader-effects/sampler.h> // Dali::Sampler
+
+// INTERNAL INCLUDES
+#include <dali/internal/event/effects/sampler-impl.h> // Dali::Internal::Sampler
+
+namespace Dali
+{
+
+Sampler Sampler::New( const std::string& uniformName )
+{
+ Internal::SamplerPtr sampler = Internal::Sampler::New();
+ return Sampler( sampler.Get() );
+}
+
+Sampler::Sampler()
+{
+}
+
+Sampler::~Sampler()
+{
+}
+
+Sampler::Sampler( const Sampler& handle )
+: Handle( handle )
+{
+}
+
+Sampler& Sampler::operator=( const Sampler& handle )
+{
+ BaseHandle::operator=( handle );
+ return *this;
+}
+
+void Sampler::SetUniformName( const std::string& name )
+{
+ GetImplementation(*this).SetUniformName( name );
+}
+
+void Sampler::SetImage( Image image )
+{
+ GetImplementation(*this).SetImage( GetImplementation( image ) );
+}
+
+void Sampler::SetFilterMode( FilterMode minFilter, FilterMode magFilter )
+{
+ GetImplementation(*this).SetFilterMode( minFilter, magFilter );
+}
+
+void Sampler::SetWrapMode( WrapMode uWrap, WrapMode vWrap )
+{
+ GetImplementation(*this).SetWrapMode( uWrap, vWrap );
+}
+
+void Sampler::SetAffectsTransparency( bool affectsTransparency )
+{
+ GetImplementation(*this).SetAffectsTransparency( affectsTransparency );
+}
+
+Sampler::Sampler(Internal::Sampler* pointer)
+: Handle( pointer )
+{
+}
+
+} //namespace Dali
+
--- /dev/null
+/*
+ * Copyright (c) 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/public-api/shader-effects/shader.h> // Dali::Shader
+
+// INTERNAL INCLUDES
+#include <dali/internal/event/effects/shader-impl.h> // Dali::Internal::Shader
+
+namespace Dali
+{
+
+Shader Shader::New( const std::string& vertexShader,
+ const std::string& fragmentShader,
+ ShaderHints hints )
+{
+ Internal::ShaderPtr renderer = Internal::Shader::New( vertexShader, fragmentShader, hints );
+ return Shader( renderer.Get() );
+}
+
+Shader::Shader()
+{
+}
+
+Shader::~Shader()
+{
+}
+
+Shader::Shader( const Shader& handle )
+: Handle( handle )
+{
+}
+
+Shader& Shader::operator=( const Shader& handle )
+{
+ BaseHandle::operator=( handle );
+ return *this;
+}
+
+Shader::Shader( Internal::Shader* pointer )
+: Handle( pointer )
+{
+}
+
+} // namespace Dali
projects / platform / core / uifw / dali-core.git / commitdiff