tools: reduce diff noise
[xonotic/netradiant.git] / libs / dragplanes.h
1 /*
2    Copyright (C) 2001-2006, William Joseph.
3    All Rights Reserved.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #if !defined( INCLUDED_DRAGPLANES_H )
23 #define INCLUDED_DRAGPLANES_H
24
25 #include "selectable.h"
26 #include "selectionlib.h"
27 #include "math/aabb.h"
28 #include "math/line.h"
29
30 // local must be a pure rotation
31 inline Vector3 translation_to_local( const Vector3& translation, const Matrix4& local ){
32         return matrix4_get_translation_vec3(
33                            matrix4_multiplied_by_matrix4(
34                                    matrix4_translated_by_vec3( matrix4_transposed( local ), translation ),
35                                    local
36                                    )
37                            );
38 }
39
40 // local must be a pure rotation
41 inline Vector3 translation_from_local( const Vector3& translation, const Matrix4& local ){
42         return matrix4_get_translation_vec3(
43                            matrix4_multiplied_by_matrix4(
44                                    matrix4_translated_by_vec3( local, translation ),
45                                    matrix4_transposed( local )
46                                    )
47                            );
48 }
49
50 class DragPlanes
51 {
52 public:
53 ObservedSelectable m_selectable_right;   // +x
54 ObservedSelectable m_selectable_left;   // -x
55 ObservedSelectable m_selectable_front;   // +y
56 ObservedSelectable m_selectable_back;   // -y
57 ObservedSelectable m_selectable_top;   // +z
58 ObservedSelectable m_selectable_bottom;   // -z
59 AABB m_bounds;
60
61 DragPlanes( const SelectionChangeCallback& onchanged ) :
62         m_selectable_right( onchanged ),
63         m_selectable_left( onchanged ),
64         m_selectable_front( onchanged ),
65         m_selectable_back( onchanged ),
66         m_selectable_top( onchanged ),
67         m_selectable_bottom( onchanged ){
68 }
69 bool isSelected() const {
70         return m_selectable_right.isSelected()
71                    || m_selectable_left.isSelected()
72                    || m_selectable_front.isSelected()
73                    || m_selectable_back.isSelected()
74                    || m_selectable_top.isSelected()
75                    || m_selectable_bottom.isSelected();
76 }
77 void setSelected( bool selected ){
78         m_selectable_right.setSelected( selected );
79         m_selectable_left.setSelected( selected );
80         m_selectable_front.setSelected( selected );
81         m_selectable_back.setSelected( selected );
82         m_selectable_top.setSelected( selected );
83         m_selectable_bottom.setSelected( selected );
84 }
85 void selectPlanes( const AABB& aabb, Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback, const Matrix4& rotation = g_matrix4_identity ){
86         Line line( test.getNear(), test.getFar() );
87         Vector3 corners[8];
88         aabb_corners_oriented( aabb, rotation, corners );
89
90         Plane3 planes[6];
91         aabb_planes_oriented( aabb, rotation, planes );
92
93         for ( Vector3* i = corners; i != corners + 8; ++i )
94         {
95                 *i = vector3_subtracted( line_closest_point( line, *i ), *i );
96         }
97
98         if ( vector3_dot( planes[0].normal(), corners[1] ) > 0
99                  && vector3_dot( planes[0].normal(), corners[2] ) > 0
100                  && vector3_dot( planes[0].normal(), corners[5] ) > 0
101                  && vector3_dot( planes[0].normal(), corners[6] ) > 0 ) {
102                 Selector_add( selector, m_selectable_right );
103                 selectedPlaneCallback( planes[0] );
104                 //globalOutputStream() << "right\n";
105         }
106         if ( vector3_dot( planes[1].normal(), corners[0] ) > 0
107                  && vector3_dot( planes[1].normal(), corners[3] ) > 0
108                  && vector3_dot( planes[1].normal(), corners[4] ) > 0
109                  && vector3_dot( planes[1].normal(), corners[7] ) > 0 ) {
110                 Selector_add( selector, m_selectable_left );
111                 selectedPlaneCallback( planes[1] );
112                 //globalOutputStream() << "left\n";
113         }
114         if ( vector3_dot( planes[2].normal(), corners[0] ) > 0
115                  && vector3_dot( planes[2].normal(), corners[1] ) > 0
116                  && vector3_dot( planes[2].normal(), corners[4] ) > 0
117                  && vector3_dot( planes[2].normal(), corners[5] ) > 0 ) {
118                 Selector_add( selector, m_selectable_front );
119                 selectedPlaneCallback( planes[2] );
120                 //globalOutputStream() << "front\n";
121         }
122         if ( vector3_dot( planes[3].normal(), corners[2] ) > 0
123                  && vector3_dot( planes[3].normal(), corners[3] ) > 0
124                  && vector3_dot( planes[3].normal(), corners[6] ) > 0
125                  && vector3_dot( planes[3].normal(), corners[7] ) > 0 ) {
126                 Selector_add( selector, m_selectable_back );
127                 selectedPlaneCallback( planes[3] );
128                 //globalOutputStream() << "back\n";
129         }
130         if ( vector3_dot( planes[4].normal(), corners[0] ) > 0
131                  && vector3_dot( planes[4].normal(), corners[1] ) > 0
132                  && vector3_dot( planes[4].normal(), corners[2] ) > 0
133                  && vector3_dot( planes[4].normal(), corners[3] ) > 0 ) {
134                 Selector_add( selector, m_selectable_top );
135                 selectedPlaneCallback( planes[4] );
136                 //globalOutputStream() << "top\n";
137         }
138         if ( vector3_dot( planes[5].normal(), corners[4] ) > 0
139                  && vector3_dot( planes[5].normal(), corners[5] ) > 0
140                  && vector3_dot( planes[5].normal(), corners[6] ) > 0
141                  && vector3_dot( planes[5].normal(), corners[7] ) > 0 ) {
142                 Selector_add( selector, m_selectable_bottom );
143                 selectedPlaneCallback( planes[5] );
144                 //globalOutputStream() << "bottom\n";
145         }
146
147         m_bounds = aabb;
148 }
149 void selectReversedPlanes( const AABB& aabb, Selector& selector, const SelectedPlanes& selectedPlanes, const Matrix4& rotation = g_matrix4_identity ){
150         Plane3 planes[6];
151         aabb_planes_oriented( aabb, rotation, planes );
152
153         if ( selectedPlanes.contains( plane3_flipped( planes[0] ) ) ) {
154                 Selector_add( selector, m_selectable_right );
155         }
156         if ( selectedPlanes.contains( plane3_flipped( planes[1] ) ) ) {
157                 Selector_add( selector, m_selectable_left );
158         }
159         if ( selectedPlanes.contains( plane3_flipped( planes[2] ) ) ) {
160                 Selector_add( selector, m_selectable_front );
161         }
162         if ( selectedPlanes.contains( plane3_flipped( planes[3] ) ) ) {
163                 Selector_add( selector, m_selectable_back );
164         }
165         if ( selectedPlanes.contains( plane3_flipped( planes[4] ) ) ) {
166                 Selector_add( selector, m_selectable_top );
167         }
168         if ( selectedPlanes.contains( plane3_flipped( planes[5] ) ) ) {
169                 Selector_add( selector, m_selectable_bottom );
170         }
171 }
172 AABB evaluateResize( const Vector3& translation ) const {
173         Vector3 min = m_bounds.origin - m_bounds.extents;
174         Vector3 max = m_bounds.origin + m_bounds.extents;
175         if ( m_bounds.extents[0] != 0 ) {
176                 if ( m_selectable_right.isSelected() ) {
177                         max[0] += translation[0];
178                         //globalOutputStream() << "moving right\n";
179                 }
180                 if ( m_selectable_left.isSelected() ) {
181                         min[0] += translation[0];
182                         //globalOutputStream() << "moving left\n";
183                 }
184         }
185         if ( m_bounds.extents[1] != 0 ) {
186                 if ( m_selectable_front.isSelected() ) {
187                         max[1] += translation[1];
188                         //globalOutputStream() << "moving front\n";
189                 }
190                 if ( m_selectable_back.isSelected() ) {
191                         min[1] += translation[1];
192                         //globalOutputStream() << "moving back\n";
193                 }
194         }
195         if ( m_bounds.extents[2] != 0 ) {
196                 if ( m_selectable_top.isSelected() ) {
197                         max[2] += translation[2];
198                         //globalOutputStream() << "moving top\n";
199                 }
200                 if ( m_selectable_bottom.isSelected() ) {
201                         min[2] += translation[2];
202                         //globalOutputStream() << "moving bottom\n";
203                 }
204         }
205
206         return AABB( vector3_mid( min, max ), vector3_scaled( vector3_subtracted( max, min ), 0.5 ) );
207 }
208 AABB evaluateResize( const Vector3& translation, const Matrix4& rotation ) const {
209         AABB aabb( evaluateResize( translation_to_local( translation, rotation ) ) );
210         aabb.origin = m_bounds.origin + translation_from_local( aabb.origin - m_bounds.origin, rotation );
211         return aabb;
212 }
213 Matrix4 evaluateTransform( const Vector3& translation ) const {
214         AABB aabb( evaluateResize( translation ) );
215         Vector3 scale(
216                 m_bounds.extents[0] != 0 ? aabb.extents[0] / m_bounds.extents[0] : 1,
217                 m_bounds.extents[1] != 0 ? aabb.extents[1] / m_bounds.extents[1] : 1,
218                 m_bounds.extents[2] != 0 ? aabb.extents[2] / m_bounds.extents[2] : 1
219                 );
220
221         Matrix4 matrix( matrix4_translation_for_vec3( aabb.origin - m_bounds.origin ) );
222         matrix4_pivoted_scale_by_vec3( matrix, scale, m_bounds.origin );
223
224         return matrix;
225 }
226 };
227
228 #endif