00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "controler-gmap-types.hh"
00026 #include "precompile-object-transformation.hh"
00027 #include "parameter-object-transformation.hh"
00028 #include "parameter-object-translation.hh"
00029 #include "parameter-object-rotation.hh"
00030 #include "parameter-object-scale.hh"
00031 #include "parameter-object-ponderation.hh"
00032 #include "geometry.hh"
00033 #include "transformation-matrix.hh"
00034 #include "vertex.hh"
00035 #include <cassert>
00036 using namespace GMap3d;
00037
00038 CPrecompileObjectTransformation::
00039 CPrecompileObjectTransformation( CParameterObjectTransformation *
00040 AParameterObjectTransformation,
00041 CParameterObjectTranslation *
00042 AParameterObjectTranslation,
00043 CParameterObjectRotation *
00044 AParameterObjectRotation,
00045 CParameterObjectScale *
00046 AParameterObjectScale,
00047 CParameterObjectPonderation *
00048 AParameterObjectPonderation) :
00049 FParameterObjectTransformation(AParameterObjectTransformation),
00050 FParameterObjectTranslation (AParameterObjectTranslation),
00051 FParameterObjectRotation (AParameterObjectRotation),
00052 FParameterObjectScale (AParameterObjectScale),
00053 FParameterObjectPonderation (AParameterObjectPonderation),
00054 FCurrentMode (MODE_DEFAULT)
00055 {
00056 assert(FParameterObjectTransformation!=NULL);
00057
00058 FParameterObjectTransformation->addPrecompileToUpdate(this);
00059
00060 if (FParameterObjectTranslation!=NULL)
00061 FParameterObjectTranslation->addPrecompileToUpdate(this);
00062
00063 if (FParameterObjectRotation!=NULL)
00064 FParameterObjectRotation->addPrecompileToUpdate(this);
00065
00066 if (FParameterObjectScale!=NULL)
00067 FParameterObjectScale->addPrecompileToUpdate(this);
00068
00069 if (FParameterObjectPonderation!=NULL)
00070 FParameterObjectPonderation->addPrecompileToUpdate(this);
00071
00072 disable();
00073 }
00074
00075 CPrecompileObjectTransformation::
00076 CPrecompileObjectTransformation( const CPrecompileObjectTransformation &
00077 APrecompile ) :
00078 CPrecompile (APrecompile),
00079 FParameterObjectTransformation(static_cast<CParameterObjectTransformation*>
00080 (APrecompile.FParameterObjectTransformation->copy())),
00081 FParameterObjectTranslation (APrecompile.FParameterObjectTranslation),
00082 FParameterObjectRotation (APrecompile.FParameterObjectRotation),
00083 FParameterObjectScale (APrecompile.FParameterObjectScale),
00084 FParameterObjectPonderation (APrecompile.FParameterObjectPonderation),
00085 FCurrentMode (APrecompile.FCurrentMode)
00086 {
00087 assert(FParameterObjectTransformation!=NULL);
00088
00089 FParameterObjectTransformation->addPrecompileToUpdate(this);
00090
00091 if (FParameterObjectTranslation!=NULL)
00092 FParameterObjectTranslation->addPrecompileToUpdate(this);
00093
00094 if (FParameterObjectRotation!=NULL)
00095 FParameterObjectRotation->addPrecompileToUpdate(this);
00096
00097 if (FParameterObjectScale!=NULL)
00098 FParameterObjectScale->addPrecompileToUpdate(this);
00099
00100 if (FParameterObjectPonderation!=NULL)
00101 FParameterObjectPonderation->addPrecompileToUpdate(this);
00102
00103 disable();
00104 }
00105
00106 CPrecompileObjectTransformation::~CPrecompileObjectTransformation()
00107 {
00108 FParameterObjectTransformation->removePrecompileToUpdate(this);
00109
00110 if (FParameterObjectTranslation!=NULL)
00111 FParameterObjectTranslation->removePrecompileToUpdate(this);
00112
00113 if (FParameterObjectRotation!=NULL)
00114 FParameterObjectRotation->removePrecompileToUpdate(this);
00115
00116 if (FParameterObjectScale!=NULL)
00117 FParameterObjectScale->removePrecompileToUpdate(this);
00118
00119 if (FParameterObjectPonderation!=NULL)
00120 FParameterObjectPonderation->removePrecompileToUpdate(this);
00121 }
00122
00123 CPrecompile * CPrecompileObjectTransformation::copy() const
00124 { return new CPrecompileObjectTransformation(*this); }
00125
00126 void CPrecompileObjectTransformation::setCurrentMode(TMode AMode)
00127 {
00128 if ( AMode!=FCurrentMode )
00129 {
00130 FCurrentMode = AMode;
00131 setToUpdate();
00132 }
00133 }
00134
00135 void CPrecompileObjectTransformation::setParameter(CParameter * AParameter)
00136 {
00137 switch (AParameter->getType())
00138 {
00139 case PARAMETER_OBJECT_TRANSFORMATION:
00140 setObjectTransformation(static_cast<CParameterObjectTransformation *>(AParameter));
00141 break;
00142 case PARAMETER_OBJECT_TRANSLATION:
00143 setObjectTranslation(static_cast<CParameterObjectTranslation *>(AParameter));
00144 break;
00145 case PARAMETER_OBJECT_ROTATION:
00146 setObjectRotation(static_cast<CParameterObjectRotation *>(AParameter));
00147 break;
00148 case PARAMETER_OBJECT_SCALE:
00149 setObjectScale(static_cast<CParameterObjectScale *>(AParameter));
00150 break;
00151 case PARAMETER_OBJECT_PONDERATION:
00152 setObjectPonderation(static_cast<CParameterObjectPonderation *>(AParameter));
00153 break;
00154 }
00155 }
00156
00157 CParameter* CPrecompileObjectTransformation::getParameter() const
00158 { return FParameterObjectTransformation; }
00159
00160 void CPrecompileObjectTransformation::
00161 setObjectTransformation(CParameterObjectTransformation* AObjectTransformation)
00162 {
00163 assert(AObjectTransformation != NULL);
00164 AObjectTransformation->addPrecompileToUpdate(this);
00165 FParameterObjectTransformation->removePrecompileToUpdate(this);
00166 FParameterObjectTransformation = AObjectTransformation;
00167 setToUpdate();
00168 }
00169
00170 void CPrecompileObjectTransformation::
00171 setObjectTranslation(CParameterObjectTranslation* AObjectTranslation)
00172 {
00173 if (AObjectTranslation != NULL)
00174 AObjectTranslation->addPrecompileToUpdate(this);
00175
00176 if (FParameterObjectTranslation!= NULL)
00177 FParameterObjectTranslation->removePrecompileToUpdate(this);
00178
00179 FParameterObjectTranslation = AObjectTranslation;
00180 setToUpdate();
00181 }
00182
00183 void CPrecompileObjectTransformation::
00184 setObjectRotation(CParameterObjectRotation* AObjectRotation)
00185 {
00186 if (AObjectRotation != NULL)
00187 AObjectRotation->addPrecompileToUpdate(this);
00188
00189 if (FParameterObjectRotation!= NULL)
00190 FParameterObjectRotation->removePrecompileToUpdate(this);
00191
00192 FParameterObjectRotation = AObjectRotation;
00193 setToUpdate();
00194 }
00195
00196 void CPrecompileObjectTransformation::
00197 setObjectScale(CParameterObjectScale* AObjectScale)
00198 {
00199 if (AObjectScale != NULL)
00200 AObjectScale->addPrecompileToUpdate(this);
00201
00202 if (FParameterObjectScale!= NULL)
00203 FParameterObjectScale->removePrecompileToUpdate(this);
00204
00205 FParameterObjectScale = AObjectScale;
00206 setToUpdate();
00207 }
00208
00209 void CPrecompileObjectTransformation::
00210 setObjectPonderation(CParameterObjectPonderation* AObjectPonderation)
00211 {
00212 if (AObjectPonderation != NULL)
00213 AObjectPonderation->addPrecompileToUpdate(this);
00214
00215 if (FParameterObjectPonderation!= NULL)
00216 FParameterObjectPonderation->removePrecompileToUpdate(this);
00217
00218 FParameterObjectPonderation = AObjectPonderation;
00219 setToUpdate();
00220 }
00221
00222 TPrecompile CPrecompileObjectTransformation::getType() const
00223 { return PRECOMPILE_OBJECT_TRANSFORMATION; }
00224
00225 #define AXIAL_EDGES (10)
00226 #define PLANAR_EDGES (4)
00227
00228 void CPrecompileObjectTransformation::drawModel()
00229 {
00230 glLineWidth(FParameterObjectTransformation->getLWObjectTransformation());
00231 glColor3fv(FParameterObjectTransformation->getCLObjectTransformation());
00232
00233 switch(FCurrentMode)
00234 {
00235 case MODE_TRANSLATION:
00236 if ( FParameterObjectTranslation!=NULL &&
00237 FParameterObjectTranslation->getPonderation() )
00238 drawInteractivePonderation();
00239 break;
00240 case MODE_ROTATION:
00241 if (FParameterObjectRotation!=NULL)
00242 {
00243 CVertex C = FParameterObjectRotation->getAxeVertex();
00244 CVertex V = FParameterObjectRotation->getAxeVector();
00245
00246 if (!V.isNull())
00247 drawInteractiveAxe(C, V, AXIAL_EDGES);
00248
00249 if ( FParameterObjectRotation->getPonderation() )
00250 drawInteractivePonderation();
00251 }
00252 break;
00253 case MODE_SCALE:
00254 if (FParameterObjectScale!=NULL)
00255 {
00256 CVertex P;
00257 CVertex C = FParameterObjectScale->getCenter();
00258 CVertex V = FParameterObjectScale->getVector();
00259
00260 switch (FParameterObjectScale->getScaleType())
00261 {
00262 case SCALE_POINT:
00263 drawInteractiveAxe(C, ORIGIN, 0);
00264 break;
00265
00266 case SCALE_AXE:
00267 if (!V.isNull())
00268 drawInteractiveAxe(C, V, AXIAL_EDGES);
00269 break;
00270
00271 case SCALE_PLANE:
00272 if (!V.isNull())
00273 drawInteractiveAxe(C, V, PLANAR_EDGES);
00274 break;
00275 }
00276
00277 if (FParameterObjectScale->getPonderation())
00278 drawInteractivePonderation();
00279 }
00280 break;
00281 default:
00282 {
00283 drawInteractivePonderation();
00284 }
00285 }
00286 }
00287
00288 void CPrecompileObjectTransformation::drawInteractiveAxe(const CVertex & C,
00289 const CVertex & V,
00290 int circleNbEdges,
00291 bool ponderation)
00292 {
00293 CVertex P;
00294
00295 if (V.isNull())
00296 {
00297 #define K (0.1)
00298 glBegin(GL_LINES);
00299
00300 if (ponderation)
00301 {
00302 P = C - K*(OX+OY); PLOT(&P);
00303 P = C + K*(OX+OY); PLOT(&P);
00304
00305 P = C - K*(OX-OY); PLOT(&P);
00306 P = C + K*(OX-OY); PLOT(&P);
00307
00308 P = C - K*OZ; PLOT(&P);
00309 P = C + K*OZ; PLOT(&P);
00310 }
00311 else
00312 for (int i=0; i<2; ++i)
00313 for (int j=0; j<2; ++j)
00314 {
00315 P = C+K*CVertex(2*i-1,2*j-1,-1); PLOT(&P);
00316 P = C-K*CVertex(2*i-1,2*j-1,-1); PLOT(&P);
00317 }
00318
00319 glEnd();
00320 #undef K
00321 return;
00322 }
00323 else
00324 {
00325 #define N (21) // doit être impair!
00326 CVertex VV = 2*V/V.norm();
00327
00328 glBegin(GL_LINES);
00329
00330 int i = ponderation ? 0 : 1;
00331
00332 for (; i<=N; i+=2)
00333 {
00334 P = C + VV*(float(i )/N - 0.5); PLOT(&P);
00335 P = C + VV*(float(i+1)/N - 0.5); PLOT(&P);
00336 }
00337
00338 glEnd();
00339 #undef N
00340
00341 CVertex N = CGeometry::getNormalVector(V);
00342 CVertex E = C + N/N.norm()/circleNbEdges;
00343
00344 glBegin(GL_LINE_LOOP);
00345 {
00346 CTransformationMatrix
00347 rotationMatrix(CTransformationMatrix::IdentityMatrix);
00348 rotationMatrix.rotate(C, V, 360.0/circleNbEdges);
00349
00350 for (int i=0; i<circleNbEdges; ++i)
00351 {
00352 PLOT(&E);
00353 rotationMatrix.applyOn(E);
00354 }
00355 }
00356 glEnd();
00357 }
00358 }
00359
00360 void CPrecompileObjectTransformation::drawInteractivePonderation()
00361 {
00362 if (FParameterObjectPonderation==NULL) return;
00363
00364 CVertex C = FParameterObjectPonderation->getPonderationCenter();
00365 CVertex V = FParameterObjectPonderation->getPonderationVector();
00366
00367 if (V.isNull())
00368 V = OZ;
00369
00370 switch (FParameterObjectPonderation->getPonderationType())
00371 {
00372 case PONDERATION_POINT:
00373 drawInteractiveAxe(C, ORIGIN, 0, true);
00374 break;
00375
00376 case PONDERATION_AXE:
00377 drawInteractiveAxe(C, V, AXIAL_EDGES, true);
00378 break;
00379
00380 case PONDERATION_PLANE:
00381 drawInteractiveAxe(C, V, PLANAR_EDGES, true);
00382 break;
00383 }
00384 }
00385
