Moka controlers
 All Classes Namespaces Files Functions Variables Typedefs Enumerator Friends Macros
precompile-object-transformation.cc
Go to the documentation of this file.
1 /*
2  * lib-controler-gmap : Le contrôleur de 3-G-cartes, surcouche de lib-controler.
3  * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
4  * http://www.sic.sp2mi.univ-poitiers.fr/
5  * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
6  * guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
7  *
8  * This file is part of lib-controler-gmap
9  *
10  * This program is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with this program. If not, see <http://www.gnu.org/licenses/>.
22  */
23 
24 //******************************************************************************
25 #include "controler-gmap-types.hh"
26 #include "precompile-object-transformation.hh"
27 #include "parameter-object-transformation.hh"
28 #include "parameter-object-translation.hh"
29 #include "parameter-object-rotation.hh"
30 #include "parameter-object-scale.hh"
31 #include "parameter-object-ponderation.hh"
32 #include "geometry.hh"
33 #include "transformation-matrix.hh"
34 #include "vertex.hh"
35 #include <cassert>
36 using namespace GMap3d;
37 //******************************************************************************
38 CPrecompileObjectTransformation::
39 CPrecompileObjectTransformation( CParameterObjectTransformation *
40  AParameterObjectTransformation,
41  CParameterObjectTranslation *
42  AParameterObjectTranslation,
43  CParameterObjectRotation *
44  AParameterObjectRotation,
45  CParameterObjectScale *
46  AParameterObjectScale,
47  CParameterObjectPonderation *
48  AParameterObjectPonderation) :
49  FParameterObjectTransformation(AParameterObjectTransformation),
50  FParameterObjectTranslation (AParameterObjectTranslation),
51  FParameterObjectRotation (AParameterObjectRotation),
52  FParameterObjectScale (AParameterObjectScale),
53  FParameterObjectPonderation (AParameterObjectPonderation),
54  FCurrentMode (MODE_DEFAULT)
55 {
56  assert(FParameterObjectTransformation!=NULL);
57 
58  FParameterObjectTransformation->addPrecompileToUpdate(this);
59 
60  if (FParameterObjectTranslation!=NULL)
61  FParameterObjectTranslation->addPrecompileToUpdate(this);
62 
63  if (FParameterObjectRotation!=NULL)
64  FParameterObjectRotation->addPrecompileToUpdate(this);
65 
66  if (FParameterObjectScale!=NULL)
67  FParameterObjectScale->addPrecompileToUpdate(this);
68 
69  if (FParameterObjectPonderation!=NULL)
70  FParameterObjectPonderation->addPrecompileToUpdate(this);
71 
72  disable();
73 }
74 //******************************************************************************
75 CPrecompileObjectTransformation::
76 CPrecompileObjectTransformation( const CPrecompileObjectTransformation &
77  APrecompile ) :
78  CPrecompile (APrecompile),
79  FParameterObjectTransformation(static_cast<CParameterObjectTransformation*>
80  (APrecompile.FParameterObjectTransformation->copy())),
81  FParameterObjectTranslation (APrecompile.FParameterObjectTranslation),
82  FParameterObjectRotation (APrecompile.FParameterObjectRotation),
83  FParameterObjectScale (APrecompile.FParameterObjectScale),
84  FParameterObjectPonderation (APrecompile.FParameterObjectPonderation),
85  FCurrentMode (APrecompile.FCurrentMode)
86 {
87  assert(FParameterObjectTransformation!=NULL);
88 
89  FParameterObjectTransformation->addPrecompileToUpdate(this);
90 
91  if (FParameterObjectTranslation!=NULL)
92  FParameterObjectTranslation->addPrecompileToUpdate(this);
93 
94  if (FParameterObjectRotation!=NULL)
95  FParameterObjectRotation->addPrecompileToUpdate(this);
96 
97  if (FParameterObjectScale!=NULL)
98  FParameterObjectScale->addPrecompileToUpdate(this);
99 
100  if (FParameterObjectPonderation!=NULL)
101  FParameterObjectPonderation->addPrecompileToUpdate(this);
102 
103  disable();
104 }
105 //******************************************************************************
106 CPrecompileObjectTransformation::~CPrecompileObjectTransformation()
107 {
108  FParameterObjectTransformation->removePrecompileToUpdate(this);
109 
110  if (FParameterObjectTranslation!=NULL)
111  FParameterObjectTranslation->removePrecompileToUpdate(this);
112 
113  if (FParameterObjectRotation!=NULL)
114  FParameterObjectRotation->removePrecompileToUpdate(this);
115 
116  if (FParameterObjectScale!=NULL)
117  FParameterObjectScale->removePrecompileToUpdate(this);
118 
119  if (FParameterObjectPonderation!=NULL)
120  FParameterObjectPonderation->removePrecompileToUpdate(this);
121 }
122 //******************************************************************************
123 CPrecompile * CPrecompileObjectTransformation::copy() const
124 { return new CPrecompileObjectTransformation(*this); }
125 //******************************************************************************
126 void CPrecompileObjectTransformation::setCurrentMode(TMode AMode)
127 {
128  if ( AMode!=FCurrentMode )
129  {
130  FCurrentMode = AMode;
131  setToUpdate();
132  }
133 }
134 //******************************************************************************
135 void CPrecompileObjectTransformation::setParameter(CParameter * AParameter)
136 {
137  switch (AParameter->getType())
138  {
139  case PARAMETER_OBJECT_TRANSFORMATION:
140  setObjectTransformation(static_cast<CParameterObjectTransformation *>(AParameter));
141  break;
142  case PARAMETER_OBJECT_TRANSLATION:
143  setObjectTranslation(static_cast<CParameterObjectTranslation *>(AParameter));
144  break;
145  case PARAMETER_OBJECT_ROTATION:
146  setObjectRotation(static_cast<CParameterObjectRotation *>(AParameter));
147  break;
148  case PARAMETER_OBJECT_SCALE:
149  setObjectScale(static_cast<CParameterObjectScale *>(AParameter));
150  break;
151  case PARAMETER_OBJECT_PONDERATION:
152  setObjectPonderation(static_cast<CParameterObjectPonderation *>(AParameter));
153  break;
154  }
155 }
156 //******************************************************************************
157 CParameter* CPrecompileObjectTransformation::getParameter() const
158 { return FParameterObjectTransformation; }
159 //******************************************************************************
160 void CPrecompileObjectTransformation::
161 setObjectTransformation(CParameterObjectTransformation* AObjectTransformation)
162 {
163  assert(AObjectTransformation != NULL);
164  AObjectTransformation->addPrecompileToUpdate(this);
165  FParameterObjectTransformation->removePrecompileToUpdate(this);
166  FParameterObjectTransformation = AObjectTransformation;
167  setToUpdate();
168 }
169 //******************************************************************************
170 void CPrecompileObjectTransformation::
171 setObjectTranslation(CParameterObjectTranslation* AObjectTranslation)
172 {
173  if (AObjectTranslation != NULL)
174  AObjectTranslation->addPrecompileToUpdate(this);
175 
176  if (FParameterObjectTranslation!= NULL)
177  FParameterObjectTranslation->removePrecompileToUpdate(this);
178 
179  FParameterObjectTranslation = AObjectTranslation;
180  setToUpdate();
181 }
182 //******************************************************************************
183 void CPrecompileObjectTransformation::
184 setObjectRotation(CParameterObjectRotation* AObjectRotation)
185 {
186  if (AObjectRotation != NULL)
187  AObjectRotation->addPrecompileToUpdate(this);
188 
189  if (FParameterObjectRotation!= NULL)
190  FParameterObjectRotation->removePrecompileToUpdate(this);
191 
192  FParameterObjectRotation = AObjectRotation;
193  setToUpdate();
194 }
195 //******************************************************************************
196 void CPrecompileObjectTransformation::
197 setObjectScale(CParameterObjectScale* AObjectScale)
198 {
199  if (AObjectScale != NULL)
200  AObjectScale->addPrecompileToUpdate(this);
201 
202  if (FParameterObjectScale!= NULL)
203  FParameterObjectScale->removePrecompileToUpdate(this);
204 
205  FParameterObjectScale = AObjectScale;
206  setToUpdate();
207 }
208 //******************************************************************************
209 void CPrecompileObjectTransformation::
210 setObjectPonderation(CParameterObjectPonderation* AObjectPonderation)
211 {
212  if (AObjectPonderation != NULL)
213  AObjectPonderation->addPrecompileToUpdate(this);
214 
215  if (FParameterObjectPonderation!= NULL)
216  FParameterObjectPonderation->removePrecompileToUpdate(this);
217 
218  FParameterObjectPonderation = AObjectPonderation;
219  setToUpdate();
220 }
221 //******************************************************************************
222 TPrecompile CPrecompileObjectTransformation::getType() const
223 { return PRECOMPILE_OBJECT_TRANSFORMATION; }
224 //******************************************************************************
225 #define AXIAL_EDGES (10)
226 #define PLANAR_EDGES (4)
227 //******************************************************************************
228 void CPrecompileObjectTransformation::drawModel()
229 {
230  glLineWidth(FParameterObjectTransformation->getLWObjectTransformation());
231  glColor3fv(FParameterObjectTransformation->getCLObjectTransformation());
232 
233  switch(FCurrentMode)
234  {
235  case MODE_TRANSLATION:
236  if ( FParameterObjectTranslation!=NULL &&
237  FParameterObjectTranslation->getPonderation() )
238  drawInteractivePonderation();
239  break;
240  case MODE_ROTATION:
241  if (FParameterObjectRotation!=NULL)
242  {
243  CVertex C = FParameterObjectRotation->getAxeVertex();
244  CVertex V = FParameterObjectRotation->getAxeVector();
245 
246  if (!V.isNull())
247  drawInteractiveAxe(C, V, AXIAL_EDGES);
248 
249  if ( FParameterObjectRotation->getPonderation() )
250  drawInteractivePonderation();
251  }
252  break;
253  case MODE_SCALE:
254  if (FParameterObjectScale!=NULL)
255  {
256  CVertex P;
257  CVertex C = FParameterObjectScale->getCenter();
258  CVertex V = FParameterObjectScale->getVector();
259 
260  switch (FParameterObjectScale->getScaleType())
261  {
262  case SCALE_POINT:
263  drawInteractiveAxe(C, ORIGIN, 0);
264  break;
265 
266  case SCALE_AXE:
267  if (!V.isNull())
268  drawInteractiveAxe(C, V, AXIAL_EDGES);
269  break;
270 
271  case SCALE_PLANE:
272  if (!V.isNull())
273  drawInteractiveAxe(C, V, PLANAR_EDGES);
274  break;
275  }
276 
277  if (FParameterObjectScale->getPonderation())
278  drawInteractivePonderation();
279  }
280  break;
281  default:
282  {
283  drawInteractivePonderation();
284  }
285  }
286 }
287 //******************************************************************************
288 void CPrecompileObjectTransformation::drawInteractiveAxe(const CVertex & C,
289  const CVertex & V,
290  int circleNbEdges,
291  bool ponderation)
292 {
293  CVertex P;
294 
295  if (V.isNull())
296  {
297 #define K (0.1)
298  glBegin(GL_LINES);
299 
300  if (ponderation)
301  {
302  P = C - K*(OX+OY); PLOT(&P);
303  P = C + K*(OX+OY); PLOT(&P);
304 
305  P = C - K*(OX-OY); PLOT(&P);
306  P = C + K*(OX-OY); PLOT(&P);
307 
308  P = C - K*OZ; PLOT(&P);
309  P = C + K*OZ; PLOT(&P);
310  }
311  else
312  for (int i=0; i<2; ++i)
313  for (int j=0; j<2; ++j)
314  {
315  P = C+K*CVertex(2*i-1,2*j-1,-1); PLOT(&P);
316  P = C-K*CVertex(2*i-1,2*j-1,-1); PLOT(&P);
317  }
318 
319  glEnd();
320 #undef K
321  return;
322  }
323  else
324  {
325 #define N (21) // doit être impair!
326  CVertex VV = 2*V/V.norm();
327 
328  glBegin(GL_LINES);
329 
330  int i = ponderation ? 0 : 1;
331 
332  for (; i<=N; i+=2)
333  {
334  P = C + VV*(float(i )/N - 0.5); PLOT(&P);
335  P = C + VV*(float(i+1)/N - 0.5); PLOT(&P);
336  }
337 
338  glEnd();
339 #undef N
340 
341  CVertex N = CGeometry::getNormalVector(V);
342  CVertex E = C + N/N.norm()/circleNbEdges;
343 
344  glBegin(GL_LINE_LOOP);
345  {
346  CTransformationMatrix
347  rotationMatrix(CTransformationMatrix::IdentityMatrix);
348  rotationMatrix.rotate(C, V, 360.0/circleNbEdges);
349 
350  for (int i=0; i<circleNbEdges; ++i)
351  {
352  PLOT(&E);
353  rotationMatrix.applyOn(E);
354  }
355  }
356  glEnd();
357  }
358 }
359 //******************************************************************************
360 void CPrecompileObjectTransformation::drawInteractivePonderation()
361 {
362  if (FParameterObjectPonderation==NULL) return;
363 
364  CVertex C = FParameterObjectPonderation->getPonderationCenter();
365  CVertex V = FParameterObjectPonderation->getPonderationVector();
366 
367  if (V.isNull())
368  V = OZ;
369 
370  switch (FParameterObjectPonderation->getPonderationType())
371  {
372  case PONDERATION_POINT:
373  drawInteractiveAxe(C, ORIGIN, 0, true);
374  break;
375 
376  case PONDERATION_AXE:
377  drawInteractiveAxe(C, V, AXIAL_EDGES, true);
378  break;
379 
380  case PONDERATION_PLANE:
381  drawInteractiveAxe(C, V, PLANAR_EDGES, true);
382  break;
383  }
384 }
385 //******************************************************************************