From e80712e92df63ed8bb909e9cf15c565ca4ddd541 Mon Sep 17 00:00:00 2001 From: Heeyong Song Date: Thu, 17 Oct 2013 14:46:52 +0900 Subject: [PATCH] Fix a crash when exit app - Add a copy constructor in BoundingVolume class Change-Id: I16f58bb71f27c25172bd2d25820aa08c0f8a4a61 --- inc/FUiAnimBoundingVolume.h | 10 + src/ui/animations/FUiAnimBoundingVolume.cpp | 22 +- src/ui/animations/FUiAnim_BoundingVolumeImpl.cpp | 262 ++++++++++++----------- src/ui/inc/FUiAnim_BoundingVolumeImpl.h | 19 +- 4 files changed, 170 insertions(+), 143 deletions(-) diff --git a/inc/FUiAnimBoundingVolume.h b/inc/FUiAnimBoundingVolume.h index 558c40d..8e0237c 100644 --- a/inc/FUiAnimBoundingVolume.h +++ b/inc/FUiAnimBoundingVolume.h @@ -119,6 +119,15 @@ public: virtual ~BoundingVolume(void); /** + * This is the copy constructor of this class + * + * @since 3.0 + * + * @remarks Supplies different types of bounding volume, default is AABB + */ + BoundingVolume(const BoundingVolume& boundingVolume); + + /** * Initializes this instance of %BoundingVolume of AABB type with the specified parameters. * * @since 3.0 @@ -129,6 +138,7 @@ public: * @remarks The specific error code can be accessed using the GetLastResult() method. */ BoundingVolume(const Tizen::Graphics::FloatPoint3& min, const Tizen::Graphics::FloatPoint3& max); + /** * Initializes this instance of %BoundingVolume of SPHERE type with the specified parameters. * diff --git a/src/ui/animations/FUiAnimBoundingVolume.cpp b/src/ui/animations/FUiAnimBoundingVolume.cpp index d3bf67a..c7ce72a 100644 --- a/src/ui/animations/FUiAnimBoundingVolume.cpp +++ b/src/ui/animations/FUiAnimBoundingVolume.cpp @@ -44,11 +44,10 @@ namespace Tizen { namespace Ui { namespace Animations BoundingVolume::BoundingVolume() : _pBoundingVolumeImpl(null) { - _pBoundingVolumeImpl = new (std::nothrow) _BoundingVolumeImpl(); + ClearLastResult(); - SysTryLog(NID_UI_ANIM, _pBoundingVolumeImpl != null, "[E_OUT_OF_MEMORY] Memory allocation failed while creating _BoundingVolumeImpl."); - SetLastResult(E_OUT_OF_MEMORY); - //SysTryLogExeption(NID_UI_ANIM, _pBoundingVolumeImpl != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed while creating _BoundingVolumeImpl."); + _pBoundingVolumeImpl = new (std::nothrow) _BoundingVolumeImpl(); + SysTryReturnVoidResult(NID_UI_ANIM, _pBoundingVolumeImpl != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed while creating _BoundingVolumeImpl."); } BoundingVolume::~BoundingVolume(void) @@ -59,24 +58,35 @@ BoundingVolume::~BoundingVolume(void) } } +BoundingVolume::BoundingVolume(const BoundingVolume& boundingVolume) + : _pBoundingVolumeImpl(null) +{ + ClearLastResult(); + + _pBoundingVolumeImpl = new (std::nothrow) _BoundingVolumeImpl(*boundingVolume._pBoundingVolumeImpl); + SysTryReturnVoidResult(NID_UI_ANIM, _pBoundingVolumeImpl != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed while creating _BoundingVolumeImpl."); +} + BoundingVolume::BoundingVolume(const Tizen::Graphics::FloatPoint3& min, const Tizen::Graphics::FloatPoint3& max) : _pBoundingVolumeImpl(null) { + ClearLastResult(); + _Math::Vector3 minInternal(min.x,min.y,min.z); _Math::Vector3 maxInternal(max.x,max.y,max.z); _pBoundingVolumeImpl = new (std::nothrow) _BoundingVolumeImpl(minInternal,minInternal); - SysTryReturnVoidResult(NID_UI_ANIM, _pBoundingVolumeImpl != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed while creating _BoundingVolumeImpl."); } BoundingVolume::BoundingVolume(const Tizen::Graphics::FloatPoint3& center, float radius) : _pBoundingVolumeImpl(null) { + ClearLastResult(); + _Math::Vector3 centerInternal(center.x,center.y,center.z); _pBoundingVolumeImpl = new (std::nothrow) _BoundingVolumeImpl(centerInternal,radius); - SysTryReturnVoidResult(NID_UI_ANIM, _pBoundingVolumeImpl != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed while creating _BoundingVolumeImpl."); } diff --git a/src/ui/animations/FUiAnim_BoundingVolumeImpl.cpp b/src/ui/animations/FUiAnim_BoundingVolumeImpl.cpp index f6fbd1a..0b52145 100644 --- a/src/ui/animations/FUiAnim_BoundingVolumeImpl.cpp +++ b/src/ui/animations/FUiAnim_BoundingVolumeImpl.cpp @@ -29,18 +29,18 @@ #include "FUiAnim_MathMatrix4.h" -//sphere coordinates are saved in declared _BoundingVolumeImpl->Min as a center, Max.x as radius -#define CENTER Min -#define RADIUS Max.x +//sphere coordinates are saved in declared _BoundingVolumeImpl->__min as a center, __max.x as radius +#define CENTER __min +#define RADIUS __max.x namespace Tizen{ namespace Ui{ namespace Animations { _BoundingVolumeImpl::_BoundingVolumeImpl() - : State(BOUNDING_VOLUME_STATE_EMPTY) - , Type(BOUNDING_VOLUME_TYPE_AABB) - , Min(0.0f) - , Max(0.0f) + : __state(BOUNDING_VOLUME_STATE_EMPTY) + , __type(BOUNDING_VOLUME_TYPE_AABB) + , __min(0.0f) + , __max(0.0f) { } @@ -50,22 +50,30 @@ _BoundingVolumeImpl::~_BoundingVolumeImpl() } +_BoundingVolumeImpl::_BoundingVolumeImpl(const _BoundingVolumeImpl& boundingVolumeImpl) + : __state(boundingVolumeImpl.__state) + , __type(boundingVolumeImpl.__type) + , __min(boundingVolumeImpl.__min) + , __max(boundingVolumeImpl.__max) +{ +} + _BoundingVolumeImpl::_BoundingVolumeImpl(const _Math::Vector3& min, const _Math::Vector3& max) - : State(BOUNDING_VOLUME_STATE_EMPTY) - , Type(BOUNDING_VOLUME_TYPE_AABB) - , Min(0.0f) - , Max(0.0f) + : __state(BOUNDING_VOLUME_STATE_EMPTY) + , __type(BOUNDING_VOLUME_TYPE_AABB) + , __min(0.0f) + , __max(0.0f) { SysTryReturnVoidResult(NID_UI_ANIM, (min.x <= max.x && min.y <= max.y && min.z <= max.z), E_INVALID_ARG, "Invalid arguments while initializing Bounding Volume Impl max must be higher than min"); //SysTryCatch(NID_UI_ANIM, (min.x <= max.x && min.y <= max.y && min.z <= max.z), , E_INVALID_ARG, "Invalid arguments while initializing Bounding Volume Impl max must be higher than min"); - State = BOUNDING_VOLUME_STATE_VALID; - Min = min; - Max = max; + __state = BOUNDING_VOLUME_STATE_VALID; + __min = min; + __max = max; - if(Min == Max) + if(__min == __max) { - State = BOUNDING_VOLUME_STATE_ONE_POINT; + __state = BOUNDING_VOLUME_STATE_ONE_POINT; } //CATCH: @@ -73,10 +81,10 @@ _BoundingVolumeImpl::_BoundingVolumeImpl(const _Math::Vector3& min, const _Math: } _BoundingVolumeImpl::_BoundingVolumeImpl(const _Math::Vector3& center, const float radius) - : State(BOUNDING_VOLUME_STATE_EMPTY) - , Type(BOUNDING_VOLUME_TYPE_SPHERE) - , Min(0.0f) - , Max(0.0f) + : __state(BOUNDING_VOLUME_STATE_EMPTY) + , __type(BOUNDING_VOLUME_TYPE_SPHERE) + , __min(0.0f) + , __max(0.0f) { SysTryReturnVoidResult(NID_UI_ANIM, (radius >= 0), E_INVALID_ARG, "Invalid arguments while initializing Bounding Volume Impl radius must be greater than 0"); //SysTryCatch(NID_UI_ANIM, (radius >= 0), , E_INVALID_ARG, "Invalid arguments while initializing Bounding Volume Impl max must be higher than min"); @@ -85,10 +93,10 @@ _BoundingVolumeImpl::_BoundingVolumeImpl(const _Math::Vector3& center, const flo CENTER = center; RADIUS = radius; - State = BOUNDING_VOLUME_STATE_VALID; + __state = BOUNDING_VOLUME_STATE_VALID; if(RADIUS == 0) { - State = BOUNDING_VOLUME_STATE_ONE_POINT; + __state = BOUNDING_VOLUME_STATE_ONE_POINT; } //CATCH: @@ -116,17 +124,17 @@ _BoundingVolumeImpl::GetInstance(BoundingVolume* pPublic) _Math::Vector3 _BoundingVolumeImpl::GetCenter() const { - switch(Type) + switch(__type) { case BOUNDING_VOLUME_TYPE_AABB: return _Math::Vector3( - (Min.x + Max.x) * 0.5f, - (Min.y + Max.y) * 0.5f, - (Min.z + Max.z) * 0.5f); + (__min.x + __max.x) * 0.5f, + (__min.y + __max.y) * 0.5f, + (__min.z + __max.z) * 0.5f); break; case BOUNDING_VOLUME_TYPE_SPHERE: - return _Math::Vector3(Min); + return _Math::Vector3(__min); break; default: @@ -143,13 +151,13 @@ _BoundingVolumeImpl::Set(const _Math::Vector3& min, const _Math::Vector3& max) { SysTryReturnResult(NID_UI_ANIM, (min.x <= max.x && min.y <= max.y && min.z <= max.z), E_INVALID_ARG, "Invalid arguments while initializing Bounding Volume Impl max must be higher than min"); - State = BOUNDING_VOLUME_STATE_VALID; - Min = min; - Max = max; + __state = BOUNDING_VOLUME_STATE_VALID; + __min = min; + __max = max; - if(Min == Max) + if(__min == __max) { - State = BOUNDING_VOLUME_STATE_ONE_POINT; + __state = BOUNDING_VOLUME_STATE_ONE_POINT; } return E_SUCCESS; @@ -163,10 +171,10 @@ _BoundingVolumeImpl::Set(const _Math::Vector3& center, const float radius) CENTER = center; RADIUS = radius; - State = BOUNDING_VOLUME_STATE_VALID; + __state = BOUNDING_VOLUME_STATE_VALID; if(RADIUS == 0) { - State = BOUNDING_VOLUME_STATE_ONE_POINT; + __state = BOUNDING_VOLUME_STATE_ONE_POINT; } return E_SUCCESS; @@ -175,10 +183,10 @@ _BoundingVolumeImpl::Set(const _Math::Vector3& center, const float radius) result _BoundingVolumeImpl::Get(_Math::Vector3& min, _Math::Vector3& max) { - SysTryReturnResult(NID_UI_ANIM, Type == BOUNDING_VOLUME_TYPE_AABB, E_INVALID_ARG, "Invalid arguments while get values of Bounding Volume Impl, type is not BOUNDING_VOLUME_TYPE_AABB"); + SysTryReturnResult(NID_UI_ANIM, __type == BOUNDING_VOLUME_TYPE_AABB, E_INVALID_ARG, "Invalid arguments while get values of Bounding Volume Impl, type is not BOUNDING_VOLUME_TYPE_AABB"); - min = Min; - max = Max; + min = __min; + max = __max; return E_SUCCESS; } @@ -186,7 +194,7 @@ _BoundingVolumeImpl::Get(_Math::Vector3& min, _Math::Vector3& max) result _BoundingVolumeImpl::Get(_Math::Vector3& center, float& radius) { - SysTryReturnResult(NID_UI_ANIM, Type == BOUNDING_VOLUME_TYPE_SPHERE, E_INVALID_ARG, "Invalid arguments while get values of Bounding Volume Impl, type is not BOUNDING_VOLUME_TYPE_AABB"); + SysTryReturnResult(NID_UI_ANIM, __type == BOUNDING_VOLUME_TYPE_SPHERE, E_INVALID_ARG, "Invalid arguments while get values of Bounding Volume Impl, type is not BOUNDING_VOLUME_TYPE_AABB"); center = CENTER; radius = RADIUS; @@ -198,10 +206,10 @@ _BoundingVolumeImpl::Get(_Math::Vector3& center, float& radius) _Math::Vector3 _BoundingVolumeImpl::GetHalfSize() const { - switch(Type) + switch(__type) { case BOUNDING_VOLUME_TYPE_AABB: - return _Math::Vector3((Max - Min) * 0.5f); + return _Math::Vector3((__max - __min) * 0.5f); break; case BOUNDING_VOLUME_TYPE_SPHERE: @@ -223,21 +231,21 @@ _BoundingVolumeImpl::Merge(const _BoundingVolumeImpl& volume) _Math::Vector3 onePoint; const float sqrt3 = sqrt(3); - switch(Type) + switch(__type) { case BOUNDING_VOLUME_TYPE_AABB: - if (volume.State != BOUNDING_VOLUME_STATE_VALID) + if (volume.__state != BOUNDING_VOLUME_STATE_VALID) return E_INVALID_ARG; - if (State == BOUNDING_VOLUME_STATE_VALID) + if (__state == BOUNDING_VOLUME_STATE_VALID) { - switch(volume.Type) + switch(volume.__type) { case BOUNDING_VOLUME_TYPE_AABB: //this - aabb, state valid merge with rhs - aabb - Merge(volume.Min); - Merge(volume.Max); + Merge(volume.__min); + Merge(volume.__max); break; case BOUNDING_VOLUME_TYPE_SPHERE: //this - aabb, state valid merge with rhs - sphere @@ -251,19 +259,19 @@ _BoundingVolumeImpl::Merge(const _BoundingVolumeImpl& volume) break; } } - else if (State == BOUNDING_VOLUME_STATE_ONE_POINT) + else if (__state == BOUNDING_VOLUME_STATE_ONE_POINT) { - switch(volume.Type) + switch(volume.__type) { case BOUNDING_VOLUME_TYPE_AABB: //this - aabb, state one point merge with rhs - aabb - onePoint = Min; - Set(volume.Min, volume.Max); + onePoint = __min; + Set(volume.__min, volume.__max); Merge(onePoint); break; case BOUNDING_VOLUME_TYPE_SPHERE: //this - aabb, state one point merge with rhs - sphere - onePoint = Min; + onePoint = __min; Set(volume.CENTER - volume.RADIUS * sqrt3, volume.CENTER + volume.RADIUS * sqrt3); Merge(onePoint); break; @@ -276,11 +284,11 @@ _BoundingVolumeImpl::Merge(const _BoundingVolumeImpl& volume) } else { - switch(volume.Type) + switch(volume.__type) { case BOUNDING_VOLUME_TYPE_AABB: //this - aabb, state empty merge with rhs - aabb - Set(volume.Min, volume.Max); + Set(volume.__min, volume.__max); break; case BOUNDING_VOLUME_TYPE_SPHERE: //this - aabb, state empty merge with rhs - sphere @@ -298,17 +306,17 @@ _BoundingVolumeImpl::Merge(const _BoundingVolumeImpl& volume) break; case BOUNDING_VOLUME_TYPE_SPHERE: - if (volume.State != BOUNDING_VOLUME_STATE_VALID) + if (volume.__state != BOUNDING_VOLUME_STATE_VALID) return E_INVALID_ARG; - if (State == BOUNDING_VOLUME_STATE_VALID) + if (__state == BOUNDING_VOLUME_STATE_VALID) { - switch(volume.Type) + switch(volume.__type) { case BOUNDING_VOLUME_TYPE_AABB: //this - sphere, state valid merge with rhs - aabb - Merge(volume.Min); - Merge(volume.Max); + Merge(volume.__min); + Merge(volume.__max); break; case BOUNDING_VOLUME_TYPE_SPHERE: //this - sphere, state valid merge with rhs - sphere @@ -325,14 +333,14 @@ _BoundingVolumeImpl::Merge(const _BoundingVolumeImpl& volume) break; } } - else if (State == BOUNDING_VOLUME_STATE_ONE_POINT) + else if (__state == BOUNDING_VOLUME_STATE_ONE_POINT) { - switch(volume.Type) + switch(volume.__type) { case BOUNDING_VOLUME_TYPE_AABB: //this - sphere, state one point merge with rhs - aabb - Merge(volume.Min); - Merge(volume.Max); + Merge(volume.__min); + Merge(volume.__max); break; case BOUNDING_VOLUME_TYPE_SPHERE: //this - sphere, state one point merge with rhs - sphere @@ -351,12 +359,12 @@ _BoundingVolumeImpl::Merge(const _BoundingVolumeImpl& volume) } else { - switch(volume.Type) + switch(volume.__type) { case BOUNDING_VOLUME_TYPE_AABB: //this - sphere, state empty merge with rhs - aabb - onePoint = volume.Max - volume.Min; - Set(volume.Min + onePoint/2, onePoint.Length()/2); + onePoint = volume.__max - volume.__min; + Set(volume.__min + onePoint/2, onePoint.Length()/2); break; case BOUNDING_VOLUME_TYPE_SPHERE: //this - sphere, state empty merge with rhs - sphere @@ -387,34 +395,34 @@ _BoundingVolumeImpl::Merge(const _Math::Vector3& point) { _Math::Vector3 oldMin; - switch(Type) + switch(__type) { case BOUNDING_VOLUME_TYPE_AABB: - if (State == BOUNDING_VOLUME_STATE_VALID) + if (__state == BOUNDING_VOLUME_STATE_VALID) { - Min.SetMin(point); - Max.SetMax(point); + __min.SetMin(point); + __max.SetMax(point); } - else if (State == BOUNDING_VOLUME_STATE_ONE_POINT) + else if (__state == BOUNDING_VOLUME_STATE_ONE_POINT) { - Max = point; - oldMin = Min; + __max = point; + oldMin = __min; - Min.SetMin(point); - Max.SetMax(oldMin); + __min.SetMin(point); + __max.SetMax(oldMin); - State = BOUNDING_VOLUME_STATE_VALID; + __state = BOUNDING_VOLUME_STATE_VALID; } else { - Min = point; - State = BOUNDING_VOLUME_STATE_ONE_POINT; + __min = point; + __state = BOUNDING_VOLUME_STATE_ONE_POINT; } return E_SUCCESS; break; case BOUNDING_VOLUME_TYPE_SPHERE: - if (State == BOUNDING_VOLUME_STATE_VALID) + if (__state == BOUNDING_VOLUME_STATE_VALID) { oldMin = point - CENTER; if(RADIUS < oldMin.Length()) @@ -422,7 +430,7 @@ _BoundingVolumeImpl::Merge(const _Math::Vector3& point) RADIUS = oldMin.Length(); } } - else if (State == BOUNDING_VOLUME_STATE_ONE_POINT) + else if (__state == BOUNDING_VOLUME_STATE_ONE_POINT) { oldMin = point - CENTER; if(RADIUS < oldMin.Length()) @@ -430,12 +438,12 @@ _BoundingVolumeImpl::Merge(const _Math::Vector3& point) RADIUS = oldMin.Length(); } - State = BOUNDING_VOLUME_STATE_VALID; + __state = BOUNDING_VOLUME_STATE_VALID; } else { CENTER = point; - State = BOUNDING_VOLUME_STATE_ONE_POINT; + __state = BOUNDING_VOLUME_STATE_ONE_POINT; } return E_SUCCESS; break; @@ -470,13 +478,13 @@ _BoundingVolumeImpl::Translate(const _Math::Matrix4& world) { _Math::Vector3 translate(world.GetTranslation()); - SysTryReturnResult(NID_UI_ANIM, State == BOUNDING_VOLUME_STATE_VALID, E_FAILURE, "Bounding box state is not invalid"); + SysTryReturnResult(NID_UI_ANIM, __state == BOUNDING_VOLUME_STATE_VALID, E_FAILURE, "Bounding box state is not invalid"); - switch(Type) + switch(__type) { case BOUNDING_VOLUME_TYPE_AABB: - Min += translate; - Max += translate; + __min += translate; + __max += translate; return E_SUCCESS; break; @@ -497,24 +505,24 @@ _BoundingVolumeImpl::Translate(const _Math::Matrix4& world) result _BoundingVolumeImpl::Transform(const _Math::Matrix4& world) { - SysTryReturnResult(NID_UI_ANIM, State == BOUNDING_VOLUME_STATE_VALID, E_FAILURE, "Bounding volume state is invalid"); + SysTryReturnResult(NID_UI_ANIM, __state == BOUNDING_VOLUME_STATE_VALID, E_FAILURE, "Bounding volume state is invalid"); //for AABB, to allocate variables - if(Type == BOUNDING_VOLUME_TYPE_AABB) + if(__type == BOUNDING_VOLUME_TYPE_AABB) { _Math::Vector3 v[] = { //far - _Math::Vector3(Min.x, Max.y, Min.z), - _Math::Vector3(Max.x, Max.y, Min.z), - _Math::Vector3(Max.x, Min.y, Min.z), - _Math::Vector3(Min.x, Min.y, Min.z), + _Math::Vector3(__min.x, __max.y, __min.z), + _Math::Vector3(__max.x, __max.y, __min.z), + _Math::Vector3(__max.x, __min.y, __min.z), + _Math::Vector3(__min.x, __min.y, __min.z), //near - _Math::Vector3(Min.x, Max.y, Max.z), - _Math::Vector3(Max.x, Max.y, Max.z), - _Math::Vector3(Max.x, Min.y, Max.z), - _Math::Vector3(Min.x, Min.y, Max.z) + _Math::Vector3(__min.x, __max.y, __max.z), + _Math::Vector3(__max.x, __max.y, __max.z), + _Math::Vector3(__max.x, __min.y, __max.z), + _Math::Vector3(__min.x, __min.y, __max.z) }; Reset(); @@ -526,7 +534,7 @@ _BoundingVolumeImpl::Transform(const _Math::Matrix4& world) } } - switch(Type) + switch(__type) { case BOUNDING_VOLUME_TYPE_AABB: return E_SUCCESS; @@ -549,18 +557,18 @@ _BoundingVolumeImpl::Transform(const _Math::Matrix4& world) void _BoundingVolumeImpl::Reset() { - Min = _Math::Vector3(); - Max = _Math::Vector3(); - State = BOUNDING_VOLUME_STATE_EMPTY; + __min = _Math::Vector3(); + __max = _Math::Vector3(); + __state = BOUNDING_VOLUME_STATE_EMPTY; } result _BoundingVolumeImpl::IsBoxTwiceLess(const _BoundingVolumeImpl& box, bool& is) { - SysTryReturnResult(NID_UI_ANIM, Type == BOUNDING_VOLUME_TYPE_AABB, E_FAILURE, "Bounding volume type is not invalid (not AABB)"); - SysTryReturnResult(NID_UI_ANIM, box.Type == BOUNDING_VOLUME_TYPE_AABB, E_FAILURE, "Received bounding volume type is not invalid (not AABB)"); - SysTryReturnResult(NID_UI_ANIM, State == BOUNDING_VOLUME_STATE_VALID, E_FAILURE, "Bounding volume state is not invalid"); - SysTryReturnResult(NID_UI_ANIM, box.State == BOUNDING_VOLUME_STATE_VALID, E_FAILURE, "Received bounding volume state is not invalid"); + SysTryReturnResult(NID_UI_ANIM, __type == BOUNDING_VOLUME_TYPE_AABB, E_FAILURE, "Bounding volume type is not invalid (not AABB)"); + SysTryReturnResult(NID_UI_ANIM, box.__type == BOUNDING_VOLUME_TYPE_AABB, E_FAILURE, "Received bounding volume type is not invalid (not AABB)"); + SysTryReturnResult(NID_UI_ANIM, __state == BOUNDING_VOLUME_STATE_VALID, E_FAILURE, "Bounding volume state is not invalid"); + SysTryReturnResult(NID_UI_ANIM, box.__state == BOUNDING_VOLUME_STATE_VALID, E_FAILURE, "Received bounding volume state is not invalid"); const _Math::Vector3 boxHalf = box.GetHalfSize(); const _Math::Vector3 myQuart = GetHalfSize() / 2.0f; @@ -575,15 +583,15 @@ result _BoundingVolumeImpl::IsBoxTwiceLess(const _BoundingVolumeImpl& box, bool& void _BoundingVolumeImpl::print() const { - switch(Type) + switch(__type) { case BOUNDING_VOLUME_TYPE_AABB: - AppLog("min %.3f %.3f %.3f", Min.x, Min.y, Min.z); - AppLog("max %.3f %.3f %.3f", Max.x, Max.y, Max.z); + AppLog("min %.3f %.3f %.3f", __min.x, __min.y, __min.z); + AppLog("max %.3f %.3f %.3f", __max.x, __max.y, __max.z); break; case BOUNDING_VOLUME_TYPE_SPHERE: - AppLog("Center %.3f %.3f %.3f, radius %.3f", Min.x, Min.y, Min.z, Max.x); + AppLog("Center %.3f %.3f %.3f, radius %.3f", __min.x, __min.y, __min.z, __max.x); break; default: @@ -596,19 +604,19 @@ void _BoundingVolumeImpl::print() const BoundingVolumeState _BoundingVolumeImpl::GetState() const { - return State; + return __state; } BoundingVolumeType _BoundingVolumeImpl::GetType() const { - return Type; + return __type; } result _BoundingVolumeImpl::SetType(BoundingVolumeType newType) { - if(Type == newType) + if(__type == newType) { return E_SUCCESS; } @@ -617,20 +625,20 @@ _BoundingVolumeImpl::SetType(BoundingVolumeType newType) _Math::Vector3 min,max; float r; - switch(Type) + switch(__type) { case BOUNDING_VOLUME_TYPE_AABB: switch(newType) { case BOUNDING_VOLUME_TYPE_SPHERE: //convert aabb to sphere - min = Min; - max = Max; - Min = GetCenter(); - Max.Set(0.0f); + min = __min; + max = __max; + __min = GetCenter(); + __max.Set(0.0f); min = (min - max)/2; - Max.x = min.Length(); - Type = BOUNDING_VOLUME_TYPE_SPHERE; + __max.x = min.Length(); + __type = BOUNDING_VOLUME_TYPE_SPHERE; break; default: @@ -646,9 +654,9 @@ _BoundingVolumeImpl::SetType(BoundingVolumeType newType) { case BOUNDING_VOLUME_TYPE_AABB: r = RADIUS; - Min = GetCenter() - r * sqrt3; - Max = Min + 2 * r * sqrt3; - Type = BOUNDING_VOLUME_TYPE_AABB; + __min = GetCenter() - r * sqrt3; + __max = __min + 2 * r * sqrt3; + __type = BOUNDING_VOLUME_TYPE_AABB; break; default: @@ -672,10 +680,10 @@ _BoundingVolumeImpl::SetType(BoundingVolumeType newType) _BoundingVolumeImpl& _BoundingVolumeImpl::operator =(const _BoundingVolumeImpl& rhs) { - Type = rhs.Type; - State = rhs.State; - Min = rhs.Min; - Max = rhs.Max; + __type = rhs.__type; + __state = rhs.__state; + __min = rhs.__min; + __max = rhs.__max; return *this; } @@ -683,9 +691,9 @@ _BoundingVolumeImpl::operator =(const _BoundingVolumeImpl& rhs) bool _BoundingVolumeImpl::operator ==(const _BoundingVolumeImpl& rhs) const { - if(Type == rhs.Type && State == rhs.State) + if(__type == rhs.__type && __state == rhs.__state) { - if(Min == rhs.Min && Max == rhs.Max) + if(__min == rhs.__min && __max == rhs.__max) { return true; } @@ -718,7 +726,7 @@ _BoundingVolumeImpl::Equals(const Tizen::Base::Object& obj) const int _BoundingVolumeImpl::GetHashCode(void) const { - return (int)Type * 10000000 + (int)State * 1000000 + Min.x * 100000 + Min.y * 10000 + Min.z * 1000 + Max.x * 100 + Max.y * 10 + Max.z; + return (int)__type * 10000000 + (int)__state * 1000000 + __min.x * 100000 + __min.y * 10000 + __min.z * 1000 + __max.x * 100 + __max.y * 10 + __max.z; } }}} //namespace Tizen{ namespace Ui{ namespace Animations diff --git a/src/ui/inc/FUiAnim_BoundingVolumeImpl.h b/src/ui/inc/FUiAnim_BoundingVolumeImpl.h index f9d0f23..f53036e 100644 --- a/src/ui/inc/FUiAnim_BoundingVolumeImpl.h +++ b/src/ui/inc/FUiAnim_BoundingVolumeImpl.h @@ -60,6 +60,8 @@ public: */ ~_BoundingVolumeImpl(); + _BoundingVolumeImpl(const _BoundingVolumeImpl& boundingVolumeImpl); + static _BoundingVolumeImpl* GetInstance(BoundingVolume* pPublic); static const _BoundingVolumeImpl* GetInstance(const BoundingVolume* pPublic); @@ -208,32 +210,29 @@ public: bool Equals(const Tizen::Base::Object& obj) const; int GetHashCode() const; + void print() const; + +private: /** * Holds current state of this BoundingVolume */ - BoundingVolumeState State; + BoundingVolumeState __state; /** * Holds current type of this BoundingVolume */ - BoundingVolumeType Type; + BoundingVolumeType __type; /** * Minimum point of this BoundingVolume if AABB * or Center if SPHERE */ - _Math::Vector3 Min; + _Math::Vector3 __min; /** * Minimum point of this BoundingVolume if AABB * or Radius in x coordinate if SPHERE */ - _Math::Vector3 Max; - - - void print() const; - -private: - + _Math::Vector3 __max; }; -- 2.7.4