Changed the view matrix to be the inverse of the Camera View matrix in the FREE_LOOK camera.
Updated the LOOK_AT view matrix to match an equivalent FREE_LOOK camera.
Updated sorting of renderables to work with the new view space.
Updated shader viewport uniform translation to match new view space.
Change-Id: Ideeacd1990ee4ebde715362e8006b0f2adebda91
Signed-off-by: Francisco Santos <f1.santos@samsung.com>
TEST_FUNCTION( UtcDaliCameraActorReadProjectionMatrix, POSITIVE_TC_IDX );
TEST_FUNCTION( UtcDaliCameraActorAnimatedProperties, POSITIVE_TC_IDX );
TEST_FUNCTION( UtcDaliCameraActorPropertyIndices, POSITIVE_TC_IDX );
+TEST_FUNCTION( UtcDaliCameraActorCheckLookAtAndFreeLookViews01, POSITIVE_TC_IDX );
+TEST_FUNCTION( UtcDaliCameraActorCheckLookAtAndFreeLookViews02, POSITIVE_TC_IDX );
+TEST_FUNCTION( UtcDaliCameraActorCheckLookAtAndFreeLookViews03, POSITIVE_TC_IDX );
namespace
application.SendNotification();
bool bValue;
actor.GetProperty(CameraActor::INVERT_Y_AXIS).Get(bValue);
- DALI_TEST_EQUALS(true, bValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
std::vector<Property::Index> indices ;
indices.push_back(CameraActor::TYPE);
tet_infoline("Testing Dali::CameraActor Get/Set InvertYAxis");
CameraActor actor = CameraActor::New();
- DALI_TEST_EQUALS( actor.GetInvertYAxis(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
- actor.SetInvertYAxis(false);
+ actor.SetInvertYAxis(true);
- DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetInvertYAxis(), true, TEST_LOCATION );
bool bValue;
actor.GetProperty(CameraActor::INVERT_Y_AXIS).Get(bValue);
- DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, bValue, TEST_LOCATION);
}
static void UtcDaliCameraActorModelView()
DALI_TEST_CHECK( indices.size() > basicActor.GetPropertyCount() );
DALI_TEST_EQUALS( indices.size(), camera.GetPropertyCount(), TEST_LOCATION );
}
+
+static void UtcDaliCameraActorCheckLookAtAndFreeLookViews01()
+{
+ TestApplication application;
+ Stage stage = Stage::GetCurrent();
+ Vector2 stageSize = stage.GetSize();
+
+ CameraActor freeLookCameraActor = CameraActor::New(stageSize);
+ freeLookCameraActor.SetParentOrigin(ParentOrigin::CENTER);
+ freeLookCameraActor.SetType(Camera::FREE_LOOK);
+
+ Vector3 targetPosition(30.0f, 240.0f, -256.0f);
+ Actor target = Actor::New();
+ target.SetParentOrigin(ParentOrigin::CENTER);
+ target.SetPosition(targetPosition);
+
+ Constraint cameraOrientationConstraint =
+ Constraint::New<Quaternion> ( Actor::ROTATION,
+ Source( target, Actor::WORLD_POSITION ),
+ Source( freeLookCameraActor, Actor::WORLD_POSITION ),
+ Source( target, Actor::WORLD_ROTATION ),
+ &LookAt );
+ freeLookCameraActor.ApplyConstraint( cameraOrientationConstraint );
+
+ CameraActor lookAtCameraActor = CameraActor::New(stageSize);
+ lookAtCameraActor.SetType(Camera::LOOK_AT_TARGET);
+ lookAtCameraActor.SetTargetPosition(targetPosition);
+ lookAtCameraActor.SetParentOrigin(ParentOrigin::CENTER);
+
+ stage.Add(target);
+ stage.Add(freeLookCameraActor);
+ stage.Add(lookAtCameraActor);
+
+ // Create an arbitrary vector
+ for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ {
+ for( float y=-1.0f; y<1.0f; y+=0.1f )
+ {
+ for( float z=-1.0f; z<1.0f; z+=0.1f )
+ {
+ Vector3 position(x, y, z);
+ position.Normalize();
+ position *= 200.0f;
+
+ freeLookCameraActor.SetPosition(position);
+ lookAtCameraActor.SetPosition(position);
+
+ application.SendNotification();
+ application.Render();
+ application.SendNotification();
+ application.Render();
+ Matrix freeLookViewMatrix;
+ Matrix lookAtViewMatrix;
+ freeLookCameraActor.GetProperty(CameraActor::CameraActor::VIEW_MATRIX).Get(freeLookViewMatrix);
+ lookAtCameraActor.GetProperty(CameraActor::CameraActor::VIEW_MATRIX).Get(lookAtViewMatrix);
+
+ DALI_TEST_EQUALS( freeLookViewMatrix, lookAtViewMatrix, 0.01, TEST_LOCATION );
+ }
+ }
+ }
+}
+
+static void UtcDaliCameraActorCheckLookAtAndFreeLookViews02()
+{
+ TestApplication application;
+ Stage stage = Stage::GetCurrent();
+ Vector2 stageSize = stage.GetSize();
+
+ CameraActor freeLookCameraActor = CameraActor::New(stageSize);
+ freeLookCameraActor.SetParentOrigin(ParentOrigin::CENTER);
+ freeLookCameraActor.SetType(Camera::FREE_LOOK);
+
+ Vector3 targetPosition(30.0f, 240.0f, -256.0f);
+ Actor target = Actor::New();
+ target.SetParentOrigin(ParentOrigin::CENTER);
+ target.SetPosition(targetPosition);
+
+ Constraint cameraOrientationConstraint =
+ Constraint::New<Quaternion> ( Actor::ROTATION,
+ Source( target, Actor::WORLD_POSITION ),
+ Source( freeLookCameraActor, Actor::WORLD_POSITION ),
+ Source( target, Actor::WORLD_ROTATION ),
+ &LookAt );
+ freeLookCameraActor.ApplyConstraint( cameraOrientationConstraint );
+
+ CameraActor lookAtCameraActor = CameraActor::New(stageSize);
+ lookAtCameraActor.SetType(Camera::LOOK_AT_TARGET);
+ lookAtCameraActor.SetTargetPosition(targetPosition);
+ lookAtCameraActor.SetParentOrigin(ParentOrigin::CENTER);
+
+ stage.Add(target);
+ stage.Add(freeLookCameraActor);
+ stage.Add(lookAtCameraActor);
+
+ // Create an arbitrary vector
+ for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ {
+ for( float y=-1.0f; y<1.0f; y+=0.1f )
+ {
+ for( float z=-1.0f; z<1.0f; z+=0.1f )
+ {
+ Vector3 position(x, y, z);
+ position.Normalize();
+ position *= 200.0f;
+
+ freeLookCameraActor.SetPosition(position);
+ lookAtCameraActor.SetPosition(position);
+
+ application.SendNotification();
+ application.Render();
+ application.SendNotification();
+ application.Render();
+ Matrix freeLookViewMatrix;
+ Matrix lookAtViewMatrix;
+ freeLookCameraActor.GetProperty(CameraActor::CameraActor::VIEW_MATRIX).Get(freeLookViewMatrix);
+ lookAtCameraActor.GetProperty(CameraActor::CameraActor::VIEW_MATRIX).Get(lookAtViewMatrix);
+
+ Matrix freeLookWorld = freeLookCameraActor.GetCurrentWorldMatrix();
+
+ Matrix freeLookTest(false);
+ Matrix::Multiply(freeLookTest, freeLookViewMatrix, freeLookWorld);
+ DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION);
+
+ DALI_TEST_EQUALS( freeLookViewMatrix, lookAtViewMatrix, 0.01, TEST_LOCATION );
+ }
+ }
+ }
+}
+
+static void UtcDaliCameraActorCheckLookAtAndFreeLookViews03()
+{
+ TestApplication application;
+ Stage stage = Stage::GetCurrent();
+ Vector2 stageSize = stage.GetSize();
+
+ Vector3 targetPosition(Vector3::ZERO);
+
+ CameraActor lookAtCameraActor = CameraActor::New(stageSize);
+ lookAtCameraActor.SetType(Camera::LOOK_AT_TARGET);
+ lookAtCameraActor.SetTargetPosition(targetPosition);
+ lookAtCameraActor.SetParentOrigin(ParentOrigin::CENTER);
+ stage.Add(lookAtCameraActor);
+
+ Vector3 cameraOffset( 0.f, 0.f, 100.f );
+
+ CameraActor freeLookCameraActor = CameraActor::New(stageSize);
+ freeLookCameraActor.SetType(Camera::FREE_LOOK);
+ freeLookCameraActor.SetParentOrigin(ParentOrigin::CENTER);
+
+ Quaternion cameraOrientation( Radian(Degree(180.f)), Vector3::YAXIS );
+ freeLookCameraActor.SetPosition(cameraOffset);
+ freeLookCameraActor.SetRotation(cameraOrientation);
+
+ Actor cameraAnchor = Actor::New();
+ cameraAnchor.Add(lookAtCameraActor);
+ stage.Add(cameraAnchor);
+
+
+ for( float angle = 1.f; angle <= 180.f; angle += 1.f )
+ {
+ Quaternion rotation(Radian(Degree(angle)), Vector3::YAXIS);
+
+ lookAtCameraActor.SetPosition( rotation.Rotate( cameraOffset ) );
+ cameraAnchor.SetRotation( rotation );
+
+ application.SendNotification();
+ application.Render();
+ application.SendNotification();
+ application.Render();
+
+ Matrix freeLookViewMatrix;
+ freeLookCameraActor.GetProperty(CameraActor::CameraActor::VIEW_MATRIX).Get(freeLookViewMatrix);
+
+ Matrix freeLookWorld = freeLookCameraActor.GetCurrentWorldMatrix();
+
+ Matrix freeLookTest(false);
+ Matrix::Multiply( freeLookTest, freeLookViewMatrix, freeLookWorld);
+ DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION);
+ }
+}
+
Stage::GetCurrent().Add(actor);
effect.SetUniform( "uVec2", Vector2( 0.0f, 0.0f ), ShaderEffect::COORDINATE_TYPE_VIEWPORT_POSITION );
+ effect.SetUniform( "uVec2Dir", Vector2( 1.0f, 2.0f ), ShaderEffect::COORDINATE_TYPE_VIEWPORT_DIRECTION );
application.SendNotification();
application.Render();
DALI_TEST_CHECK(
application.GetGlAbstraction().CheckUniformValue(
- "uVec2", Vector2( -stageSize.x/2, stageSize.y/2 ) ) );
+ "uVec2", Vector2( stageSize.x/2, -stageSize.y/2 ) ) );
+ DALI_TEST_CHECK(
+ application.GetGlAbstraction().CheckUniformValue(
+ "uVec2Dir", Vector2( -1.0f, 2.0f ) ) );
}
static void UtcDaliShaderEffectMethodSetEffectImage()
TEST_FUNCTION( UtcDaliMatrixTranspose, POSITIVE_TC_IDX );
TEST_FUNCTION( UtcDaliMatrixOStreamOperator, POSITIVE_TC_IDX );
TEST_FUNCTION( UtcDaliMatrixMultiply, POSITIVE_TC_IDX );
-TEST_FUNCTION( UtcDaliMatrixOperatorMultiply, POSITIVE_TC_IDX );
+TEST_FUNCTION( UtcDaliMatrixOperatorMultiply01, POSITIVE_TC_IDX );
+TEST_FUNCTION( UtcDaliMatrixOperatorMultiply02, POSITIVE_TC_IDX );
TEST_FUNCTION( UtcDaliMatrixOperatorEquals, POSITIVE_TC_IDX );
TEST_FUNCTION( UtcDaliMatrixOperatorNotEquals, POSITIVE_TC_IDX );
TEST_FUNCTION( UtcDaliMatrixGetTransformComponents01, POSITIVE_TC_IDX );
TEST_FUNCTION( UtcDaliMatrixSetInverseTransformComponent02, POSITIVE_TC_IDX );
+
// Called only once before first test is run.
static void Startup()
{
DALI_TEST_EQUALS(m2, r1, 0.01f, TEST_LOCATION);
}
-static void UtcDaliMatrixOperatorMultiply()
+static void UtcDaliMatrixOperatorMultiply01()
{
+ TestApplication application;
Vector4 v1(2.0f, 5.0f, 4.0f, 0.0f);
float els[] = {2.0f, 0.0f, 0.0f, 0.0f,
DALI_TEST_EQUALS(v2, r1, 0.01f, TEST_LOCATION);
}
+static void UtcDaliMatrixOperatorMultiply02()
+{
+ TestApplication application;
+
+ Vector3 position ( 30.f, 40.f, 50.f);
+
+ Matrix m1(false);
+ m1.SetIdentity();
+ m1.SetTranslation(-position);
+
+ Vector4 positionV4(position);
+ positionV4.w=1.0f;
+ Vector4 output = m1 * positionV4;
+
+ output.w = 0.0f;
+ DALI_TEST_EQUALS(output, Vector4::ZERO, 0.01f, TEST_LOCATION);
+}
+
+
static void UtcDaliMatrixOperatorEquals()
{
Matrix m1 = Matrix::IDENTITY;
/**
* Coordinate type of the shader uniform
- * Viewport coordinates will be centered and inverted on the Y axis. Use this coordinate type
- * if your are doing a transformation in view space.
+ * Viewport coordinate types will convert from viewport to view space.
+ * Use this coordinate type if your are doing a transformation in view space.
* The texture coordinate type converts a value in actor local space to texture coodinates.
* This is useful for pixel shaders and accounts for texture atlas.
*/
enum UniformCoordinateType
{
COORDINATE_TYPE_DEFAULT, ///< Default, No transformation to be applied
- COORDINATE_TYPE_VIEWPORT_POSITION, ///< The uniform is a position vector in viewport coordinates, Needs to be converted to GL coordinates
- COORDINATE_TYPE_VIEWPORT_DIRECTION, ///< The uniform is a directional vector in viewport coordinates, Needs to be converted to GL coordinates
+ COORDINATE_TYPE_VIEWPORT_POSITION, ///< The uniform is a position vector in viewport coordinates that needs to be converted to GL view space coordinates.
+ COORDINATE_TYPE_VIEWPORT_DIRECTION, ///< The uniform is a directional vector in viewport coordinates that needs to be converted to GL view space coordinates.
COORDINATE_TYPE_TEXTURE_POSITION ///< The uniform is a position in texture coordinates.
};
Vector4 cameraOrigin = invView * Vector4( 0.f, 0.f, 0.f, 1.f );
Vector4 nearPlaneOrigin = invView * Vector4( 0.0f, 0.0f, -nearPlaneDistance, 1.0f);
- rayDir = (nearPlaneOrigin - cameraOrigin);
+ // Vector pointing from the camera to the near plane
+ rayDir = cameraOrigin - nearPlaneOrigin;
rayOrigin -= rayDir;
rayDir.Normalize();
rayDir.w = 1.0f;
SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
}
-bool CameraActor::BuildPickingRay( const Vector2& screenCoordinates, const Viewport& viewport, Vector4& rayOrigin, Vector4& rayDirection )
+bool CameraActor::BuildPickingRay( const Vector2& screenCoordinates,
+ const Viewport& viewport,
+ Vector4& rayOrigin,
+ Vector4& rayDirection )
{
bool success = true;
if( GetProjectionMode() == Dali::Camera::PERSPECTIVE_PROJECTION )
}
else
{
- // TODO someone who understands the math needs to optimise this version as well
float nearPlaneDistance = GetNearClippingPlane();
- BuildOrthoPickingRay( GetViewMatrix(), GetProjectionMatrix(), viewport, screenCoordinates.x, screenCoordinates.y, rayOrigin, rayDirection, nearPlaneDistance );
+ BuildOrthoPickingRay( GetViewMatrix(),
+ GetProjectionMatrix(),
+ viewport, screenCoordinates.x,
+ screenCoordinates.y,
+ rayOrigin,
+ rayDirection,
+ nearPlaneDistance );
}
return success;
static float ZValue(const Vector3& position, float sortModifier)
{
// inlined so we avoid a function call when sorting renderers
- return -position.z + sortModifier;
+ return position.z + sortModifier;
}
/**
const unsigned int sourceActorDepth( layer.GetDepth() );
CameraActor* cameraActor = renderTask.GetCameraActor();
- bool pickingPossible = cameraActor->BuildPickingRay( screenCoordinates, viewport, results.rayOrigin, results.rayDirection );
+ bool pickingPossible = cameraActor->BuildPickingRay(
+ screenCoordinates,
+ viewport,
+ results.rayOrigin,
+ results.rayDirection );
if( !pickingPossible )
{
return false;
{
screenCoords.x = localX;
screenCoords.y = localY;
- if( !localCamera->GetInvertYAxis() )
- {
- screenCoords.y = actorSize.y - localY;
- }
}
else
{
case Dali::ShaderEffect::COORDINATE_TYPE_VIEWPORT_POSITION :
{
/**
- * Convert from viewport coordinates to GL view
+ * Convert coordinates from viewport to GL view space
*
- * Viewport
- * (x,y)
+ * Viewport coordinate
+ * (0,0)
* +-----+
* | |
* | |
* +-----+
- * (x+width,y+height)
+ * (width,height)
*
- * GL View Coordinates
- * (-width/2,height/2)
+ * GL view space coordinates
+ * (width/2,-height/2)
* +-----+
* | |
* | |
* +-----+
- * (width/2,-height/2)
+ * (-width/2,height/2)
**/
const Rect< int >& viewport = context.GetViewport();
- value.x = value.x - viewport.width * 0.5f;
- value.y = viewport.height * 0.5f - value.y;
+ value.x = viewport.width * 0.5f - value.x;
+ value.y = value.y - viewport.height * 0.5f;
break;
}
case Dali::ShaderEffect::COORDINATE_TYPE_VIEWPORT_DIRECTION :
{
- value.y *= -1.0f;
+ // Check diagram in COORDINATE_TYPE_VIEWPORT_POSITION
+ value.x *= -1.0f;
break;
}
case Dali::ShaderEffect::COORDINATE_TYPE_TEXTURE_POSITION :
}
/**
- * Function which sorts based on the calculated depth values
+ * Function which sorts based on the calculated depth values ordering them back to front
* @param lhs item
* @param rhs item
- * @return true if right item is greater than left
+ * @return true if left item is greater than right
*/
bool SortByDepthSortValue( const RendererWithSortValue& lhs, const RendererWithSortValue& rhs )
{
- return rhs.first < lhs.first;
+ return lhs.first > rhs.first;
}
/**
{
RenderItem& item = transparentRenderList.GetItem( index );
// the default sorting function should get inlined here
- sortingHelper[ index ].first = Internal::Layer::ZValue( item.GetModelViewMatrix().GetTranslation3(), layer.transparentRenderables[ index ]->GetSortModifier() );
+ sortingHelper[ index ].first = Internal::Layer::ZValue(
+ item.GetModelViewMatrix().GetTranslation3(),
+ layer.transparentRenderables[ index ]->GetSortModifier() );
// keep the renderitem pointer in the helper so we can quickly reorder items after sort
sortingHelper[ index ].second = &item;
}
for( size_t index = 0; index < renderableCount; ++index )
{
RenderItem& item = transparentRenderList.GetItem( index );
- sortingHelper[ index ].first = (*sortFunction)( item.GetModelViewMatrix().GetTranslation3(), layer.transparentRenderables[ index ]->GetSortModifier() );
+ sortingHelper[ index ].first = (*sortFunction)(
+ item.GetModelViewMatrix().GetTranslation3(),
+ layer.transparentRenderables[ index ]->GetSortModifier() );
// keep the renderitem pointer in the helper so we can quickly reorder items after sort
sortingHelper[ index ].second = &item;
}
}
- // sort the values
+ // sort the renderers back to front, Z Axis point from near plane to far plane
std::sort( sortingHelper.begin(), sortingHelper.end(), SortByDepthSortValue );
// reorder/repopulate the renderitems in renderlist to correct order based on sortinghelper
void LookAt(Matrix& result, const Vector3& eye, const Vector3& target, const Vector3& up)
{
- Vector3 vForward = target - eye;
- vForward.Normalize();
+ Vector3 vZ = target - eye;
+ vZ.Normalize();
- Vector3 vSide = vForward.Cross(up);
- vSide.Normalize();
+ Vector3 vX = up.Cross(vZ);
+ vX.Normalize();
- Vector3 vUp = vSide.Cross(vForward);
- vUp.Normalize();
+ Vector3 vY = vZ.Cross(vX);
+ vY.Normalize();
- result.SetInverseTransformComponents(vSide, vUp, -vForward, eye);
+ result.SetInverseTransformComponents(vX, vY, vZ, eye);
}
if ((near <= 0.0f) || (far <= 0.0f) || (deltaX <= 0.0f) || (deltaY <= 0.0f) || (deltaZ <= 0.0f))
{
+ DALI_ASSERT_DEBUG("Invalid parameters passed into Frustum!");
return;
}
float* m = result.AsFloat();
- m[0] = 2.0f * near / deltaX;
+ m[0] = -2.0f * near / deltaX;
m[1] = m[2] = m[3] = 0.0f;
- m[5] = 2.0f * near / deltaY;
+ m[5] = -2.0f * near / deltaY;
m[4] = m[6] = m[7] = 0.0f;
m[8] = (right + left) / deltaX;
m[9] = (top + bottom) / deltaY;
- m[10] = -(near + far) / deltaZ;
- m[11] = -1.0f;
+ m[10] = (near + far) / deltaZ;
+ m[11] = 1.0f;
m[14] = -2.0f * near * far / deltaZ;
m[12] = m[13] = m[15] = 0.0f;
!Equals(far, near) && "Cannot create orthographic projection with a zero edge" );
float *m = result.AsFloat();
- m[0] = 2.0f / deltaX;
+ m[0] = -2.0f / deltaX;
m[1] = 0.0f;
m[2] = 0.0f;
m[3] = 0.0f;
m[4] = 0.0f;
- m[5] = 2.0f / deltaY;
+ m[5] = -2.0f / deltaY;
m[6] = 0.0f;
m[7] = 0.0f;
m[8] = 0.0f;
m[9] = 0.0f;
- m[10] = -2.0f / deltaZ;
+ m[10] = 2.0f / deltaZ;
m[11] = 0.0f;
m[12] = -(right + left) / deltaX;
m[13] = -(top + bottom) / deltaY;
const Dali::Camera::Type CameraAttachment::DEFAULT_TYPE( Dali::Camera::LOOK_AT_TARGET );
const Dali::Camera::ProjectionMode CameraAttachment::DEFAULT_MODE( Dali::Camera::PERSPECTIVE_PROJECTION );
-const bool CameraAttachment::DEFAULT_INVERT_Y_AXIS( true );
+const bool CameraAttachment::DEFAULT_INVERT_Y_AXIS( false );
const float CameraAttachment::DEFAULT_FIELD_OF_VIEW( 45.0f*(M_PI/180.0f) );
const float CameraAttachment::DEFAULT_ASPECT_RATIO( 4.0f/3.0f );
const float CameraAttachment::DEFAULT_LEFT_CLIPPING_PLANE(-240.0f);
const float CameraAttachment::DEFAULT_TOP_CLIPPING_PLANE(-400.0f);
const float CameraAttachment::DEFAULT_BOTTOM_CLIPPING_PLANE(400.0f);
const float CameraAttachment::DEFAULT_NEAR_CLIPPING_PLANE( 800.0f ); // default height of the screen
-const float CameraAttachment::DEFAULT_FAR_CLIPPING_PLANE( DEFAULT_NEAR_CLIPPING_PLANE + 0xFFF ); // for a 16bit screen 4 bits per unit in depth buffer
+const float CameraAttachment::DEFAULT_FAR_CLIPPING_PLANE( DEFAULT_NEAR_CLIPPING_PLANE + 2.f * DEFAULT_NEAR_CLIPPING_PLANE );
const Vector3 CameraAttachment::DEFAULT_TARGET_POSITION( 0.0f, 0.0f, 0.0f );
CameraAttachment::CameraAttachment()
: NodeAttachment(),
- mLookAtMatrix(false),
mUpdateViewFlag( UPDATE_COUNT ),
mUpdateProjectionFlag( UPDATE_COUNT ),
mType( DEFAULT_TYPE ),
void CameraAttachment::SetInvertYAxis( bool invertYAxis )
{
mInvertYAxis = invertYAxis;
+ mUpdateProjectionFlag = UPDATE_COUNT;
}
void CameraAttachment::SetFieldOfView( float fieldOfView )
// camera orientation taken from node - i.e. look in abitrary, unconstrained direction
case Dali::Camera::FREE_LOOK:
{
- Matrix view(false);
- Quaternion cameraRotation(owningNode.GetWorldRotation(updateBufferIndex));
- if( ! cameraRotation.IsIdentity())
- {
- cameraRotation = cameraRotation*Quaternion(M_PI, Vector3::YAXIS);
- }
- view.SetInverseTransformComponents( Vector3::ONE,
- cameraRotation,
- owningNode.GetWorldPosition(updateBufferIndex) );
-
Matrix& viewMatrix = mViewMatrix.Get(updateBufferIndex);
-
- if(mInvertYAxis)
- {
- viewMatrix.SetIdentityAndScale( Vector3(1.0f, -1.0f, 1.0f) );
- }
- else
- {
- viewMatrix.SetIdentity();
- }
-
- Matrix::Multiply( viewMatrix, viewMatrix, view );
+ viewMatrix.SetInverseTransformComponents(
+ Vector3::ONE,
+ owningNode.GetWorldRotation(updateBufferIndex),
+ owningNode.GetWorldPosition(updateBufferIndex) );
mViewMatrix.SetDirty(updateBufferIndex);
break;
// camera orientation constrained to look at a target
case Dali::Camera::LOOK_AT_TARGET:
{
- mLookAtMatrix = Matrix::IDENTITY;
-
- LookAt( mLookAtMatrix,
+ Matrix& viewMatrix = mViewMatrix.Get(updateBufferIndex);
+ LookAt( viewMatrix,
owningNode.GetWorldPosition(updateBufferIndex),
mTargetPosition,
owningNode.GetWorldRotation(updateBufferIndex).Rotate(Vector3::YAXIS) );
- Matrix& viewMatrix = mViewMatrix.Get(updateBufferIndex);
-
- if(mInvertYAxis)
- {
- viewMatrix.SetIdentityAndScale( Vector3(1.0f, -1.0f, 1.0f) );
- }
- else
- {
- viewMatrix.SetIdentity();
- }
- Matrix::Multiply( viewMatrix, viewMatrix, mLookAtMatrix );
-
mViewMatrix.SetDirty(updateBufferIndex);
break;
}
{
case Dali::Camera::PERSPECTIVE_PROJECTION:
{
- Perspective( mProjectionMatrix.Get(updateBufferIndex),
+ Matrix &projectionMatrix = mProjectionMatrix.Get(updateBufferIndex);
+ Perspective( projectionMatrix,
mFieldOfView,
mAspectRatio,
mNearClippingPlane,
}
case Dali::Camera::ORTHOGRAPHIC_PROJECTION:
{
- Orthographic( mProjectionMatrix.Get(updateBufferIndex),
+ Matrix &projectionMatrix = mProjectionMatrix.Get(updateBufferIndex);
+ Orthographic( projectionMatrix,
mLeftClippingPlane, mRightClippingPlane,
mBottomClippingPlane, mTopClippingPlane,
mNearClippingPlane, mFarClippingPlane );
void UpdateInverseViewProjection( BufferIndex updateBufferIndex );
private:
- Matrix mLookAtMatrix; ///< This is used during the view-matrix calculation.
unsigned int mUpdateViewFlag; ///< This is non-zero if the view matrix requires an update
unsigned int mUpdateProjectionFlag; ///< This is non-zero if the projection matrix requires an update
// LookAt
///////////////////////////////////////////////////////////////////////////////////////////////////
-static Quaternion LookAtTarget( const Vector3& vForward, const Quaternion& targetRotation )
+static Quaternion LookAtTarget( const Vector3& vZ, const Quaternion& targetRotation )
{
- Vector3 vRight;
- Vector3 vUp;
-
- Vector3 targetUp(targetRotation.Rotate(-Vector3::YAXIS));
- targetUp.Normalize();
+ Vector3 targetY(targetRotation.Rotate(Vector3::YAXIS));
+ targetY.Normalize();
// Camera Right vector is perpendicular to forward & target up
- vRight = vForward.Cross(targetUp);
- vRight.Normalize();
+ Vector3 vX = targetY.Cross(vZ);
+ vX.Normalize();
// Camera Up vector is perpendicular to forward and right
- vUp = vForward.Cross(vRight);
- vUp.Normalize();
+ Vector3 vY = vZ.Cross(vX);
+ vY.Normalize();
- return Quaternion( vRight, vUp, vForward );
+ return Quaternion( vX, vY, vZ );
}
Dali::Quaternion LookAt( const Dali::Quaternion& current,
projects / platform / core / uifw / dali-core.git / commitdiff