utc-Dali-PinchGesture.cpp
utc-Dali-PinchGestureDetector.cpp
utc-Dali-Pixel.cpp
+ utc-Dali-PropertyBuffer.cpp
utc-Dali-PropertyMap.cpp
+ utc-Dali-PropertyArray.cpp
utc-Dali-PropertyNotification.cpp
utc-Dali-PropertyValue.cpp
utc-Dali-Quaternion.cpp
mTrace.PushCall( "DynamicsShape::Initialize", "" );
}
-void TestDynamicsShape::Initialize( int type, const MeshData::VertexContainer& vertices, const MeshData::FaceIndices& faceIndices )
++void TestDynamicsShape::Initialize( int type, Geometry geometry )
+ {
- mTrace.PushCall( "DynamicsShape::Initialize", "mesh" );
++ mTrace.PushCall( "DynamicsShape::Initialize", "" );
+ }
+
TestDynamicsBody::TestDynamicsBody( TraceCallStack& trace )
: mSettings( NULL ),
mConserveVolume( false ),
public:
void Initialize( int type, const Vector3& dimensions );
-
- void Initialize( int type, const MeshData::VertexContainer& vertices, const MeshData::FaceIndices& faceIndices );
-
-public:
-
- MeshData::VertexContainer* mVertices;
- MeshData::FaceIndices* mFaces;
++ void Initialize( int type, Geometry geometry );
private:
mTrace.PushCall( "DynamicsBody::GetTransform", "" );
}
- inline void GetSoftVertices( MeshData::VertexContainer& vertices ) const
++ inline void GetSoftVertices( Geometry geometry ) const
+ {
+ mTrace.PushCall( "DynamicsBody::GetSoftVertices", "" );
+ }
private:
Dali::Integration::DynamicsBodySettings* mSettings;
publicapiactorsdir = $(publicapidir)/actors
publicapianimationdir = $(publicapidir)/animation
publicapicommondir = $(publicapidir)/common
- publicapidynamicsdir = $(publicapidir)/dynamics
publicapieventsdir = $(publicapidir)/events
+publicapigeometrydir = $(publicapidir)/geometry
publicapiimagesdir = $(publicapidir)/images
publicapimathdir = $(publicapidir)/math
- publicapimodelingdir = $(publicapidir)/modeling
publicapiobjectdir = $(publicapidir)/object
publicapirendertasksdir = $(publicapidir)/render-tasks
publicapishadereffectsdir = $(publicapidir)/shader-effects
publicapiactors_HEADERS = $(public_api_core_actors_header_files)
publicapianimation_HEADERS = $(public_api_core_animation_header_files)
publicapicommon_HEADERS = $(public_api_core_common_header_files)
- publicapidynamics_HEADERS = $(public_api_core_dynamics_header_files)
publicapievents_HEADERS = $(public_api_core_events_header_files)
+publicapigeometry_HEADERS = $(public_api_core_geometry_header_files)
publicapiimages_HEADERS = $(public_api_core_images_header_files)
publicapimath_HEADERS = $(public_api_core_math_header_files)
- publicapimodeling_HEADERS = $(public_api_core_modeling_header_files)
publicapirendertasks_HEADERS = $(public_api_core_render_tasks_header_files)
publicapiobject_HEADERS = $(public_api_core_object_header_files)
- publicapiscripting_HEADERS = $(public_api_core_scripting_header_files)
publicapisizenegotiation_HEADERS = $(public_api_core_size_negotiation_header_files)
publicapishadereffects_HEADERS = $(public_api_core_shader_effects_header_files)
publicapisignals_HEADERS = $(public_api_core_signals_header_files)
*/
// CLASS HEADER
- #include <dali/public-api/dynamics/dynamics-shape.h>
+ #include <dali/devel-api/dynamics/dynamics-shape.h>
// INTERNAL HEADERS
-#include <dali/internal/event/modeling/mesh-impl.h>
#ifdef DYNAMICS_SUPPORT
#include <dali/internal/event/dynamics/dynamics-shape-impl.h>
--- /dev/null
- $(devel_api_src_dir)/actors/mesh-actor.cpp \
+ # Add devel source files here for DALi internal developer files used by Adaptor & Toolkit
+
+ devel_api_src_files = \
- $(devel_api_src_dir)/geometry/animatable-mesh.cpp \
- $(devel_api_src_dir)/geometry/animatable-vertex.cpp \
+ $(devel_api_src_dir)/animation/path-constrainer.cpp \
+ $(devel_api_src_dir)/common/hash.cpp \
+ $(devel_api_src_dir)/common/mutex.cpp \
+ $(devel_api_src_dir)/dynamics/dynamics-body.cpp \
+ $(devel_api_src_dir)/dynamics/dynamics-body-config.cpp \
+ $(devel_api_src_dir)/dynamics/dynamics-collision.cpp \
+ $(devel_api_src_dir)/dynamics/dynamics-joint.cpp \
+ $(devel_api_src_dir)/dynamics/dynamics-shape.cpp \
+ $(devel_api_src_dir)/dynamics/dynamics-world.cpp \
+ $(devel_api_src_dir)/dynamics/dynamics-world-config.cpp \
+ $(devel_api_src_dir)/events/hit-test-algorithm.cpp \
- $(devel_api_src_dir)/geometry/mesh-data.cpp \
- $(devel_api_src_dir)/geometry/mesh-factory.cpp \
- $(devel_api_src_dir)/geometry/mesh.cpp \
+ $(devel_api_src_dir)/geometry/cloth.cpp \
- $(devel_api_src_dir)/modeling/bone.cpp \
- $(devel_api_src_dir)/modeling/material.cpp \
+ $(devel_api_src_dir)/images/atlas.cpp \
+ $(devel_api_src_dir)/images/distance-field.cpp \
-devel_api_core_actors_header_files = \
- $(devel_api_src_dir)/actors/mesh-actor.h
-
+ $(devel_api_src_dir)/scripting/scripting.cpp
+
+ # Add devel header files here DALi internal developer files used by Adaptor & Toolkit
+
- $(devel_api_src_dir)/geometry/animatable-mesh.h \
- $(devel_api_src_dir)/geometry/animatable-vertex.h \
- $(devel_api_src_dir)/geometry/cloth.h \
- $(devel_api_src_dir)/geometry/mesh.h \
- $(devel_api_src_dir)/geometry/mesh-data.h \
- $(devel_api_src_dir)/geometry/mesh-factory.h
+ devel_api_core_animation_header_files = \
+ $(devel_api_src_dir)/animation/path-constrainer.h
+
+ devel_api_core_common_header_files = \
+ $(devel_api_src_dir)/common/hash.h \
+ $(devel_api_src_dir)/common/map-wrapper.h \
+ $(devel_api_src_dir)/common/mutex.h \
+ $(devel_api_src_dir)/common/ref-counted-dali-vector.h \
+ $(devel_api_src_dir)/common/scoped-pointer.h \
+ $(devel_api_src_dir)/common/set-wrapper.h
+
+ devel_api_core_dynamics_header_files = \
+ $(devel_api_src_dir)/dynamics/dynamics.h \
+ $(devel_api_src_dir)/dynamics/dynamics-body.h \
+ $(devel_api_src_dir)/dynamics/dynamics-body-config.h \
+ $(devel_api_src_dir)/dynamics/dynamics-collision.h \
+ $(devel_api_src_dir)/dynamics/dynamics-joint.h \
+ $(devel_api_src_dir)/dynamics/dynamics-shape.h \
+ $(devel_api_src_dir)/dynamics/dynamics-world.h \
+ $(devel_api_src_dir)/dynamics/dynamics-world-config.h
+
+
+ devel_api_core_events_header_files = \
+ $(devel_api_src_dir)/events/hit-test-algorithm.h
+
+
+ devel_api_core_geometry_header_files = \
-devel_api_core_modeling_header_files = \
- $(devel_api_src_dir)/modeling/bone.h \
- $(devel_api_src_dir)/modeling/material.h
-
++ $(devel_api_src_dir)/geometry/cloth.h
+
+
+ devel_api_core_images_header_files = \
+ $(devel_api_src_dir)/images/atlas.h \
+ $(devel_api_src_dir)/images/distance-field.h \
+ $(devel_api_src_dir)/images/image-operations.h \
+ $(devel_api_src_dir)/images/native-image-interface.h
+
+ devel_api_core_object_header_files = \
+ $(devel_api_src_dir)/object/type-registry-helper.h
+
+ devel_api_core_scripting_header_files = \
+ $(devel_api_src_dir)/scripting/scripting.h
+
+
--- /dev/null
-#include <dali/devel-api/geometry/mesh-factory.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.
+ *
+ */
+
+ // CLASS HEADER
+ #include <dali/devel-api/geometry/cloth.h>
+
+ // INTERNAL INCLUDES
-: Mesh(handle)
+ #include <dali/internal/event/modeling/cloth-impl.h>
+
+ namespace Dali
+ {
+
+ namespace
+ {
+
+ } // namespace
+
+ Cloth::Cloth()
+ {
+ }
+
+ Cloth::~Cloth()
+ {
+ }
+
+ Cloth::Cloth(const Cloth& handle)
- MeshData meshData( MeshFactory::NewPlane(width, height, xSteps, ySteps, textureCoordinates) );
+ {
+ }
+
+ Cloth& Cloth::operator=(const Cloth& rhs)
+ {
+ BaseHandle::operator=(rhs);
+ return *this;
+ }
+
+ Cloth Cloth::New( const float width, const float height, const int xSteps, const int ySteps, const Rect<float>& textureCoordinates )
+ {
- Internal::ClothIPtr clothPtr = Internal::Cloth::New( meshData );
++ Dali::Geometry geometry;
++ //TODO: MESH_REWORK: create the geometry
+
-: Mesh(internal)
++ Internal::ClothIPtr clothPtr = Internal::Cloth::New( GetImplementation(geometry) );
+ return Cloth( clothPtr.Get() );
+ }
+
+ Cloth Cloth::DownCast( BaseHandle handle )
+ {
+ return Cloth( dynamic_cast<Dali::Internal::Cloth*>(handle.GetObjectPtr()) );
+ }
+
+ Cloth::Cloth(Internal::Cloth* internal)
+ {
+ }
+
+ } // namespace Dali
--- /dev/null
-#include <dali/devel-api/geometry/mesh.h>
+ #ifndef __DALI_CLOTH_H__
+ #define __DALI_CLOTH_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/math/rect.h>
+ #include <dali/public-api/math/vector4.h>
+ #include <dali/public-api/object/base-handle.h>
-class DALI_IMPORT_API Cloth : public Mesh
++#include <dali/public-api/object/property-buffer.h>
+
+ namespace Dali
+ {
+
+ namespace Internal DALI_INTERNAL
+ {
+ class Cloth;
+ }
+
+ /**
+ * @brief A Cloth is a specialized mesh that can be used and modified
+ * by the Dynamics engine.
+ */
++class DALI_IMPORT_API Cloth : public BaseHandle
+ {
+ public:
+
+ /**
+ * @brief Create an initialized plane aligned on the XY axis.
+ *
+ * @param[in] width The width of the plane
+ * @param[in] height The height of the plane
+ * @param[in] xSteps The number of vertices along the X axis
+ * @param[in] ySteps The number of vertices along the Y axis
+ * @param[in] textureCoordinates UV coordinates.
+ * @return A handle to a newly allocated Dali resource.
+ */
+ static Cloth New(const float width,
+ const float height,
+ const int xSteps,
+ const int ySteps,
+ const Rect<float>& textureCoordinates = Rect<float>(0.0f, 0.0f, 1.0f, 1.0f));
+
+
+ /**
+ * @brief Create an uninitialized Cloth; this can be initialized with Cloth::New().
+ *
+ * Calling member functions with an uninitialized Dali::Object is not allowed.
+ */
+ Cloth();
+
+ /**
+ * @brief Destructor
+ *
+ * This is non-virtual since derived Handle types must not contain data or virtual methods.
+ */
+ ~Cloth();
+
+ /**
+ * @brief This copy constructor is required for (smart) pointer semantics.
+ *
+ * @param [in] handle A reference to the copied handle
+ */
+ Cloth(const Cloth& handle);
+
+ /**
+ * @brief This assignment operator is required for (smart) pointer semantics.
+ *
+ * @param [in] rhs A reference to the copied handle
+ * @return A reference to this
+ */
+ Cloth& operator=(const Cloth& rhs);
+
+ /**
+ * @brief Downcast an Object handle to a Cloth handle.
+ *
+ * If handle points to a Cloth object the downcast produces valid
+ * handle. If not the returned handle is left uninitialized.
+ *
+ * @param[in] handle to an object
+ * @return handle to a Cloth object or an uninitialized handle
+ */
+ static Cloth DownCast( BaseHandle handle );
+
+ public: // Not intended for application developers
+
+ /**
+ * @brief This constructor is used by Dali New() methods.
+ *
+ * @param [in] cloth A pointer to a newly allocated Dali resource
+ */
+ explicit DALI_INTERNAL Cloth(Internal::Cloth* cloth);
+ };
+
+ } // namespace Dali
+
+ #endif // __DALI_CLOTH_H__
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/devel-api/geometry/mesh-data.h>
++#include <dali/public-api/geometry/geometry.h>
namespace Dali
{
virtual void SetTransform( const Vector3& position, const Quaternion& rotation ) = 0;
virtual void GetTransform( Vector3& position, Quaternion& rotation ) = 0;
- virtual void GetSoftVertices( MeshData::VertexContainer& meshData ) const = 0;
+ /**
+ * Get the vertices and normal from a soft body
+ * @param[in,out] meshData A MeshData object with preallocated space for all the vertices.
+ */
++ virtual void GetSoftVertices( Geometry geometry ) const = 0;
+
}; // class DynamicsBody
} //namespace Integration
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/devel-api/geometry/mesh-data.h>
++#include <dali/public-api/object/property-buffer.h>
namespace Dali
{
struct Vector3;
++
namespace Integration
{
*/
virtual void Initialize( int type, const Vector3& dimensions ) = 0;
- virtual void Initialize( int type, const MeshData::VertexContainer& vertices, const MeshData::FaceIndices& faceIndices ) = 0;
+ /**
+ * Initialize the shape
+ */
++ virtual void Initialize( int type, Geometry geometry ) = 0;
}; // class DynamicsShape
// INTERNAL INCLUDES
#include <dali/public-api/object/type-registry.h>
- #include <dali/public-api/scripting/scripting.h>
+ #include <dali/devel-api/scripting/scripting.h>
#include <dali/internal/event/common/property-helper.h>
+#include <dali/internal/event/effects/shader-effect-impl.h>
#include <dali/internal/event/images/image-connector.h>
#include <dali/internal/event/images/nine-patch-image-impl.h>
--- /dev/null
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ /*
-#include <dali/internal/event/modeling/mesh-impl.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.
+ *
+ */
+
+ // CLASS HEADER
+ #include <dali/internal/event/modeling/cloth-impl.h>
+
+ // EXTERNAL INCLUDES
+ #include <stdio.h>
+
+ // INTERNAL INCLUDES
-ClothIPtr Cloth::New( const Dali::MeshData& meshData )
+
+ namespace Dali
+ {
+ namespace Internal
+ {
+
- ClothIPtr cloth( new Cloth( meshData ) );
++ClothIPtr Cloth::New( Geometry& geometry )
+ {
-Cloth::Cloth( const Dali::MeshData& publicMeshData )
-: Mesh( publicMeshData, false /* not discardable */, false /* not scalable */ )
++ ClothIPtr cloth( new Cloth( geometry ) );
+ return cloth;
+ }
+
++Cloth::Cloth( Geometry& geometry )
+ {
+ }
+
+ Cloth::~Cloth()
+ {
+ }
+
+ } // namespace Internal
+ } // namespace Dali
--- /dev/null
-#include <dali/internal/event/modeling/mesh-impl.h>
+ #ifndef __DALI_INTERNAL_CLOTH_H__
+ #define __DALI_INTERNAL_CLOTH_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/devel-api/geometry/cloth.h>
-class Cloth : public Mesh
++#include <dali/internal/event/common/object-impl.h>
++#include <dali/internal/event/geometry/geometry-impl.h>
+
+ namespace Dali
+ {
+ class MeshData;
+
+ namespace Internal
+ {
+ class Cloth;
+
+ typedef IntrusivePtr<Cloth> ClothIPtr; ///< smart pointer to a Cloth
+
+ /**
+ * A single cloth in a 3D model
+ */
- static ClothIPtr New( const Dali::MeshData& clothData );
++class Cloth : public BaseObject
+ {
+ public: // construction, destruction and initialisation
+
+ /**
+ * Create a new cloth.
+ * @param[in] clothData the mesh data
+ * @return A smart-pointer to the newly allocated Cloth.
+ */
- Cloth( const Dali::MeshData& clothData );
++ static ClothIPtr New( Geometry& clothData );
+
+ /**
+ * Construct a new Cloth. This is not discardable or scalable.
+ * @param[in] clothData the mesh data
+ */
++ Cloth( Geometry& clothData );
+
+ protected:
+ /**
+ * A reference counted object may only be deleted by calling Unreference()
+ */
+ virtual ~Cloth();
+
+ private:
+ // Undefined
+ Cloth(const Cloth&);
+
+ // Undefined
+ Cloth& operator=(const Cloth& rhs);
+ };
+
+ } // namespace Internal
+
+ // Helpers for public-api forwarding methods
+
+ inline Internal::Cloth& GetImplementation(Dali::Cloth& cloth)
+ {
+ DALI_ASSERT_ALWAYS( cloth && "Cloth handle is empty" );
+
+ BaseObject& handle = cloth.GetBaseObject();
+
+ return static_cast<Internal::Cloth&>(handle);
+ }
+
+ inline const Internal::Cloth& GetImplementation(const Dali::Cloth& cloth)
+ {
+ DALI_ASSERT_ALWAYS( cloth && "Cloth handle is empty" );
+
+ const BaseObject& handle = cloth.GetBaseObject();
+
+ return static_cast<const Internal::Cloth&>(handle);
+ }
+
+ } // namespace Dali
+
+ #endif // __DALI_INTERNAL_CLOTH_H__
$(internal_src_dir)/event/images/nine-patch-image-impl.cpp \
$(internal_src_dir)/event/images/resource-image-impl.cpp \
$(internal_src_dir)/event/images/native-image-impl.cpp \
- $(internal_src_dir)/event/modeling/animatable-mesh-impl.cpp \
+ $(internal_src_dir)/event/modeling/cloth-impl.cpp \
- $(internal_src_dir)/event/modeling/material-impl.cpp \
- $(internal_src_dir)/event/modeling/mesh-impl.cpp \
$(internal_src_dir)/event/object/custom-object-internal.cpp \
$(internal_src_dir)/event/render-tasks/render-task-impl.cpp \
$(internal_src_dir)/event/render-tasks/render-task-list-impl.cpp \
--- /dev/null
- #include <dali/public-api/common/hash.h>
+#ifndef DALI_INTERNAL_SCENE_GRAPH_UNIFORM_MAP_H
+#define DALI_INTERNAL_SCENE_GRAPH_UNIFORM_MAP_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.
+ */
+
++#include <dali/devel-api/common/hash.h>
+#include <dali/internal/common/owner-container.h>
+
+#include <string>
+
+namespace Dali
+{
+namespace Internal
+{
+class PropertyInputImpl;
+
+namespace SceneGraph
+{
+
+/**
+ * The uniform map is used to map a uniform name to a property value.
+ */
+class UniformPropertyMapping
+{
+public:
+ typedef unsigned long Hash;
+
+ /**
+ * Constructor
+ */
+ UniformPropertyMapping( const std::string& theUniformName, const PropertyInputImpl* thePropertyPtr )
+ : propertyPtr( thePropertyPtr ),
+ uniformName( theUniformName ),
+ uniformNameHash( Dali::CalculateHash( theUniformName ) )
+ {
+ }
+
+ UniformPropertyMapping()
+ : propertyPtr( NULL ),
+ uniformName( "" ),
+ uniformNameHash( 0 )
+ {
+ }
+
+
+ const PropertyInputImpl* propertyPtr;
+ std::string uniformName;
+ Hash uniformNameHash;
+};
+
+/**
+ * The UniformMap class is used to map uniform names to property values. It is available
+ * in all of the classes responsible for rendering:
+ * Actor, Renderer, Geometry, PropertyBuffer, Material, Sampler, Shader.
+ *
+ * It can be observed for changes to the mapping table.
+ */
+class UniformMap
+{
+public:
+ class Observer
+ {
+ public:
+ virtual void UniformMappingsChanged(const UniformMap& mappings) = 0;
+ };
+
+ /**
+ * Constructor
+ */
+ UniformMap();
+
+ /**
+ * Destructor
+ */
+ ~UniformMap();
+
+ /**
+ * Add an observer that watches for changes in the mappings
+ */
+ void AddObserver( Observer& observer );
+
+ /**
+ * Remove an observer
+ */
+ void RemoveObserver( Observer& observer );
+
+ /**
+ * Add a map to the mappings table.
+ */
+ void Add( UniformPropertyMapping* map );
+
+ /**
+ * Remove a map from the mappings table
+ */
+ void Remove( const std::string& uniformName );
+
+ /**
+ * Find a property given the uniform name.
+ * @return The address of the property if it's in the map, or NULL otherwise.
+ */
+ const PropertyInputImpl* Find( const std::string& uniformName );
+
+ /**
+ * Get the count of uniforms in the map
+ * @return The number of uniform mappings
+ */
+ unsigned int Count() const;
+
+ /**
+ * @pre index must be in the range 0 :: Count()-1
+ * @param[in] index The index of the element to fetch
+ * @return reference to the element in the map
+ */
+ const UniformPropertyMapping& operator[]( unsigned int index ) const;
+
+private:
+ /**
+ * Helper to call the observers when the mappings have changed
+ */
+ void MappingChanged();
+
+private:
+ typedef OwnerContainer< UniformPropertyMapping* > UniformMapContainer;
+ typedef UniformMapContainer::Iterator UniformMapIter;
+ typedef Dali::Vector< Observer* > Observers;
+ typedef Observers::Iterator ObserversIter;
+
+ UniformMapContainer mUniformMaps; // Owner container of uniform maps
+
+ Observers mObservers;
+};
+
+
+} // namespace SceneGraph
+} // namespace Internal
+} // namespace Dali
+
+#endif // DALI_INTERNAL_SCENE_GRAPH_UNIFORM_MAP_H
#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/events/touch-point.h>
-
- #include <dali/public-api/images/atlas.h>
+#include <dali/public-api/geometry/geometry.h>
#include <dali/public-api/images/buffer-image.h>
- #include <dali/public-api/images/distance-field.h>
#include <dali/public-api/images/encoded-buffer-image.h>
#include <dali/public-api/images/frame-buffer-image.h>
#include <dali/public-api/images/image.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/vector4.h>
--
#include <dali/public-api/object/any.h>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/base-object.h>
#include <dali/public-api/signals/signal-slot-observers.h>
#include <dali/public-api/signals/slot-delegate.h>
+#include <dali/public-api/shader-effects/material.h>
+#include <dali/public-api/shader-effects/sampler.h>
+#include <dali/public-api/shader-effects/shader.h>
#include <dali/public-api/shader-effects/shader-effect.h>
-
#include <dali/public-api/size-negotiation/relayout-container.h>
#include <dali/public-api/dali-core-version.h>
$(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)/images/atlas.cpp \
- $(public_api_src_dir)/images/distance-field.cpp \
+ $(public_api_src_dir)/geometry/geometry.cpp \
$(public_api_src_dir)/images/image.cpp \
$(public_api_src_dir)/images/pixel.cpp \
$(public_api_src_dir)/images/buffer-image.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-array.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 \
$(public_api_src_dir)/signals/connection-tracker.cpp \
$(public_api_src_dir)/signals/connection-tracker-interface.cpp \
$(public_api_src_dir)/events/touch-point.h \
$(public_api_src_dir)/events/touch-event.h
+public_api_core_geometry_header_files = \
+ $(public_api_src_dir)/geometry/geometry.h
+
public_api_core_images_header_files = \
- $(public_api_src_dir)/images/atlas.h \
$(public_api_src_dir)/images/buffer-image.h \
- $(public_api_src_dir)/images/distance-field.h \
$(public_api_src_dir)/images/encoded-buffer-image.h \
$(public_api_src_dir)/images/frame-buffer-image.h \
$(public_api_src_dir)/images/image.h \
$(public_api_src_dir)/math/vector4.h \
$(public_api_src_dir)/math/viewport.h
-
--
public_api_core_object_header_files = \
$(public_api_src_dir)/object/any.h \
$(public_api_src_dir)/object/base-handle.h \
$(public_api_src_dir)/object/base-object.h \
$(public_api_src_dir)/object/handle.h \
$(public_api_src_dir)/object/object-registry.h \
- $(public_api_src_dir)/object/property.h \
+ $(public_api_src_dir)/object/property-array.h \
+ $(public_api_src_dir)/object/property-buffer.h \
$(public_api_src_dir)/object/property-conditions.h \
$(public_api_src_dir)/object/property-index-ranges.h \
$(public_api_src_dir)/object/property-input.h \
$(public_api_src_dir)/render-tasks/render-task-list.h
public_api_core_shader_effects_header_files = \
+ $(public_api_src_dir)/shader-effects/material.h \
+ $(public_api_src_dir)/shader-effects/sampler.h \
+ $(public_api_src_dir)/shader-effects/shader.h \
$(public_api_src_dir)/shader-effects/shader-effect.h
- public_api_core_scripting_header_files = \
- $(public_api_src_dir)/scripting/scripting.h
-
public_api_core_size_negotiation_header_files = \
$(public_api_src_dir)/size-negotiation/relayout-container.h
projects / platform / core / uifw / dali-core.git / commitdiff