Merge branch 'devel/master' into tizen
[platform/core/uifw/dali-core.git] / dali / internal / event / common / projection.cpp
1 /*
2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 // CLASS HEADER
19 #include <dali/internal/event/common/projection.h>
20
21 // INTERNAL INCLUDES
22 #include <dali/public-api/math/rect.h>
23 #include <dali/public-api/math/matrix.h>
24 #include <dali/public-api/math/vector4.h>
25 #include <dali/public-api/math/vector2.h>
26 #include <dali/public-api/math/viewport.h>
27 #include <dali/integration-api/debug.h>
28 #include <dali/public-api/math/math-utils.h>
29
30 namespace Dali
31 {
32
33 namespace Internal
34 {
35
36 bool Unproject( const Vector4& windowPos,
37                 const Matrix& inverseMvp,
38                 float viewportWidth,
39                 float viewportHeight,
40                 Vector4& objectPos )
41 {
42   objectPos.x = windowPos.x;
43   objectPos.y = windowPos.y;
44   objectPos.z = windowPos.z;
45   objectPos.w = 1.0f;
46
47   objectPos.x = objectPos.x / viewportWidth;
48   objectPos.y = objectPos.y / viewportHeight;
49
50   objectPos.x = objectPos.x * 2.0f - 1.0f;
51   objectPos.y = objectPos.y * 2.0f - 1.0f;
52   objectPos.z = objectPos.z * 2.0f - 1.0f;
53
54   objectPos = inverseMvp * objectPos;
55
56   // In the case where objectPos.w is exactly zero, the unproject fails
57   if ( EqualsZero( objectPos.w ) )
58   {
59     return false;
60   }
61
62   objectPos.x /= objectPos.w;
63   objectPos.y /= objectPos.w;
64   objectPos.z /= objectPos.w;
65
66   return true;
67 }
68
69 bool UnprojectFull( const Vector4& windowPos,
70                     const Matrix& modelView,
71                     const Matrix& projection,
72                     float viewportWidth,
73                     float viewportHeight,
74                     Vector4& objectPos )
75 {
76   Matrix invertedMvp( false ); // Don't initialize.
77   Matrix::Multiply( invertedMvp, modelView, projection );
78
79   if (invertedMvp.Invert())
80   {
81     return Unproject( windowPos, invertedMvp, viewportWidth, viewportHeight, objectPos );
82   }
83
84   return false;
85 }
86
87 bool XyPlaneIntersect( const Vector4& pointA, const Vector4& pointB, Vector4& intersect )
88 {
89   const Vector4* near = NULL;
90   const Vector4* far = NULL;
91
92   if ( pointA.z > 0.0f && pointB.z < 0.0f )
93   {
94     near = &pointA;
95     far  = &pointB;
96   }
97   else if ( pointB.z > 0.0f && pointA.z < 0.0f )
98   {
99     near = &pointB;
100     far  = &pointA;
101   }
102   else
103   {
104     return false; // ray does not cross xy plane
105   }
106
107   float dist = near->z / (near->z - far->z);
108
109   intersect.x = near->x + (far->x - near->x) * dist;
110   intersect.y = near->y + (far->y - near->y) * dist;
111   intersect.z = 0.0f;
112
113   return true;
114 }
115
116 bool ProjectFull( const Vector4& position,
117                   const Matrix& modelView,
118                   const Matrix& projection,
119                   float viewportX,
120                   float viewportY,
121                   float viewportWidth,
122                   float viewportHeight,
123                   Vector4& windowPos )
124 {
125   bool ok = false;
126
127   Matrix Mvp( false ); // Don't initialize.
128   Matrix::Multiply( Mvp, modelView, projection );
129
130   Vector4 p = Mvp * position;
131
132   Vector2 depthRange(0,1);
133
134   if( !EqualsZero( p.w ) )
135   {
136     float div = 1.0f / p.w;
137
138     windowPos = Vector4( (1 + p.x * div) * viewportWidth  / 2 + viewportX,
139                          (1 - p.y * div) * viewportHeight / 2 + viewportY,
140                          (p.z * div) * (depthRange.y - depthRange.x) + depthRange.x,
141                          div);
142     ok = true;
143   }
144
145   return ok;
146 }
147
148
149 } // namespace Internal
150
151 } // namespace Dali