mathmod-11.1-source.zip: .../mathmod.cpp

"Fossies" - the Fresh Open Source Software Archive

Member "mathmod-11.1/ui_modules/mathmod.cpp" (17 Jun 2021, 78777 Bytes) of package /linux/misc/mathmod-11.1-source.zip:

As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

1 /*************************************************************************** 2 * Copyright (C) 2021 by Abderrahman Taha * 3 * * 4 * * 5 * This program is free software; you can redistribute it and/or modify * 6 * it under the terms of the GNU General Public License as published by * 7 * the Free Software Foundation; either version 2 of the License, or * 8 * (at your option) any later version. * 9 * * 10 * This program is distributed in the hope that it will be useful, * 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 13 * GNU General Public License for more details. * 14 * * 15 * You should have received a copy of the GNU General Public License * 16 * along with this program; if not, write to the * 17 * Free Software Foundation, Inc., * 18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * 19 ***************************************************************************/ 20 #include "mathmod.h" 21 22 void MathMod::CalculateTexturePoints(int type) 23 { 24 double tmp, val[6]={0,0,0,0,0,0}; 25 uint Jprime; 26 if (type == 1) 27 { 28 LocalScene.componentsinfos.ThereisRGBA[0] = true; 29 LocalScene.componentsinfos.NoiseParam[0].NoiseType = 1; 30 LocalScene.componentsinfos.NoiseParam[0].RgbtParser = 31 IsoObjet->masterthread->RgbtParser; 32 LocalScene.componentsinfos.NoiseParam[0].NoiseParser = 33 IsoObjet->masterthread->NoiseParser; 34 IsoObjet->masterthread->Noise == "" 35 ? LocalScene.componentsinfos.NoiseParam[0].NoiseShape = 0 36 : LocalScene.componentsinfos.NoiseParam[0].NoiseShape = 1; 37 } 38 if (type == 0) 39 { 40 LocalScene.componentsinfos.ThereisRGBA[0] = true; 41 LocalScene.componentsinfos.NoiseParam[0].NoiseType = 1; 42 LocalScene.componentsinfos.NoiseParam[0].RgbtParser = 43 ParObjet->masterthread->RgbtParser; 44 LocalScene.componentsinfos.NoiseParam[0].NoiseParser = 45 ParObjet->masterthread->NoiseParser; 46 ParObjet->masterthread->Noise == "" 47 ? LocalScene.componentsinfos.NoiseParam[0].NoiseShape = 0 48 : LocalScene.componentsinfos.NoiseParam[0].NoiseShape = 1; 49 } 50 for (uint i = 0; i < LocalScene.VertxNumber; i++) 51 { 52 val[0] = difMaximum * 53 double(LocalScene.ArrayNorVer_localPt[i * 10 + 7]) / 54 hauteur_fenetre - 55 decalage_xo; 56 val[1] = difMaximum * 57 double(LocalScene.ArrayNorVer_localPt[i * 10 + 8]) / 58 hauteur_fenetre - 59 decalage_yo; 60 val[2] = difMaximum * 61 double(LocalScene.ArrayNorVer_localPt[i * 10 + 9]) / 62 hauteur_fenetre - 63 decalage_zo; 64 if (type != 1) 65 { 66 Jprime = (i) % (ParObjet->Vgrid); 67 val[3] = double(Jprime) / double(ParObjet->Vgrid); 68 val[3] = val[3] * ParObjet->masterthread->dif_u[0] + 69 ParObjet->masterthread->u_inf[0]; 70 Jprime = (i) / (ParObjet->Ugrid); 71 val[4] = double(Jprime) / double(ParObjet->Ugrid); 72 val[4] = val[4] * ParObjet->masterthread->dif_v[0] + 73 ParObjet->masterthread->v_inf[0]; 74 } 75 if (LocalScene.componentsinfos.NoiseParam[0].NoiseShape != 0) 76 { 77 tmp = LocalScene.componentsinfos.NoiseParam[0].NoiseParser->Eval(val); 78 } 79 else 80 { 81 tmp = 1.0; 82 } 83 val[0] *= tmp; 84 val[1] *= tmp; 85 val[2] *= tmp; 86 // val[3] and val[4] uninitialized! 87 val[3] *= tmp; 88 val[4] *= tmp; 89 LocalScene.ArrayNorVer_localPt[i * 10] = 90 float(LocalScene.componentsinfos.NoiseParam[0].RgbtParser[0].Eval(val)); 91 LocalScene.ArrayNorVer_localPt[i * 10 + 1] = 92 float(LocalScene.componentsinfos.NoiseParam[0].RgbtParser[1].Eval(val)); 93 LocalScene.ArrayNorVer_localPt[i * 10 + 2] = 94 float(LocalScene.componentsinfos.NoiseParam[0].RgbtParser[2].Eval(val)); 95 LocalScene.ArrayNorVer_localPt[i * 10 + 3] = 96 float(LocalScene.componentsinfos.NoiseParam[0].RgbtParser[3].Eval(val)); 97 } 98 } 99 100 void MathMod::CalculatePigmentPoints(int type) 101 { 102 double tmp, ValCol[100], val[4]; 103 if (type == 1) 104 { 105 LocalScene.componentsinfos.ThereisRGBA[0] = true; 106 LocalScene.componentsinfos.NoiseParam[0].NoiseType = 0; // Pigments 107 LocalScene.componentsinfos.NoiseParam[0].VRgbtParser = 108 IsoObjet->masterthread->VRgbtParser; 109 LocalScene.componentsinfos.NoiseParam[0].GradientParser = 110 IsoObjet->masterthread->GradientParser; 111 LocalScene.componentsinfos.NoiseParam[0].Nb_vrgbts = 112 IsoObjet->masterthread->VRgbtSize; 113 LocalScene.componentsinfos.NoiseParam[0].NoiseParser = 114 IsoObjet->masterthread->NoiseParser; 115 IsoObjet->masterthread->Noise == "" 116 ? LocalScene.componentsinfos.NoiseParam[0].NoiseShape = 0 117 : LocalScene.componentsinfos.NoiseParam[0].NoiseShape = 1; 118 } 119 if (type == 0) 120 { 121 LocalScene.componentsinfos.ThereisRGBA[0] = true; 122 LocalScene.componentsinfos.NoiseParam[0].NoiseType = 0; // Pigments 123 LocalScene.componentsinfos.NoiseParam[0].VRgbtParser = 124 ParObjet->masterthread->VRgbtParser; 125 LocalScene.componentsinfos.NoiseParam[0].GradientParser = 126 ParObjet->masterthread->GradientParser; 127 LocalScene.componentsinfos.NoiseParam[0].Nb_vrgbts = 128 ParObjet->masterthread->VRgbtSize; 129 LocalScene.componentsinfos.NoiseParam[0].NoiseParser = 130 ParObjet->masterthread->NoiseParser; 131 ParObjet->masterthread->Noise == "" 132 ? LocalScene.componentsinfos.NoiseParam[0].NoiseShape = 0 133 : LocalScene.componentsinfos.NoiseParam[0].NoiseShape = 1; 134 } 135 for (uint i = 0; 136 i < LocalScene.componentsinfos.NoiseParam[0].Nb_vrgbts && i < 100; i++) 137 { 138 ValCol[i] = 139 LocalScene.componentsinfos.NoiseParam[0].VRgbtParser[i].Eval(val); 140 } 141 for (uint i = 0; i < LocalScene.VertxNumber; i++) 142 { 143 val[0] = difMaximum * 144 double(LocalScene.ArrayNorVer_localPt[i * 10 + 7]) / 145 hauteur_fenetre - 146 decalage_xo; 147 val[1] = difMaximum * 148 double(LocalScene.ArrayNorVer_localPt[i * 10 + 8]) / 149 hauteur_fenetre - 150 decalage_yo; 151 val[2] = difMaximum * 152 double(LocalScene.ArrayNorVer_localPt[i * 10 + 9]) / 153 hauteur_fenetre - 154 decalage_zo; 155 if (LocalScene.componentsinfos.NoiseParam[0].NoiseShape != 0) 156 tmp = LocalScene.componentsinfos.NoiseParam[0].NoiseParser->Eval(val); 157 else 158 tmp = 1.0; 159 val[0] *= tmp; 160 val[1] *= tmp; 161 val[2] *= tmp; 162 tmp = LocalScene.componentsinfos.NoiseParam[0].GradientParser->Eval(val); 163 int c = int(tmp); 164 tmp = std::abs(tmp - double(c)); 165 for (uint j = 0; 166 j < LocalScene.componentsinfos.NoiseParam[0].Nb_vrgbts && j < 100; 167 j += 5) 168 if (tmp <= ValCol[j]) 169 { 170 LocalScene.ArrayNorVer_localPt[i*10 ] = float(ValCol[j+1]); 171 LocalScene.ArrayNorVer_localPt[i*10+1] = float(ValCol[j+2]); 172 LocalScene.ArrayNorVer_localPt[i*10+2] = float(ValCol[j+3]); 173 LocalScene.ArrayNorVer_localPt[i*10+3] = float(ValCol[j+4]); 174 j = 100; 175 } 176 } 177 } 178 179 int MathMod::memoryallocation(uint nbthreads, 180 uint initparGrid, uint initisoGrid, 181 uint FactX, uint FactY, uint FactZ) 182 { 183 try 184 { 185 IsoObjet = new Iso3D(nbthreads, initisoGrid, FactX, FactY, FactZ); 186 ParObjet = new Par3D(nbthreads, initparGrid); 187 return 1; 188 } 189 catch (std::bad_alloc &) 190 { 191 message.setText("Not enough memory available to complete this operation"); 192 message.adjustSize(); 193 message.exec(); 194 return -1; 195 } 196 } 197 198 void MathMod::SaveSceneAsObjPoly(int type) 199 { 200 int startpl = 0; 201 uint actualpointindice; 202 QString fileName = QFileDialog::getSaveFileName(this, tr("Save OBJ file"), "", 203 tr("OBJ Files (*.obj)")); 204 QFile data(fileName); 205 if (data.open(QFile::ReadWrite | QFile::Truncate)) 206 { 207 QTextStream stream(&data); 208 stream.setRealNumberNotation(QTextStream::FixedNotation); 209 stream.setRealNumberPrecision(3); 210 // save vertices: 211 if (type == 1) 212 { 213 for (uint i = 0; i < LocalScene.VertxNumber; i++) 214 { 215 (stream) << "v " 216 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 7]) * 217 (difMaximum*factx/ hauteur_fenetre) - decalage_xo) 218 << " " 219 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 8]) * 220 (difMaximum*facty / hauteur_fenetre) - decalage_yo) 221 << " " 222 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 9]) * 223 (difMaximum*factz / hauteur_fenetre) - decalage_zo) 224 << " " << LocalScene.ArrayNorVer_localPt[10 * i] << " " 225 << LocalScene.ArrayNorVer_localPt[10 * i + 1] << " " 226 << LocalScene.ArrayNorVer_localPt[10 * i + 2] << "\n"; 227 } 228 } 229 else 230 { 231 for (uint i = 0; i < LocalScene.VertxNumber; i++) 232 { 233 (stream) << "v " 234 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 7]) * 235 (difMaximum*factx / hauteur_fenetre) - decalage_xo) 236 << " " 237 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 8]) * 238 (difMaximum*facty / hauteur_fenetre) - decalage_yo) 239 << " " 240 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 9]) * 241 (difMaximum*factz / hauteur_fenetre) - decalage_zo) 242 << "\n"; 243 } 244 } 245 // save faces: 246 uint paramcomp= LocalScene.componentsinfos.ParametricGrid.size(); 247 if(LocalScene.typedrawing == 1) 248 { 249 startpl = LocalScene.PolyNumber; 250 for (uint i = 0; i < LocalScene.NbPolygnNbVertexPtMin; i++) 251 { 252 uint polysize = LocalScene.PolyIndices_localPtMin[i]; 253 (stream) << "f"; 254 for (uint j = 0; j < polysize; j++) 255 { 256 actualpointindice = LocalScene.PolyIndices_localPt[startpl++]+1; 257 (stream) << " " << actualpointindice; 258 } 259 (stream) << "\n"; 260 } 261 } 262 else if(LocalScene.typedrawing == -1) 263 { 264 //**** Parametrics components ***/ 265 uint ugrid=0; 266 uint vgrid =0; 267 uint index=0; 268 for (uint p = 0; p < paramcomp; p += 2) 269 { 270 ugrid=LocalScene.componentsinfos.ParametricGrid[p]; 271 vgrid=LocalScene.componentsinfos.ParametricGrid[p+1]; 272 for (uint i = 0; i < ugrid-1; i ++) 273 for (uint j = 0; j < vgrid-1; j ++) 274 { 275 (stream) << "f " 276 << " " << (i*vgrid + j+index) +1<< " " 277 << ((i+1)*vgrid + j +index) +1<< " " 278 << ((i+1)*vgrid + (j+1)+index) +1<< " " 279 << (i*vgrid + (j+1)+index) +1<< "\n"; 280 } 281 index += ugrid*vgrid; 282 } 283 } 284 else 285 { 286 //**** Parametrics components ***/ 287 288 uint ugrid=0; 289 uint vgrid =0; 290 uint index=0; 291 for (uint p = 0; p < paramcomp; p += 2) 292 { 293 ugrid=LocalScene.componentsinfos.ParametricGrid[p]; 294 vgrid=LocalScene.componentsinfos.ParametricGrid[p+1]; 295 for (uint i = 0; i < ugrid-1; i ++) 296 for (uint j = 0; j < vgrid-1; j ++) 297 { 298 (stream) << "f " 299 << " " << (i*vgrid + j+index) +1<< " " 300 << ((i+1)*vgrid + j +index) +1<< " " 301 << ((i+1)*vgrid + (j+1)+index) +1<< " " 302 << (i*vgrid + (j+1)+index) +1<< "\n"; 303 } 304 index += ugrid*vgrid; 305 } 306 307 // Isosurfaces components 308 startpl = LocalScene.PolyNumber+LocalScene.componentsinfos.MinParametricMeshLines; 309 uint kl= LocalScene.componentsinfos.NbParametricMeshLines; 310 for (uint i = kl; i < LocalScene.NbPolygnNbVertexPtMin; i++) 311 { 312 uint polysize = LocalScene.PolyIndices_localPtMin[i]; 313 (stream) << "f"; 314 for (uint j = 0; j < polysize; j++) 315 { 316 actualpointindice = LocalScene.PolyIndices_localPt[startpl++]+1; 317 (stream) << " " << actualpointindice; 318 } 319 (stream) << "\n"; 320 } 321 322 } 323 } 324 } 325 326 void MathMod::SaveSceneAsObjTrian(int type) 327 { 328 QString fileName = QFileDialog::getSaveFileName(this, tr("Save OBJ file"), "", 329 tr("OBJ Files (*.obj)")); 330 QFile data(fileName); 331 if (data.open(QFile::ReadWrite | QFile::Truncate)) 332 { 333 uint i; 334 QTextStream stream(&data); 335 stream.setRealNumberNotation(QTextStream::FixedNotation); 336 stream.setRealNumberPrecision(3); 337 // save vertices: 338 if (type == 1) 339 { 340 for (i = 0; i < LocalScene.VertxNumber; i++) 341 { 342 (stream) << "v " 343 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 7]) * 344 (difMaximum*factx / hauteur_fenetre) - decalage_xo) 345 << " " 346 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 8]) * 347 (difMaximum*facty / hauteur_fenetre) - decalage_yo) 348 << " " 349 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 9]) * 350 (difMaximum*factz / hauteur_fenetre) - decalage_zo) 351 << " " << LocalScene.ArrayNorVer_localPt[10 * i] << " " 352 << LocalScene.ArrayNorVer_localPt[10 * i + 1] << " " 353 << LocalScene.ArrayNorVer_localPt[10 * i + 2] << "\n"; 354 } 355 } 356 else 357 { 358 for (i = 0; i < LocalScene.VertxNumber; i++) 359 { 360 (stream) << "v " 361 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 7]) * 362 (difMaximum*factx / hauteur_fenetre) - decalage_xo) 363 << " " 364 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 8]) * 365 (difMaximum*facty / hauteur_fenetre) - decalage_yo) 366 << " " 367 << float(double(LocalScene.ArrayNorVer_localPt[10 * i + 9]) * 368 (difMaximum*factz / hauteur_fenetre) - decalage_zo) 369 << "\n"; 370 } 371 } 372 for (i = 0; i < LocalScene.PolyNumber; i += 3) 373 { 374 (stream) << "f " 375 << " " << LocalScene.PolyIndices_localPt[i] + 1 << " " 376 << LocalScene.PolyIndices_localPt[i + 1] + 1 << " " 377 << LocalScene.PolyIndices_localPt[i + 2] + 1 << "\n"; 378 } 379 } 380 } 381 382 MathMod::~MathMod() 383 { 384 delete (timer); 385 delete ParObjet; 386 delete IsoObjet; 387 } 388 389 void MathMod::PutObjectInsideCube() 390 { 391 minx = 999999999.0; 392 miny = 999999999.0; 393 minz = 999999999.0; 394 maxx = -999999999.0; 395 maxy = -999999999.0; 396 maxz = -999999999.0; 397 if ((LocalScene.morph != 1 || 398 (LocalScene.morph == 1 && FistTimecalibrate == 1)) && 399 LocalScene.slider != 1) 400 { 401 for (uint i = 0; i < LocalScene.VertxNumber; i++) 402 { 403 if (minx > LocalScene.ArrayNorVer_localPt[10 * i + 3 + 4]) 404 minx = LocalScene.ArrayNorVer_localPt[10 * i + 3 + 4]; 405 if (miny > LocalScene.ArrayNorVer_localPt[10 * i + 4 + 4]) 406 miny = LocalScene.ArrayNorVer_localPt[10 * i + 4 + 4]; 407 if (minz > LocalScene.ArrayNorVer_localPt[10 * i + 5 + 4]) 408 minz = LocalScene.ArrayNorVer_localPt[10 * i + 5 + 4]; 409 410 if (maxx < LocalScene.ArrayNorVer_localPt[10 * i + 3 + 4]) 411 maxx = LocalScene.ArrayNorVer_localPt[10 * i + 3 + 4]; 412 if (maxy < LocalScene.ArrayNorVer_localPt[10 * i + 4 + 4]) 413 maxy = LocalScene.ArrayNorVer_localPt[10 * i + 4 + 4]; 414 if (maxz < LocalScene.ArrayNorVer_localPt[10 * i + 5 + 4]) 415 maxz = LocalScene.ArrayNorVer_localPt[10 * i + 5 + 4]; 416 } 417 FistTimecalibrate = -1; 418 oldminx = minx; oldminy = miny; oldminz=minz; 419 oldmaxx = maxx; oldmaxy = maxy; oldmaxz=maxz; 420 difX = maxx - minx; 421 difY = maxy - miny; 422 difZ = maxz - minz; 423 // Recherche du maximum : 424 difMaximum = double(difX); 425 if (difY > float(difMaximum)) 426 { 427 difMaximum = double(difY); 428 } 429 if (difZ > float(difMaximum)) 430 { 431 difMaximum = double(difZ); 432 } 433 /// On va inclure cet objet dans un cube de langueur maximum 434 /// egale a "hauteur_fenetre" 435 decalage_xo = -double(minx + maxx) / 2; 436 decalage_yo = -double(miny + maxy) / 2; 437 decalage_zo = -double(minz + maxz) / 2; 438 } 439 for (uint i = 0; i < LocalScene.VertxNumber; i++) 440 { 441 LocalScene.ArrayNorVer_localPt[10 * i + 7] = float( 442 hauteur_fenetre * 443 (double(LocalScene.ArrayNorVer_localPt[10 * i + 7]) + decalage_xo) / 444 difMaximum); 445 LocalScene.ArrayNorVer_localPt[10 * i + 8] = float( 446 hauteur_fenetre * 447 (double(LocalScene.ArrayNorVer_localPt[10 * i + 8]) + decalage_yo) / 448 difMaximum); 449 LocalScene.ArrayNorVer_localPt[10 * i + 9] = float( 450 hauteur_fenetre * 451 (double(LocalScene.ArrayNorVer_localPt[10 * i + 9]) + decalage_zo) / 452 difMaximum); 453 } 454 455 // Cube vertices and indexes 456 float longX = wh * float(difX / float(difMaximum)), 457 longY = wh * (difY / float(difMaximum)), 458 longZ = wh * (difZ / float(difMaximum)); 459 uint NbVert = LocalScene.VertxNumber; 460 CubeStartIndex=NbVert; 461 for(uint id=0; id<12; id++) 462 { 463 LocalScene.ArrayNorVer_localPt[10 * (NbVert+id) + 0] = 0.8f; 464 LocalScene.ArrayNorVer_localPt[10 * (NbVert+id) + 1] = 0.8f; 465 LocalScene.ArrayNorVer_localPt[10 * (NbVert+id) + 2] = 0.8f; 466 LocalScene.ArrayNorVer_localPt[10 * (NbVert+id) + 3] = 1.0f; 467 } 468 469 LocalScene.ArrayNorVer_localPt[10 * NbVert + 7] = -longX; 470 LocalScene.ArrayNorVer_localPt[10 * NbVert + 8] = -longY; 471 LocalScene.ArrayNorVer_localPt[10 * NbVert + 9] = -longZ; 472 473 LocalScene.ArrayNorVer_localPt[10 * (NbVert+1) + 7] = longX; 474 LocalScene.ArrayNorVer_localPt[10 * (NbVert+1) + 8] = -longY; 475 LocalScene.ArrayNorVer_localPt[10 * (NbVert+1) + 9] = -longZ; 476 477 LocalScene.ArrayNorVer_localPt[10 * (NbVert+2) + 7] = longX; 478 LocalScene.ArrayNorVer_localPt[10 * (NbVert+2) + 8] = longY; 479 LocalScene.ArrayNorVer_localPt[10 * (NbVert+2) + 9] = -longZ; 480 481 LocalScene.ArrayNorVer_localPt[10 * (NbVert+3) + 7] = -longX; 482 LocalScene.ArrayNorVer_localPt[10 * (NbVert+3) + 8] = longY; 483 LocalScene.ArrayNorVer_localPt[10 * (NbVert+3) + 9] = -longZ; 484 485 LocalScene.ArrayNorVer_localPt[10 * (NbVert+4) + 7] = -longX; 486 LocalScene.ArrayNorVer_localPt[10 * (NbVert+4) + 8] = -longY; 487 LocalScene.ArrayNorVer_localPt[10 * (NbVert+4) + 9] = -longZ; 488 489 LocalScene.ArrayNorVer_localPt[10 * (NbVert+5) + 7] = -longX; 490 LocalScene.ArrayNorVer_localPt[10 * (NbVert+5) + 8] = -longY; 491 LocalScene.ArrayNorVer_localPt[10 * (NbVert+5) + 9] = longZ; 492 493 LocalScene.ArrayNorVer_localPt[10 * (NbVert+6) + 7] = -longX; 494 LocalScene.ArrayNorVer_localPt[10 * (NbVert+6) + 8] = longY; 495 LocalScene.ArrayNorVer_localPt[10 * (NbVert+6) + 9] = longZ; 496 497 LocalScene.ArrayNorVer_localPt[10 * (NbVert+7) + 7] = -longX; 498 LocalScene.ArrayNorVer_localPt[10 * (NbVert+7) + 8] = longY; 499 LocalScene.ArrayNorVer_localPt[10 * (NbVert+7) + 9] = -longZ; 500 501 LocalScene.ArrayNorVer_localPt[10 * (NbVert+8) + 7] = -longX; 502 LocalScene.ArrayNorVer_localPt[10 * (NbVert+8) + 8] = -longY; 503 LocalScene.ArrayNorVer_localPt[10 * (NbVert+8) + 9] = -longZ; 504 505 LocalScene.ArrayNorVer_localPt[10 * (NbVert+9) + 7] = -longX; 506 LocalScene.ArrayNorVer_localPt[10 * (NbVert+9) + 8] = -longY; 507 LocalScene.ArrayNorVer_localPt[10 * (NbVert+9) + 9] = longZ; 508 509 LocalScene.ArrayNorVer_localPt[10 * (NbVert+10) + 7] = longX; 510 LocalScene.ArrayNorVer_localPt[10 * (NbVert+10) + 8] = -longY; 511 LocalScene.ArrayNorVer_localPt[10 * (NbVert+10) + 9] = longZ; 512 513 LocalScene.ArrayNorVer_localPt[10 * (NbVert+11) + 7] = longX; 514 LocalScene.ArrayNorVer_localPt[10 * (NbVert+11) + 8] = -longY; 515 LocalScene.ArrayNorVer_localPt[10 * (NbVert+11) + 9] = -longZ; 516 517 // Plan vertices and indexes 518 PlanStartIndex=NbVert+12; 519 for(uint id=0; id<60; id++) 520 { 521 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+id)+0] = 0.6f; 522 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+id)+1] = 0.6f; 523 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+id)+2] = 0.6f; 524 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+id)+3] = 1.0f; 525 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+id)+7] = PlanArray[3*id ]; 526 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+id)+8] = PlanArray[3*id+1]; 527 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+id)+9] = PlanArray[3*id+2]; 528 } 529 530 // Axes vertices and indexes 531 AxesStartIndex = NbVert+12+60; 532 for(uint id=0; id<6; id++) 533 { 534 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+id)+0] = (id<2)?2.0f:0.0; 535 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+id)+1] = (id>1)&&(id<4)?2.0f:0.0; 536 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+id)+2] = (id>3)?2.0f:0.0; 537 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+id)+3] = 1.0f; 538 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+id)+7] = AxeArray[3*id ]; 539 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+id)+8] = AxeArray[3*id+1]; 540 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+id)+9] = AxeArray[3*id+2]; 541 } 542 543 // Head of the X Axe 544 XStartIndex = NbVert+12+60+6; 545 for(uint id=0; id<6; id++) 546 { 547 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+6+id)+0] = (id<2)?2.0f:0.3; 548 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+6+id)+1] = 0.0; 549 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+6+id)+2] = 0.0; 550 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+6+id)+3] = 1.0f; 551 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+6+id)+7] = AxeArray[3*(id+6) ]; 552 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+6+id)+8] = AxeArray[3*(id+6)+1]; 553 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+6+id)+9] = AxeArray[3*(id+6)+2]; 554 } 555 556 // Head of the Y Axe 557 YStartIndex = NbVert+12+60+12; 558 for(uint id=0; id<6; id++) 559 { 560 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+12+id)+0] = 0.0; 561 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+12+id)+1] = (id<2)?2.0f:0.3; 562 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+12+id)+2] = 0.0; 563 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+12+id)+3] = 1.0f; 564 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+12+id)+7] = AxeArray[3*(id+12) ]; 565 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+12+id)+8] = AxeArray[3*(id+12)+1]; 566 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+12+id)+9] = AxeArray[3*(id+12)+2]; 567 } 568 569 // Head of the Z Axe 570 ZStartIndex = NbVert+12+60+18; 571 for(uint id=0; id<6; id++) 572 { 573 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+18+id)+0] = 0.0; 574 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+18+id)+1] = 0.0; 575 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+18+id)+2] = (id<2)?2.0f:0.3; 576 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+18+id)+3] = 1.0f; 577 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+18+id)+7] = AxeArray[3*(id+18) ]; 578 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+18+id)+8] = AxeArray[3*(id+18)+1]; 579 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+18+id)+9] = AxeArray[3*(id+18)+2]; 580 } 581 582 // Letter X Axe 583 XletterIndex = NbVert+12+60+24; 584 for(uint id=0; id<4; id++) 585 { 586 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+24+id)+0] = 2.0; 587 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+24+id)+1] = 0.0; 588 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+24+id)+2] = 0.0; 589 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+24+id)+3] = 1.0f; 590 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+24+id)+7] = AxeArray[3*(id+24) ]; 591 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+24+id)+8] = AxeArray[3*(id+24)+1]; 592 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+24+id)+9] = AxeArray[3*(id+24)+2]; 593 } 594 // Letter Y Axe 595 YletterIndex = NbVert+12+60+28; 596 for(uint id=0; id<4; id++) 597 { 598 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+28+id)+0] = 0.0; 599 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+28+id)+1] = 2.0; 600 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+28+id)+2] = 0.0; 601 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+28+id)+3] = 1.0f; 602 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+28+id)+7] = AxeArray[3*(id+28) ]; 603 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+28+id)+8] = AxeArray[3*(id+28)+1]; 604 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+28+id)+9] = AxeArray[3*(id+28)+2]; 605 } 606 // Letter Y Axe 607 ZletterIndex = NbVert+12+60+32; 608 for(uint id=0; id<4; id++) 609 { 610 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+32+id)+0] = 0.0; 611 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+32+id)+1] = 0.0; 612 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+32+id)+2] = 2.0; 613 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+32+id)+3] = 1.0f; 614 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+32+id)+7] = AxeArray[3*(id+32) ]; 615 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+32+id)+8] = AxeArray[3*(id+32)+1]; 616 LocalScene.ArrayNorVer_localPt[10*(NbVert+12+60+32+id)+9] = AxeArray[3*(id+32)+2]; 617 } 618 uint polynb=0; 619 if(LocalScene.typedrawing == -1) 620 { 621 uint sz = LocalScene.componentsinfos.ParametricGrid.size(); 622 for (uint p = 0; p < sz; p += 2) 623 { 624 polynb += (LocalScene.componentsinfos.ParametricGrid[p]-1) * 625 (LocalScene.componentsinfos.ParametricGrid[p+1]-1); 626 } 627 } 628 else 629 polynb = LocalScene.NbPolygnNbVertexPtMin; 630 631 labelinfos = " \n Grid : "; 632 (LocalScene.typedrawing == 1) 633 ? labelinfos += QString::number(Xgrid - CutX) + "x" + 634 QString::number(Ygrid - CutY) + "x" + 635 QString::number(Zgrid - CutZ) +" \n" 636 : labelinfos += QString::number(Ugrid - CutU) + "x" + 637 QString::number(Vgrid - CutV) +" \n"; 638 labelinfos+=" Vertices : "+QString::number(LocalScene.VertxNumber)+" \n"+ 639 " Triangles: "+QString::number(LocalScene.PolyNumber/3)+" \n" 640 " Polygons : "+QString::number(polynb)+" \n"; 641 if(LocalScene.morph==-1) 642 labelinfos+=" X["+QString::number(minx,'g',3)+","+QString::number(maxx,'g',3)+"]\n\ 643 Y["+QString::number(miny,'g',3)+","+QString::number(maxy,'g',3)+"]\n\ 644 Z["+QString::number(minz,'g',3)+","+QString::number(maxz,'g',3)+"]\n"; 645 else 646 labelinfos+=" X["+QString::number(oldminx,'g',3)+","+QString::number(oldmaxx,'g',3)+"]\n\ 647 Y["+QString::number(oldminy,'g',3)+","+QString::number(oldmaxy,'g',3)+"]\n\ 648 Z["+QString::number(oldminz,'g',3)+","+QString::number(oldmaxz,'g',3)+"]\n"; 649 650 if(LocalScene.morph==1) 651 { 652 if(LocalScene.anim==-1) 653 LabelInfos.setText(labelinfos+" Morph: ON \n"); 654 else 655 LabelInfos.setText(labelinfos+" Rotation/Morph: ON \n"); 656 } 657 else 658 { 659 if(LocalScene.anim==-1) 660 LabelInfos.setText(labelinfos); 661 else 662 LabelInfos.setText(labelinfos+" Rotation: ON \n"); 663 } 664 } 665 666 void MathMod::png() 667 { 668 LocalScene.png_ok *= -1; 669 } 670 671 void MathMod::jpg() 672 { 673 LocalScene.jpg_ok *= -1; 674 } 675 676 void MathMod::bmp() 677 { 678 LocalScene.bmp_ok *= -1; 679 } 680 681 void MathMod::quality(int c) 682 { 683 LocalScene.quality_image = c; 684 } 685 686 void MathMod::colorstype(int c) 687 { 688 LocalScene.colortype = c; 689 } 690 691 void MathMod::colorstypeParIso(int c) 692 { 693 LocalScene.colortype = LocalScene.colortypeParam = c; 694 } 695 696 void MathMod::colorstypeParam(int c) 697 { 698 LocalScene.colortypeParam = c; 699 } 700 701 void MathMod::redSpec(int cl) 702 { 703 lightSpecular[0] = (cl/ 100.0f); 704 LocalScene.ShininessValUpdated=true; 705 update(); 706 } 707 708 void MathMod::greenSpec(int cl) 709 { 710 lightSpecular[1] = (cl/ 100.0f); 711 LocalScene.ShininessValUpdated=true; 712 update(); 713 } 714 715 void MathMod::blueSpec(int cl) 716 { 717 lightSpecular[2] = (cl/ 100.0f); 718 LocalScene.ShininessValUpdated=true; 719 update(); 720 } 721 722 void MathMod::redAmb(int cl) 723 { 724 lightAmbient[0] = (cl/ 100.0f); 725 LocalScene.AmbientValUpdated=true; 726 update(); 727 } 728 729 void MathMod::greenAmb(int cl) 730 { 731 lightAmbient[1] = (cl/ 100.0f); 732 LocalScene.AmbientValUpdated=true; 733 update(); 734 } 735 736 void MathMod::blueAmb(int cl) 737 { 738 lightAmbient[2] = (cl/100.0f); 739 LocalScene.AmbientValUpdated=true; 740 update(); 741 } 742 743 void MathMod::transAmb(int cl) 744 { 745 lightAmbient[3] = (cl/100.0f); 746 LocalScene.AmbientValUpdated=true; 747 update(); 748 } 749 750 void MathMod::redDiff(int cl) 751 { 752 lightDiffuse[0] = (cl/100.0f); 753 LocalScene.DiffuseValUpdated=true; 754 update(); 755 } 756 757 void MathMod::greenDiff(int cl) 758 { 759 lightDiffuse[1] = (cl/100.0f); 760 LocalScene.DiffuseValUpdated=true; 761 update(); 762 } 763 764 void MathMod::blueDiff(int cl) 765 { 766 lightDiffuse[2] = (cl/100.0f); 767 LocalScene.DiffuseValUpdated=true; 768 update(); 769 } 770 771 void MathMod::transDiff(int cl) 772 { 773 lightDiffuse[3] = (cl/ 100.0f); 774 LocalScene.DiffuseValUpdated=true; 775 update(); 776 } 777 778 void MathMod::glfrontfacesupp(int val) 779 { 780 LocalScene.glFrontFacingSupport = val; 781 LocalScene.FrontSurfValUpdated=true; 782 update(); 783 } 784 785 void MathMod::drawCube() 786 { 787 glLineWidth(1.0); 788 glUniform1i(uniformThereisRGBA, 0); 789 glDrawArrays(GL_LINE_STRIP,CubeStartIndex, 12); 790 glUniform1i(uniformThereisRGBA, 1); 791 } 792 793 void MathMod::DrawPariso(ObjectProperties *scene, uint ParisoTypeIndex) 794 { 795 uint idx = 0; 796 for (uint i = 0; i < ParisoTypeIndex; i++) 797 idx += scene->componentsinfos.NbComponentsType[i]; 798 int start_triangle = scene->componentsinfos.ParisoTriangle[2 * idx]; 799 float frontcl[4], backcl[4]; 800 glEnable(GL_POLYGON_OFFSET_FILL); 801 glPolygonOffset(scene->polyfactor, scene->polyunits); 802 if (!scene->componentsinfos.ThereisRGBA[ParisoTypeIndex]) 803 { 804 for (uint j = 0; j < 4; j++) 805 { 806 frontcl[j] = scene->frontcols[j]; 807 backcl[j] = scene->backcols[j]; 808 } 809 glUniform1i(uniformThereisRGBA, 1); 810 glUniform1i(uniformHSVactive, 0); 811 glUniform4fv(uniformFrontColor, 1, frontcl); 812 glUniform4fv(uniformBackColor, 1, backcl); 813 } 814 else 815 { 816 glUniform1i(uniformHSVactive, scene->componentsinfos.hsv[ParisoTypeIndex]?1:0); 817 glUniform1i(uniformThereisRGBA, 0); 818 } 819 820 if (scene->componentsinfos.ThereisCND[ParisoTypeIndex]) 821 { 822 size_t Offset0 = start_triangle*sizeof( GL_FLOAT); 823 glDrawElements( 824 GL_TRIANGLES, 825 int(3 * (scene->componentsinfos.NbTrianglesNoCND[ParisoTypeIndex])), 826 GL_UNSIGNED_INT, (void *)(Offset0)); 827 828 if (scene->cndoptions[0]) 829 { 830 size_t Offset1 = (3 * scene->componentsinfos.NbTrianglesNoCND[ParisoTypeIndex] +start_triangle)*sizeof( GL_FLOAT); 831 glDrawElements( 832 GL_TRIANGLES, 833 int(3 * (scene->componentsinfos.NbTrianglesVerifyCND[ParisoTypeIndex])), 834 GL_UNSIGNED_INT, (void *)(Offset1)); 835 } 836 837 if (scene->cndoptions[1]) 838 { 839 size_t Offset2 = (3 * scene->componentsinfos.NbTrianglesNoCND[ParisoTypeIndex] + 840 3 * scene->componentsinfos.NbTrianglesVerifyCND[ParisoTypeIndex] + 841 start_triangle)*sizeof( GL_FLOAT); 842 glDrawElements( 843 GL_TRIANGLES, 844 int(3 * (scene->componentsinfos.NbTrianglesNotVerifyCND[ParisoTypeIndex])), 845 GL_UNSIGNED_INT, 846 (void *)(Offset2)); 847 } 848 } 849 else 850 { 851 for (uint i = 0; i < scene->componentsinfos.NbComponentsType[ParisoTypeIndex]; i++) 852 { 853 uint cmpIndex = (ParisoTypeIndex==1) ? (scene->componentsinfos.NbComponentsType[0]+i):i; 854 if (scene->componentsinfos.ShowParIsoCmp[cmpIndex]) 855 { 856 if (!scene->componentsinfos.ThereisRGBA[ParisoTypeIndex]) 857 { 858 for (uint j = 0; j < 4; j++) 859 { 860 frontcl[j] = scene->frontcols[4 * (i % 10) + j]; 861 backcl[j] = scene->backcols[4 * (i % 10) + j]; 862 } 863 glUniform1i(uniformThereisRGBA, 1); 864 glUniform4fv(uniformFrontColor, 1, frontcl); 865 glUniform4fv(uniformBackColor, 1, backcl); 866 } 867 else 868 { 869 glUniform1i(uniformThereisRGBA, 0); 870 } 871 { 872 size_t Offset = scene->componentsinfos.ParisoTriangle[2*(i+idx)]*sizeof( GL_FLOAT); 873 glDrawElements( 874 GL_TRIANGLES, 875 int(3 * scene->componentsinfos.ParisoTriangle[2 * (i + idx) + 1]),GL_UNSIGNED_INT,(void *)(Offset)); 876 } 877 } 878 } 879 } 880 glDisable(GL_POLYGON_OFFSET_FILL); 881 //glUniform1i(uniformThereisRGBA, 0); 882 } 883 884 void MathMod::normOk() 885 { 886 LocalScene.norm *= -1; 887 update(); 888 } 889 890 void MathMod::boundingboxOk() 891 { 892 LocalScene.boundingbox *= -1; 893 } 894 895 void MathMod::run() { 896 update(); 897 } 898 899 bool MathMod::timeractif() 900 { 901 return (LocalScene.anim == 1); 902 } 903 904 void MathMod::stoptimer() 905 { 906 timer->stop(); 907 update(); 908 } 909 910 void MathMod::starttimer() 911 { 912 timer->start(latence,this); 913 } 914 915 void MathMod::restarttimer(int newlatence) 916 { 917 latence = newlatence; 918 if (LocalScene.anim == 1) 919 { 920 timer->stop(); 921 timer->start(latence, this); 922 } 923 } 924 925 void MathMod::CreateShaderProgram() 926 { 927 int IsCompiled_VS, IsCompiled_FS; 928 GLuint vertexshader, fragmentshader; 929 char *vertexInfoLog; 930 char *fragmentInfoLog; 931 char *shaderProgramInfoLog; 932 int IsLinked; 933 int maxLength; 934 const int MAX_LENGTH = 2048; 935 char log[MAX_LENGTH]; 936 int logLength = 0; 937 bool shaderValid; 938 939 shaderprogramId = glCreateProgram(); 940 941 //+++++++++++++++++++++++++++++++// 942 //++++++++ Vertex shader ++++++++// 943 //+++++++++++++++++++++++++++++++// 944 vertexshader = glCreateShader(GL_VERTEX_SHADER); 945 shaderValid = glIsShader(vertexshader); 946 if (!shaderValid) 947 { 948 std::cout << "Could not create Vertex Shader!"; 949 } 950 static const char *c_str_vertex = 951 R"( 952 // GLSL version 953 //#version 120 954 #ifdef GL_ES 955 precision mediump float; 956 #endif 957 // uniforms 958 uniform mat4 matrixModelView; 959 uniform mat4 matrixNormal; 960 uniform mat4 matrixModelViewProjection; 961 uniform int glFrontFacing_1; 962 // vertex attribs (input) 963 attribute vec3 vertexPosition; 964 attribute vec3 vertexNormal; 965 attribute vec4 vertexColor; 966 // varyings (output) 967 varying vec3 esVertex, esNormal; 968 varying vec4 color; 969 varying vec4 v_position; 970 void main() 971 { 972 esVertex = vec3(matrixModelView * vec4(vertexPosition, 1.0)); 973 esNormal = vec3(matrixNormal * vec4(vertexNormal, 1.0)); 974 color = vertexColor; 975 if(glFrontFacing_1 == 0) 976 { 977 v_position = -matrixModelView * vec4 (vertexPosition, 1.0); 978 } 979 gl_Position = matrixModelViewProjection * vec4(vertexPosition, 1.0); 980 } 981 )"; 982 glShaderSource(vertexshader, 1, &c_str_vertex, NULL); 983 glCompileShader(vertexshader); 984 glGetShaderiv(vertexshader, GL_COMPILE_STATUS, &IsCompiled_VS); 985 if(IsCompiled_VS==GL_FALSE) 986 { 987 QMessageBox msgBox; 988 glGetShaderiv(vertexshader, GL_INFO_LOG_LENGTH, &maxLength); 989 vertexInfoLog = (char *)malloc(maxLength); 990 glGetShaderInfoLog(vertexshader, maxLength, &maxLength, vertexInfoLog); 991 std::string vertexInfoLogString = std::string(vertexInfoLog); 992 msgBox.setText("Error : " +QString::fromStdString(std::string(vertexInfoLog))); 993 msgBox.adjustSize(); 994 msgBox.exec(); 995 } 996 997 //++++++++++++++++++++++++++// 998 //++++++ Fragment shader +++// 999 //++++++++++++++++++++++++++// 1000 fragmentshader = glCreateShader(GL_FRAGMENT_SHADER); 1001 shaderValid = glIsShader(fragmentshader); 1002 if (!shaderValid) 1003 { 1004 std::cout << "Could not create Fragment Shader!"; 1005 } 1006 static const char *c_str_fragment = 1007 R"( 1008 // GLSL version 1009 //#version 120 1010 #ifdef GL_ES 1011 precision mediump float; 1012 #endif 1013 // uniforms 1014 uniform vec4 frontColor; 1015 uniform vec4 backColor; 1016 uniform vec4 gridColor; 1017 uniform vec4 lightPosition; 1018 uniform vec4 lightAmbient; 1019 uniform vec4 lightDiffuse; 1020 uniform vec4 lightSpecular; 1021 uniform int hsvactive; 1022 uniform int thereisRGBA; 1023 uniform int drawgridColor; 1024 uniform float shininess; 1025 uniform int glFrontFacing_2; 1026 // varyings 1027 varying vec3 esVertex, esNormal; 1028 varying vec4 color; 1029 varying vec4 v_position; 1030 1031 // All components are in the range [0…1], including hue. 1032 vec3 hsv2rgb(vec3 c) 1033 { 1034 vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 1035 vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 1036 return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 1037 } 1038 1039 void main() 1040 { 1041 vec4 color1=color; 1042 vec3 normal = normalize(esNormal); 1043 if(glFrontFacing_2 == 1) 1044 { 1045 if(gl_FrontFacing == false) 1046 { 1047 normal *= -1.0; 1048 if(thereisRGBA ==1) 1049 { 1050 color1=backColor; 1051 } 1052 1053 } 1054 else 1055 { 1056 if(thereisRGBA ==1) 1057 { 1058 color1=frontColor; 1059 } 1060 } 1061 } 1062 else 1063 { 1064 if(dot(normal, v_position.xyz) <= 0.0) 1065 { 1066 normal *= -1.0; 1067 if(thereisRGBA ==1) 1068 { 1069 color1=backColor; 1070 } 1071 } 1072 else 1073 { 1074 if(thereisRGBA ==1) 1075 { 1076 color1=frontColor; 1077 } 1078 } 1079 } 1080 if(drawgridColor == 1) 1081 { 1082 color1=gridColor; 1083 } 1084 vec3 light; 1085 if(lightPosition.w == 0.0) 1086 { 1087 light = normalize(lightPosition.xyz); 1088 } 1089 else 1090 { 1091 light = normalize(lightPosition.xyz - esVertex); 1092 } 1093 if(hsvactive == 1) 1094 color1 = vec4(hsv2rgb(color1.xyz), color1.w); 1095 vec3 view = normalize(-esVertex); 1096 vec3 halfv = normalize(light + view); 1097 vec4 fragColor = lightAmbient * color1; 1098 float dotNL = max(dot(normal, light), 0.0); 1099 fragColor += lightDiffuse* color1 * dotNL; // add diffuse 1100 float dotNH = max(dot(normal, halfv), 0.0); 1101 fragColor += (pow(dotNH, shininess) * lightSpecular) * color1; // add specular 1102 // set frag color 1103 //gl_FragColor = (hsvactive == 1)? vec4(hsv2rgb(fragColor.xyz), fragColor.w) : fragColor; 1104 gl_FragColor = fragColor; 1105 } 1106 )"; 1107 glShaderSource(fragmentshader, 1, &c_str_fragment, NULL); 1108 glCompileShader(fragmentshader); 1109 glGetShaderiv(fragmentshader, GL_COMPILE_STATUS, &IsCompiled_FS); 1110 if(IsCompiled_FS==GL_FALSE) 1111 { 1112 QMessageBox msgBox; 1113 glGetShaderiv(fragmentshader, GL_INFO_LOG_LENGTH, &maxLength); 1114 fragmentInfoLog = (char *)malloc(maxLength); 1115 glGetShaderInfoLog(fragmentshader, maxLength, &maxLength, fragmentInfoLog); 1116 std::string vertexInfoLogString = std::string(fragmentInfoLog); 1117 msgBox.setText("Error : " +QString::fromStdString(std::string(fragmentInfoLog))); 1118 msgBox.adjustSize(); 1119 msgBox.exec(); 1120 } 1121 1122 glAttachShader(shaderprogramId, vertexshader); 1123 glAttachShader(shaderprogramId, fragmentshader); 1124 glBindAttribLocation(shaderprogramId, 0, "in_Position"); 1125 glBindAttribLocation(shaderprogramId, 1, "in_Color"); 1126 glLinkProgram(shaderprogramId); 1127 glGetProgramiv(shaderprogramId, GL_LINK_STATUS, (int *)&IsLinked); 1128 if(!IsLinked) 1129 { 1130 glGetProgramiv(shaderprogramId, GL_INFO_LOG_LENGTH, &maxLength); 1131 shaderProgramInfoLog = (char *)malloc(maxLength); 1132 glGetProgramInfoLog(shaderprogramId, maxLength, &maxLength, shaderProgramInfoLog); 1133 } 1134 glUseProgram(shaderprogramId); 1135 uniformMatrixModelView = glGetUniformLocation(shaderprogramId, "matrixModelView"); 1136 uniformMatrixModelViewProjection = glGetUniformLocation(shaderprogramId, "matrixModelViewProjection"); 1137 uniformMatrixNormal = glGetUniformLocation(shaderprogramId, "matrixNormal"); 1138 uniformLightPosition = glGetUniformLocation(shaderprogramId, "lightPosition"); 1139 uniformLightAmbient = glGetUniformLocation(shaderprogramId, "lightAmbient"); 1140 uniformLightDiffuse = glGetUniformLocation(shaderprogramId, "lightDiffuse"); 1141 uniformLightSpecular = glGetUniformLocation(shaderprogramId, "lightSpecular"); 1142 uniformFrontColor = glGetUniformLocation(shaderprogramId, "frontColor"); 1143 uniformBackColor = glGetUniformLocation(shaderprogramId, "backColor"); 1144 uniformGridColor = glGetUniformLocation(shaderprogramId, "gridColor"); 1145 uniformThereisRGBA = glGetUniformLocation(shaderprogramId, "thereisRGBA"); 1146 uniformHSVactive = glGetUniformLocation(shaderprogramId, "hsvactive"); 1147 uniformShininess = glGetUniformLocation(shaderprogramId, "shininess"); 1148 uniformglFrontFacing_1 = glGetUniformLocation(shaderprogramId, "glFrontFacing_1"); 1149 uniformglFrontFacing_2 = glGetUniformLocation(shaderprogramId, "glFrontFacing_2"); 1150 uniformdrawgridColor = glGetUniformLocation(shaderprogramId, "drawgridColor"); 1151 attribVertexPosition = glGetAttribLocation(shaderprogramId, "vertexPosition"); 1152 attribVertexNormal = glGetAttribLocation(shaderprogramId, "vertexNormal"); 1153 attribVertexColor = glGetAttribLocation(shaderprogramId, "vertexColor"); 1154 glUniform4fv(uniformLightPosition, 1, lightPosition); 1155 glUniform4fv(uniformLightAmbient, 1, lightAmbient); 1156 glUniform4fv(uniformLightDiffuse, 1, lightDiffuse); 1157 glUniform4fv(uniformLightSpecular, 1, lightSpecular); 1158 glUniform4fv(uniformFrontColor, 1, frontColor); 1159 glUniform4fv(uniformBackColor, 1, backColor); 1160 glUniform4fv(uniformGridColor, 1, gridcol); 1161 glUniform1f(uniformShininess, shininessVal); 1162 glUniform1i(uniformglFrontFacing_1, LocalScene.glFrontFacingSupport); 1163 glUniform1i(uniformglFrontFacing_2, LocalScene.glFrontFacingSupport); 1164 glUniform1i(uniformThereisRGBA, 0); 1165 glUniform1i(uniformHSVactive, 0); 1166 glUniform1i(uniformdrawgridColor, 0); 1167 int linkStatus; 1168 glGetProgramiv(shaderprogramId, GL_LINK_STATUS, &linkStatus); 1169 if(linkStatus == GL_FALSE) 1170 { 1171 glGetProgramiv(shaderprogramId, GL_INFO_LOG_LENGTH, &logLength); 1172 glGetProgramInfoLog(shaderprogramId, MAX_LENGTH, &logLength, log); 1173 std::cout << "===== GLSL Program Log =====\n" << log << std::endl; 1174 return; 1175 } 1176 else 1177 { 1178 return; 1179 } 1180 } 1181 1182 void MathMod::proj() 1183 { 1184 qreal aspect = qreal(screenWidth) / qreal(screenHeight ? screenHeight : 1); 1185 const qreal zNear = 0.01, zFar = 15, fov = 60.0; 1186 matrixProjectionx.setToIdentity(); 1187 matrixProjectionx.perspective(fov, aspect, zNear, zFar); 1188 } 1189 1190 void MathMod::LoadShadersFiles() 1191 { 1192 CreateShaderProgram(); 1193 } 1194 1195 void MathMod::initializeGL() 1196 { 1197 initializeOpenGLFunctions(); 1198 glEnable(GL_DEPTH_TEST); 1199 glEnable(GL_BLEND); 1200 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1201 glFrontFace(GL_CCW); 1202 glClearColor(0, 0, 0, 0); 1203 proj(); 1204 } 1205 1206 void MathMod::resizeGL(int newwidth, int newheight) 1207 { 1208 screenWidth = newwidth; 1209 screenHeight = newheight; 1210 proj(); 1211 } 1212 1213 void MathMod::anim() 1214 { 1215 LocalScene.anim *= -1; 1216 if (LocalScene.anim == 1) 1217 { 1218 timer->start(latence, this); 1219 if (LocalScene.morph == -1) 1220 { 1221 LabelInfos.setText(labelinfos+" Rotation: ON \n"); 1222 } 1223 } 1224 else 1225 { 1226 oldRotation = rotation; 1227 if (LocalScene.morph == -1) 1228 { 1229 LabelInfos.setText(labelinfos); 1230 stoptimer(); 1231 } 1232 } 1233 } 1234 1235 void MathMod::morph() 1236 { 1237 LocalScene.morph *= -1; 1238 FistTimecalibrate *= -1; 1239 if (LocalScene.typedrawing == 1) 1240 { 1241 // Isosurfaces: 1242 IsoObjet->masterthread->activeMorph = LocalScene.morph; 1243 for (uint nbthreads = 0; nbthreads < IsoObjet->WorkerThreadsNumber - 1; 1244 nbthreads++) 1245 IsoObjet->workerthreads[nbthreads].activeMorph = LocalScene.morph; 1246 IsoObjet->IsoMorph(); 1247 } 1248 else if (LocalScene.typedrawing == -1) 1249 { 1250 // Parametric surfaces: 1251 ParObjet->masterthread->activeMorph = LocalScene.morph; 1252 for (uint nbthreads = 0; nbthreads < ParObjet->WorkerThreadsNumber - 1; 1253 nbthreads++) 1254 ParObjet->workerthreads[nbthreads].activeMorph = LocalScene.morph; 1255 ParObjet->ParMorph(); 1256 } 1257 else // Pariso objects 1258 { 1259 // Parametric surfaces: 1260 ParObjet->masterthread->activeMorph = LocalScene.morph; 1261 for (uint nbthreads = 0; nbthreads < ParObjet->WorkerThreadsNumber - 1; 1262 nbthreads++) 1263 ParObjet->workerthreads[nbthreads].activeMorph = LocalScene.morph; 1264 ParObjet->ParMorph(); 1265 // Isosurfaces: 1266 IsoObjet->masterthread->activeMorph = LocalScene.morph; 1267 for (uint nbthreads = 0; nbthreads < IsoObjet->WorkerThreadsNumber - 1; 1268 nbthreads++) 1269 IsoObjet->workerthreads[nbthreads].activeMorph = LocalScene.morph; 1270 IsoObjet->IsoMorph(); 1271 } 1272 if (LocalScene.morph == 1) 1273 { 1274 timer->start(latence, this); 1275 } 1276 else 1277 { 1278 if (LocalScene.anim == -1) 1279 { 1280 LabelInfos.setText(labelinfos); 1281 stoptimer(); 1282 } 1283 else 1284 { 1285 LabelInfos.setText(labelinfos+" Rotation: ON \n"); 1286 } 1287 } 1288 } 1289 1290 void MathMod::keyPressEvent(QKeyEvent *e) 1291 { 1292 int key = e->key(); 1293 switch (key) 1294 { 1295 case Qt::CTRL+Qt::Key_A: 1296 anim(); 1297 break; 1298 case Qt::CTRL+Qt::Key_P: 1299 morph(); 1300 break; 1301 case Qt::Key_C: 1302 Parent->show(); 1303 break; 1304 } 1305 update(); 1306 } 1307 void MathMod::FillOk() 1308 { 1309 LocalScene.fill *= -1; 1310 update(); 1311 } 1312 1313 void MathMod::DrawAxe() 1314 { 1315 glLineWidth(1.0); 1316 glUniform1i(uniformThereisRGBA, 0); 1317 glUniform1i(uniformHSVactive, 0); 1318 // Draw the three axes (lines without head) 1319 glDrawArrays(GL_LINES,AxesStartIndex,6); 1320 // Head of the X Axe: 1321 glDrawArrays(GL_TRIANGLE_FAN,XStartIndex,6); 1322 // Head of the Y Axe: 1323 glDrawArrays(GL_TRIANGLE_FAN,YStartIndex,6); 1324 // Head of the Z Axe: 1325 glDrawArrays(GL_TRIANGLE_FAN,ZStartIndex,6); 1326 glLineWidth(3.0); 1327 // Draw the X axe 1328 glDrawArrays(GL_LINES,XletterIndex,4); 1329 // Draw the Y axe 1330 glDrawArrays(GL_LINES,YletterIndex,4); 1331 // Draw the Z axe 1332 glDrawArrays(GL_LINE_STRIP,ZletterIndex,4); 1333 glUniform1i(uniformThereisRGBA, 1); 1334 } 1335 1336 void MathMod::DrawNormals(ObjectProperties *) 1337 { 1338 } 1339 1340 void MathMod::Winitialize_GL() 1341 { 1342 if (LocalScene.componentsinfos.updateviewer) 1343 { 1344 PutObjectInsideCube(); 1345 PutObjectInsideCubeOk=true; 1346 } 1347 } 1348 1349 void MathMod::UpdateGL() 1350 { 1351 if (LocalScene.updategl) 1352 { 1353 Winitialize_GL(); 1354 update(); 1355 } 1356 else 1357 LocalScene.updategl = true; 1358 } 1359 1360 void MathMod::DrawParisoCND(ObjectProperties *scene, uint compindex) 1361 { 1362 uint idx = 0; 1363 for (uint i = 0; i < compindex; i++) 1364 idx += scene->componentsinfos.NbComponentsType[i]; 1365 int start_triangle = scene->componentsinfos.ParisoTriangle[2 * idx]; 1366 glUniform1i(uniformThereisRGBA, 0); 1367 glUniform1i(uniformHSVactive, 0); 1368 if (scene->cndoptions[3]) 1369 { 1370 size_t Offset0 = (3 * scene->componentsinfos.NbTrianglesNoCND[compindex] + start_triangle)*sizeof( GL_FLOAT); 1371 glLineWidth(0.3); 1372 for (uint i = 0; i < (3 * scene->componentsinfos.NbTrianglesVerifyCND[compindex]); i += 3) 1373 { 1374 glDrawElements(GL_LINE_LOOP, 3, GL_UNSIGNED_INT, (void *)(Offset0)); 1375 Offset0+=(3*sizeof( GL_FLOAT)); 1376 } 1377 } 1378 1379 if (scene->cndoptions[4]) 1380 { 1381 size_t Offset1 = (3 * scene->componentsinfos 1382 .NbTrianglesNoCND[compindex] + 3 * scene->componentsinfos 1383 .NbTrianglesVerifyCND[compindex] + 1384 start_triangle)*sizeof(GL_FLOAT); 1385 glLineWidth(0.3); 1386 for (uint i = 0; i < (3 * scene->componentsinfos.NbTrianglesNotVerifyCND[compindex]); i += 3) 1387 { 1388 glDrawElements(GL_LINE_LOOP, 3, GL_UNSIGNED_INT, (void *)(Offset1)); 1389 Offset1+=(3*sizeof( GL_FLOAT)); 1390 } 1391 } 1392 if (scene->cndoptions[2]) 1393 { 1394 size_t Offset2 = (3*scene->componentsinfos.NbTrianglesNoCND[compindex]+3*(scene->componentsinfos.NbTrianglesVerifyCND[compindex] + 1395 scene->componentsinfos.NbTrianglesNotVerifyCND[compindex])+start_triangle)*sizeof( GL_FLOAT); 1396 glLineWidth(4.0); 1397 for (uint i = 0; i < (3 * scene->componentsinfos.NbTrianglesBorderCND[compindex]); i += 3) 1398 { 1399 glDrawElements(GL_LINE_LOOP, 3, GL_UNSIGNED_INT, (void *)(Offset2)); 1400 Offset2+=(3*sizeof( GL_FLOAT)); 1401 } 1402 } 1403 glUniform1i(uniformThereisRGBA, 1); 1404 } 1405 1406 void MathMod::DrawTrianglMesh(ObjectProperties *scene) 1407 { 1408 size_t Offset = 0; 1409 uint st = 0; 1410 glUniform4fv(uniformGridColor, 1, scene->gridcol); 1411 glUniform1i(uniformdrawgridColor, 1); 1412 glUniform1i(uniformThereisRGBA, 0); 1413 glUniform1i(uniformHSVactive, 0); 1414 glLineWidth(0.3); 1415 for (uint i = 0; i < scene->PolyNumber; i += 3) 1416 { 1417 Offset = st*sizeof( GL_FLOAT); 1418 glDrawElements(GL_LINE_LOOP, 3, GL_UNSIGNED_INT, (void *)(Offset)); 1419 st+=3; 1420 } 1421 glUniform1i(uniformdrawgridColor, 0); 1422 glUniform1i(uniformThereisRGBA, 1); 1423 } 1424 1425 void MathMod::DrawMinimalTopology(ObjectProperties *scene) 1426 { 1427 glUniform4fv(uniformGridColor, 1,scene->gridcol); 1428 glUniform1i(uniformdrawgridColor, 1); 1429 glUniform1i(uniformThereisRGBA, 0); 1430 glUniform1i(uniformHSVactive, 0); 1431 glLineWidth(0.4); 1432 uint st = scene->PolyNumber; 1433 uint polysize=0; 1434 size_t Offset; 1435 if(scene->typedrawing == -1) 1436 for (uint i = 0; i < (scene->NbPolygnNbVertexPtMin); i++) 1437 { 1438 polysize = scene->PolyIndices_localPtMin[i]; 1439 Offset = st*sizeof( GL_FLOAT); 1440 glDrawElements( 1441 GL_LINE_STRIP, 1442 polysize, 1443 GL_UNSIGNED_INT, 1444 (void *)(Offset)); 1445 st+=(polysize); 1446 } 1447 else 1448 if(scene->typedrawing == 1) 1449 for (uint i = 0; i < (scene->NbPolygnNbVertexPtMin); i++) 1450 { 1451 polysize = scene->PolyIndices_localPtMin[i]; 1452 Offset = st*sizeof( GL_FLOAT); 1453 glDrawElements( 1454 GL_LINE_LOOP, 1455 polysize, 1456 GL_UNSIGNED_INT, 1457 (void *)(Offset)); 1458 st+=(polysize); 1459 } 1460 else 1461 { 1462 uint kl= scene->componentsinfos.NbParametricMeshLines; 1463 for (uint i = 0; i < (scene->NbPolygnNbVertexPtMin); i++) 1464 { 1465 polysize = scene->PolyIndices_localPtMin[i]; 1466 Offset = st*sizeof( GL_FLOAT); 1467 glDrawElements( 1468 (i<kl)? GL_LINE_STRIP:GL_LINE_LOOP, 1469 polysize, 1470 GL_UNSIGNED_INT, 1471 (void *)(Offset)); 1472 st+=(polysize); 1473 } 1474 } 1475 glUniform1i(uniformdrawgridColor, 0); 1476 glUniform1i(uniformThereisRGBA, 1); 1477 } 1478 1479 void MathMod::plan() 1480 { 1481 glUniform1i(uniformThereisRGBA, 0); 1482 glUniform1i(uniformHSVactive, 0); 1483 glLineWidth(0.3); 1484 glDrawArrays(GL_LINES,PlanStartIndex,60); 1485 glUniform1i(uniformThereisRGBA, 1); 1486 } 1487 1488 void MathMod::CopyData(ObjectProperties *scene) 1489 { 1490 static int firstaction=0; 1491 static uint previousVertxNumber=0; 1492 static uint previousPolyNumberNbPolygnNbVertexPtMin=0; 1493 if(firstaction==0) 1494 { 1495 vbo[0]=vbo[1]=0; 1496 glGenBuffers(2, vbo); 1497 /* Bind our first VBO as being the active buffer and storing vertex attributes (coordinates) */ 1498 glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); 1499 glBufferData(GL_ARRAY_BUFFER, sizeof(float)*10*(scene->VertxNumber+(12+60+36)),scene->ArrayNorVer_localPt, GL_STATIC_DRAW); 1500 glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); 1501 /* Bind our first VBO as being the active buffer and storing vertex attributes (coordinates) */ 1502 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[1]); 1503 glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(uint)*(scene->PolyNumber + scene->NbPolygnNbVertexPtMinSize), scene->PolyIndices_localPt, GL_STATIC_DRAW); 1504 size_t cOffset = 0; 1505 size_t nOffset = cOffset + 4*sizeof( GL_FLOAT); 1506 size_t vOffset = nOffset + 3*sizeof (GL_FLOAT); 1507 // activate attribs 1508 glEnableVertexAttribArray(attribVertexColor); 1509 glEnableVertexAttribArray(attribVertexNormal); 1510 glEnableVertexAttribArray(attribVertexPosition); 1511 // set attrib arrays using glVertexAttribPointer() 1512 glVertexAttribPointer(attribVertexPosition, 3, GL_FLOAT, false, 10*sizeof( GL_FLOAT), (void*)vOffset); 1513 glVertexAttribPointer(attribVertexNormal, 3, GL_FLOAT, false, 10*sizeof( GL_FLOAT), (void*)nOffset); 1514 glVertexAttribPointer(attribVertexColor,4, GL_FLOAT, false, 10*sizeof( GL_FLOAT), (void*)cOffset); 1515 previousVertxNumber = scene->VertxNumber; 1516 previousPolyNumberNbPolygnNbVertexPtMin = (scene->PolyNumber + scene->NbPolygnNbVertexPtMinSize); 1517 firstaction++; 1518 } 1519 else{ 1520 if(scene->VertxNumber>previousVertxNumber) 1521 { 1522 glBufferData(GL_ARRAY_BUFFER, sizeof(float)*10*(scene->VertxNumber+(12+60+36)), scene->ArrayNorVer_localPt, GL_STATIC_DRAW); 1523 previousVertxNumber = scene->VertxNumber; 1524 } 1525 else 1526 { 1527 glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*10*(scene->VertxNumber+(12+60+36)), scene->ArrayNorVer_localPt); 1528 previousVertxNumber = scene->VertxNumber; 1529 } 1530 if((scene->PolyNumber + scene->NbPolygnNbVertexPtMinSize)>previousPolyNumberNbPolygnNbVertexPtMin) 1531 { 1532 glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(uint)*(scene->PolyNumber + scene->NbPolygnNbVertexPtMinSize), scene->PolyIndices_localPt, GL_STATIC_DRAW); 1533 previousPolyNumberNbPolygnNbVertexPtMin = (scene->PolyNumber + scene->NbPolygnNbVertexPtMinSize); 1534 } 1535 else 1536 { 1537 glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0, sizeof(uint)*(scene->PolyNumber + scene->NbPolygnNbVertexPtMinSize), scene->PolyIndices_localPt); 1538 previousPolyNumberNbPolygnNbVertexPtMin = (scene->PolyNumber + scene->NbPolygnNbVertexPtMinSize); 1539 } 1540 } 1541 } 1542 1543 void MathMod::draw(ObjectProperties *scene) 1544 { 1545 if(!PutObjectInsideCubeOk) 1546 return; 1547 if (scene->componentsinfos.Interleave) 1548 { 1549 CopyData(scene); 1550 scene->componentsinfos.Interleave = false; 1551 } 1552 // clear buffer 1553 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 1554 // set modelview matrix 1555 matrixViewx.setToIdentity(); 1556 matrixViewx.translate(0.0, 0.0, -cameraDistance); 1557 matrixViewx.rotate(rotation); 1558 matrixModelViewProjectionx = matrixProjectionx * matrixViewx; 1559 matrixNormalx=matrixViewx; 1560 matrixNormalx.setColumn(3, QVector4D(0,0,0,1)); 1561 glUniformMatrix4fv(uniformMatrixModelView, 1, false, matrixViewx.data()); 1562 glUniformMatrix4fv(uniformMatrixModelViewProjection, 1, false, matrixModelViewProjectionx.data()); 1563 glUniformMatrix4fv(uniformMatrixNormal, 1, false, matrixNormalx.data()); 1564 if(LocalScene.ShininessValUpdated) 1565 { 1566 glUniform1f(uniformShininess, shininessVal); 1567 glUniform4fv(uniformLightSpecular, 1, lightSpecular); 1568 LocalScene.ShininessValUpdated =false; 1569 } 1570 if(LocalScene.AmbientValUpdated) 1571 { 1572 glUniform4fv(uniformLightAmbient, 1, lightAmbient); 1573 LocalScene.AmbientValUpdated =false; 1574 } 1575 if(LocalScene.DiffuseValUpdated) 1576 { 1577 glUniform4fv(uniformLightDiffuse, 1, lightDiffuse); 1578 LocalScene.DiffuseValUpdated =false; 1579 } 1580 if(LocalScene.FrontSurfValUpdated) 1581 { 1582 glUniform1i(uniformglFrontFacing_1 , LocalScene.glFrontFacingSupport); 1583 glUniform1i(uniformglFrontFacing_2 , LocalScene.glFrontFacingSupport); 1584 LocalScene.FrontSurfValUpdated = false; 1585 } 1586 // We draw the Plan first because we don't want it to spin around X,Y and Z axes 1587 if (scene->plan == 1) 1588 plan(); 1589 if(LocalScene.animx==1) 1590 matrixViewx.rotate(rotationx); 1591 if(LocalScene.animy==1) 1592 matrixViewx.rotate(rotationy); 1593 if(LocalScene.animz==1) 1594 matrixViewx.rotate(rotationz); 1595 if(LocalScene.animx==1 || LocalScene.animy==1 || LocalScene.animz==1) 1596 { 1597 matrixModelViewProjectionx = matrixProjectionx * matrixViewx; 1598 matrixNormalx=matrixViewx; 1599 matrixNormalx.setColumn(3, QVector4D(0,0,0,1)); 1600 glUniformMatrix4fv(uniformMatrixModelView, 1, false, matrixViewx.data()); 1601 glUniformMatrix4fv(uniformMatrixModelViewProjection, 1, false, matrixModelViewProjectionx.data()); 1602 glUniformMatrix4fv(uniformMatrixNormal, 1, false, matrixNormalx.data()); 1603 } 1604 // Blend Effect activation: 1605 if (scene->transparency == 1) 1606 glDepthMask(GL_FALSE); 1607 1608 // Axe : 1609 if (scene->axe == 1) 1610 DrawAxe(); 1611 1612 if (scene->fill == 1 && scene->componentsinfos.updateviewer) 1613 for (uint i = 0; i < scene->componentsinfos.NbComponentsType.size(); i++) 1614 DrawPariso(scene, i); 1615 1616 // Draw Mesh Object: 1617 if (scene->triangles == 1 && scene->componentsinfos.updateviewer) 1618 DrawTrianglMesh(scene); 1619 1620 // Bounding Box: 1621 if (scene->boundingbox == 1) 1622 drawCube(); 1623 1624 // Draw Minimal topology for isosurfaces: 1625 if (scene->mesh == 1 && scene->componentsinfos.updateviewer) 1626 DrawMinimalTopology(scene); 1627 1628 if (scene->activarecnd && scene->componentsinfos.updateviewer) 1629 for (uint i = 0; i < scene->componentsinfos.NbComponentsType.size(); i++) 1630 if (scene->componentsinfos.ThereisCND[i]) 1631 DrawParisoCND(scene, i); 1632 1633 // Draw Normales: 1634 if (scene->norm == 1 && scene->componentsinfos.updateviewer) 1635 DrawNormals(scene); 1636 1637 if (scene->transparency == 1) 1638 glDepthMask(GL_TRUE); 1639 } 1640 1641 void MathMod::paintGL() 1642 { 1643 if (LocalScene.morph == 1) 1644 { 1645 if (LocalScene.typedrawing == -1) 1646 { 1647 ParObjet->ParamBuild( 1648 &(LocalScene.ArrayNorVer_localPt), &(LocalScene.PolyIndices_localPt), 1649 &LocalScene.PolyNumber, &LocalScene.VertxNumber, 1650 &(LocalScene.componentsinfos), &(LocalScene.PolyIndices_localPtMin), 1651 &(LocalScene.NbPolygnNbVertexPtMin), 1652 &(LocalScene.NbPolygnNbVertexPtMinSize)); 1653 } 1654 else if (LocalScene.typedrawing == 1) 1655 { 1656 IsoObjet->IsoBuild( 1657 &(LocalScene.ArrayNorVer_localPt), &(LocalScene.PolyIndices_localPt), 1658 &(LocalScene.PolyNumber), &(LocalScene.VertxNumber), 1659 &(LocalScene.PolyIndices_localPtMin), 1660 &(LocalScene.NbPolygnNbVertexPtMin), 1661 &(LocalScene.NbPolygnNbVertexPtMinSize), 1662 &(LocalScene.componentsinfos)); 1663 } 1664 else 1665 { 1666 ParObjet->ParamBuild( 1667 &(LocalScene.ArrayNorVer_localPt), &(LocalScene.PolyIndices_localPt), 1668 &LocalScene.PolyNumber, &LocalScene.VertxNumber, 1669 &(LocalScene.componentsinfos), &(LocalScene.PolyIndices_localPtMin), 1670 &(LocalScene.NbPolygnNbVertexPtMin), 1671 &(LocalScene.NbPolygnNbVertexPtMinSize)); 1672 IsoObjet->IsoBuild( 1673 &(LocalScene.ArrayNorVer_localPt), &(LocalScene.PolyIndices_localPt), 1674 &(LocalScene.PolyNumber), &(LocalScene.VertxNumber), 1675 &(LocalScene.PolyIndices_localPtMin), 1676 &(LocalScene.NbPolygnNbVertexPtMin), 1677 &(LocalScene.NbPolygnNbVertexPtMinSize), 1678 &(LocalScene.componentsinfos)); 1679 } 1680 Winitialize_GL(); 1681 } 1682 draw(&LocalScene); 1683 if (LocalScene.morph == 1 && LocalScene.frame == 1) 1684 FramesSave(); 1685 } 1686 1687 void MathMod::timerEvent(QTimerEvent *) 1688 { 1689 if(LocalScene.anim == 1) 1690 { 1691 if(LocalScene.animx==1) 1692 { 1693 rotationx = rotationx*QQuaternion::fromAxisAndAngle(QVector3D(1.0,0.0,0.0), LocalScene.animxValueStep); 1694 } 1695 if(LocalScene.animy==1) 1696 { 1697 rotationy = rotationy*QQuaternion::fromAxisAndAngle(QVector3D(0.0,1.0,0.0), LocalScene.animyValueStep); 1698 } 1699 if(LocalScene.animz==1) 1700 { 1701 rotationz = rotationz*QQuaternion::fromAxisAndAngle(QVector3D(0.0,0.0,1.0), LocalScene.animzValueStep); 1702 } 1703 if(LocalScene.animxyz == 1) 1704 rotation = QQuaternion::fromAxisAndAngle(n, acc/10) * rotation; 1705 oldRotation = rotation; 1706 } 1707 update(); 1708 } 1709 1710 void MathMod::mouseReleaseEvent(QMouseEvent *) 1711 { 1712 if(LocalScene.anim != 1) 1713 oldRotation = rotation; 1714 } 1715 1716 void MathMod::mousePressEvent(QMouseEvent *e) 1717 { 1718 // Save mouse press position 1719 mousePressPosition = QVector2D(e->localPos()); 1720 if(LocalScene.anim != 1) 1721 rotation = oldRotation; 1722 if (e->button() == Qt::LeftButton) 1723 { 1724 btgauche = 1; 1725 mouseLeftDown =true; 1726 } 1727 else 1728 { 1729 btgauche = 0; 1730 mouseLeftDown =false; 1731 } 1732 if (e->button() == Qt::RightButton) 1733 { 1734 btdroit = 1; 1735 mouseRightDown =true; 1736 } 1737 else 1738 { 1739 btdroit = 0; 1740 mouseRightDown =false; 1741 } 1742 if (e->button() == Qt::MidButton) 1743 btmilieu = 1; 1744 else 1745 btmilieu = 0; 1746 1747 mouseY = e->y()/2; 1748 } 1749 1750 void MathMod::mouseMoveEvent(QMouseEvent *e) 1751 { 1752 static int oldx=0, oldy=0; 1753 static QVector3D oldn=QVector3D(0,0,1); 1754 if(mouseLeftDown) 1755 { 1756 QVector2D diff = QVector2D(e->localPos()) - mousePressPosition; 1757 // Rotation axis is perpendicular to the mouse position difference 1758 n = QVector3D(diff.y(), diff.x(), 0.0).normalized(); 1759 // Accelerate angular speed relative to the length of the mouse sweep 1760 acc =std::sqrt((diff.y()-oldy)*(diff.y()-oldy)+ float(diff.x()-oldx)*(diff.x()-oldx))/ /*(double)(LocalScene.viewport[2]+1)*/3.0; 1761 // Calculate new rotation axis 1762 rotation = QQuaternion::fromAxisAndAngle(n, acc)*oldRotation; 1763 oldn = n; 1764 } 1765 if(mouseRightDown) 1766 { 1767 cameraDistance -= (e->y()/2 - mouseY) * 0.02f; 1768 mouseY = e->y()/2; 1769 } 1770 update(); 1771 } 1772 1773 void MathMod::screenshot() 1774 { 1775 QImage image = QOpenGLWidget::grabFramebuffer(); 1776 if (LocalScene.png_ok == 1) 1777 image.save("GLscreenshot.png", "PNG", LocalScene.quality_image); 1778 if (LocalScene.bmp_ok == 1) 1779 image.save("GLscreenshot.bmp", "BMP", LocalScene.quality_image); 1780 } 1781 1782 void MathMod::FramesShot() 1783 { 1784 LocalScene.frame *= -1; 1785 if (LocalScene.frame == 1) 1786 { 1787 FramesDir = QFileDialog::getExistingDirectory( 1788 this, tr("Choose Or Create Directory"), FramesDir, 1789 QFileDialog::DontResolveSymlinks); 1790 if (FramesDir != "" && !FramesDir.endsWith("/")) 1791 FramesDir += "/"; 1792 } 1793 } 1794 1795 void MathMod::FramesSave() 1796 { 1797 static int Index = 0; 1798 if (LocalScene.frame == 1) 1799 { 1800 QImage image = QOpenGLWidget::grabFramebuffer(); //:grabFrameBuffer(); 1801 QString FileName = 1802 FramesDir + QString("%1").arg(Index, 5, 10, QChar('0')) + ".png"; 1803 Index += 1; 1804 image.save(FileName, "PNG", 1); 1805 } 1806 } 1807 1808 QImage MathMod::Copyscreenshot() 1809 { 1810 return (QOpenGLWidget::grabFramebuffer()); 1811 } 1812 1813 void MathMod::transparency(int cl, int currentposition) 1814 { 1815 switch (LocalScene.colortype) 1816 { 1817 case 1: 1818 LocalScene.frontcols[(currentposition % 10) * 4 + 3] = (cl / 255.0f); 1819 break; 1820 case 0: 1821 LocalScene.backcols[(currentposition % 10) * 4 + 3] = (cl / 255.0f); 1822 break; 1823 case 2: 1824 LocalScene.gridcol[3] = (cl / 255.0f); 1825 break; 1826 case 3: 1827 LocalScene.groundcol[3] = (cl / 255.0f); 1828 glClearColor(LocalScene.groundcol[0], LocalScene.groundcol[1], 1829 LocalScene.groundcol[2], LocalScene.groundcol[3]); 1830 break; 1831 } 1832 update(); 1833 } 1834 1835 void MathMod::red(int cl, int currentposition) 1836 { 1837 switch (LocalScene.colortype) 1838 { 1839 case 1: 1840 LocalScene.frontcols[(currentposition % 10) * 4 + 0] = (cl / 255.0f); 1841 break; 1842 case 0: 1843 LocalScene.backcols[(currentposition % 10) * 4 + 0] = (cl / 255.0f); 1844 break; 1845 case 2: 1846 LocalScene.gridcol[0] = (cl / 255.0f); 1847 break; 1848 case 3: 1849 LocalScene.groundcol[0] = (cl / 255.0f); 1850 glClearColor(LocalScene.groundcol[0], LocalScene.groundcol[1], 1851 LocalScene.groundcol[2], LocalScene.groundcol[3]); 1852 break; 1853 } 1854 update(); 1855 } 1856 1857 void MathMod::green(int cl, int currentposition) 1858 { 1859 switch (LocalScene.colortype) 1860 { 1861 case 1: 1862 LocalScene.frontcols[(currentposition % 10) * 4 + 1] = (cl / 255.0f); 1863 break; 1864 case 0: 1865 LocalScene.backcols[(currentposition % 10) * 4 + 1] = (cl / 255.0f); 1866 break; 1867 case 2: 1868 LocalScene.gridcol[1] = (cl / 255.0f); 1869 break; 1870 case 3: 1871 LocalScene.groundcol[1] = (cl / 255.0f); 1872 glClearColor(LocalScene.groundcol[0], LocalScene.groundcol[1], 1873 LocalScene.groundcol[2], LocalScene.groundcol[3]); 1874 break; 1875 } 1876 update(); 1877 } 1878 1879 void MathMod::blue(int cl, int currentposition) 1880 { 1881 switch (LocalScene.colortype) 1882 { 1883 case 1: 1884 LocalScene.frontcols[(currentposition % 10) * 4 + 2] = (cl / 255.0f); 1885 break; 1886 case 0: 1887 LocalScene.backcols[(currentposition % 10) * 4 + 2] = (cl / 255.0f); 1888 break; 1889 case 2: 1890 LocalScene.gridcol[2] = (cl / 255.0f); 1891 break; 1892 case 3: 1893 LocalScene.groundcol[2] = (cl / 255.0f); 1894 glClearColor(LocalScene.groundcol[0], LocalScene.groundcol[1], 1895 LocalScene.groundcol[2], LocalScene.groundcol[3]); 1896 break; 1897 } 1898 update(); 1899 } 1900 1901 void MathMod::transSpec(int cl) 1902 { 1903 lightSpecular[3] = (cl/ 100.0f); 1904 LocalScene.ShininessValUpdated=true; 1905 update(); 1906 } 1907 1908 void MathMod::Shininess(int cl) 1909 { 1910 shininessVal= GLfloat(cl); 1911 LocalScene.ShininessValUpdated=true; 1912 update(); 1913 } 1914 1915 void MathMod::InitSpecularParameters() 1916 { 1917 glEnable(GL_DEPTH_TEST); 1918 glFrontFace(GL_CCW); 1919 update(); 1920 } 1921 1922 MathMod::MathMod(QWidget *parent, uint nbthreads, 1923 uint initparGrid, uint initisoGrid, uint FactX, uint FactY, 1924 uint FactZ) :QOpenGLWidget(parent) 1925 { 1926 PerlinNoise = new ImprovedNoise(4., 4., 4.); 1927 latence = 10; 1928 Vgrid = Ugrid = 64; 1929 CutV = CutU = 0; 1930 Xgrid = Ygrid = Zgrid = 64; 1931 CutX = CutY = CutZ = 0; 1932 LocalScene.VertxNumber = 0; 1933 LabelInfos.setWindowFlags(Qt::WindowStaysOnTopHint| Qt::FramelessWindowHint); 1934 LabelInfos.setAttribute(Qt::WA_TranslucentBackground); 1935 LabelInfos.setAttribute(Qt::WA_NoSystemBackground); 1936 LabelInfos.setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); 1937 LabelInfos.setWindowOpacity(0.8); 1938 FramesDir = "/home"; 1939 hauteur_fenetre = 2*wh; 1940 timer = new QBasicTimer(); 1941 xyzactivated = uvactivated = uvactivated4D = 1; 1942 if (memoryallocation(nbthreads, initparGrid, initisoGrid, 1943 FactX, FactY, FactZ) != 1) 1944 exit(0); 1945 } 1946 1947 void MathMod::attachinfos() 1948 { 1949 if(LocalScene.attachwininfos ==1) 1950 { 1951 QRect r = geometry(); 1952 LabelInfos.move(r.left(), r.top()); 1953 LabelInfos.setWindowFlags(Qt::WindowStaysOnTopHint| Qt::FramelessWindowHint); 1954 LabelInfos.setAttribute(Qt::WA_TranslucentBackground); 1955 LabelInfos.setAttribute(Qt::WA_NoSystemBackground); 1956 if(LocalScene.infos == 1) 1957 LabelInfos.show(); 1958 } 1959 else 1960 { 1961 Qt::WindowFlags flags0 = LabelInfos.windowFlags(); 1962 flags0 &= ~Qt::FramelessWindowHint; 1963 LabelInfos.setWindowFlags(flags0); 1964 LabelInfos.setAttribute(Qt::WA_TranslucentBackground, false); 1965 LabelInfos.setAttribute(Qt::WA_NoSystemBackground, false); 1966 LabelInfos.setStyleSheet("QLabel { background-color : black; color : white; }"); 1967 LabelInfos.setAutoFillBackground(true); 1968 if(LocalScene.infos == 1) 1969 LabelInfos.show(); 1970 } 1971 } 1972 1973 void MathMod::closeEvent(QCloseEvent *) 1974 { 1975 LabelInfos.close(); 1976 } 1977 1978 void MathMod::moveEvent(QMoveEvent *) 1979 { 1980 if(LocalScene.attachwininfos ==1) 1981 { 1982 QRect r = geometry(); 1983 LabelInfos.move(r.x(), r.y()); 1984 } 1985 } 1986 1987 void MathMod::fill() 1988 { 1989 FillOk(); 1990 update(); 1991 } 1992 1993 void MathMod::iso_infos() 1994 { 1995 LocalScene.infos *= -1; 1996 if(LocalScene.infos == 1) 1997 { 1998 QRect r = geometry(); 1999 LabelInfos.move(r.x(), r.y()); 2000 LabelInfos.show(); 2001 } 2002 else 2003 LabelInfos.hide(); 2004 update(); 2005 } 2006 2007 void MathMod::updateGL() 2008 { 2009 update(); 2010 } 2011 2012 void MathMod::draw_norm_clicked() 2013 { 2014 normOk(); 2015 } 2016 2017 void MathMod::frames_clicked() 2018 { 2019 FramesShot(); 2020 } 2021 2022 void MathMod::linecolumn_valueupdate(int cl) 2023 { 2024 ParObjet->Vgrid = Vgrid = ParObjet->Ugrid = Ugrid = uint(cl); 2025 ParObjet->masterthread->Ugrid = 2026 ParObjet->masterthread->Vgrid = uint(cl); 2027 2028 for (uint nbthreads = 0; 2029 nbthreads < ParObjet->WorkerThreadsNumber - 1; 2030 nbthreads++) 2031 { 2032 ParObjet->workerthreads[nbthreads].Ugrid = 2033 ParObjet->workerthreads[nbthreads].Vgrid = uint(cl); 2034 } 2035 } 2036 2037 void MathMod::line_valueupdate(int cl) 2038 { 2039 ParObjet->Ugrid = Ugrid = ParObjet->masterthread->Ugrid = uint(cl); 2040 for (uint nbthreads = 0; 2041 nbthreads < ParObjet->WorkerThreadsNumber - 1; 2042 nbthreads++) 2043 { 2044 ParObjet->workerthreads[nbthreads].Ugrid = uint(cl); 2045 } 2046 } 2047 2048 void MathMod::column_valueupdate(int cl) 2049 { 2050 ParObjet->Vgrid = Vgrid = ParObjet->masterthread->Vgrid = uint(cl); 2051 2052 for (uint nbthreads = 0; 2053 nbthreads < ParObjet->WorkerThreadsNumber - 1; 2054 nbthreads++) 2055 { 2056 ParObjet->workerthreads[nbthreads].Vgrid = uint(cl); 2057 } 2058 } 2059 2060 void MathMod::linecolumn_valueChanged(int cl, ModelType type) 2061 { 2062 linecolumn_valueupdate(cl); 2063 if (uvactivated == 1) 2064 (type == PARISO_TYPE) ? ParisoObjectProcess():ParametricSurfaceProcess(1); 2065 else 2066 update(); 2067 } 2068 2069 void MathMod::line_valueChanged(int cl) 2070 { 2071 line_valueupdate(cl); 2072 if (uvactivated == 1) 2073 ParametricSurfaceProcess(1); 2074 else 2075 update(); 2076 } 2077 2078 void MathMod::column_valueChanged(int cl) 2079 { 2080 column_valueupdate(cl); 2081 if (uvactivated == 1) 2082 ParametricSurfaceProcess(1); 2083 else 2084 update(); 2085 } 2086 2087 void MathMod::linecolumn_valueChanged_2(int cl) 2088 { 2089 linecolumn_valueupdate(cl); 2090 if (uvactivated4D == 1) 2091 ParametricSurfaceProcess(3); 2092 else 2093 update(); 2094 } 2095 2096 void MathMod::Initparametricpage() 2097 { 2098 LocalScene.typedrawing = -1; 2099 } 2100 2101 void MathMod::xyzg_valueupdate(int cl) 2102 { 2103 IsoObjet->masterthread->XYZgrid = uint(cl); 2104 Xgrid = Ygrid = Zgrid = cl; 2105 } 2106 2107 void MathMod::xyzg_valueChanged(int cl, ModelType type) 2108 { 2109 xyzg_valueupdate(cl); 2110 // process the new surface 2111 if (xyzactivated == 1) 2112 (type == PARISO_TYPE) ? ParisoObjectProcess() : ProcessNewIsoSurface(); 2113 } 2114 2115 void MathMod::ShowErrormessage() 2116 { 2117 message.setTextFormat(Qt::RichText); 2118 int before, after; 2119 QString sortie = QString::fromStdString(stError.strError); 2120 if (sortie.length() > (stError.iErrorIndex + 30)) 2121 after = 30; 2122 else 2123 after = sortie.length() - stError.iErrorIndex; 2124 sortie.truncate(stError.iErrorIndex + after); 2125 if (stError.iErrorIndex - 30 > 0) 2126 before = 30; 2127 else 2128 before = 0; 2129 sortie = sortie.remove(0, stError.iErrorIndex - before); 2130 sortie.replace("\t", " "); 2131 sortie.replace("\n", " "); 2132 sortie.insert(before, " <font size=14 color=#FF0033>Error => </font>"); 2133 message.setText("Error at position: " + QString::number(stError.iErrorIndex) + 2134 "<br><br>" + "..." + sortie + "..."); 2135 message.adjustSize(); 2136 message.exec(); 2137 return; 2138 } 2139 2140 int MathMod::ParsePar() 2141 { 2142 stError = ParObjet->masterthread->parse_expression(); 2143 if (stError.iErrorIndex >= 0) 2144 { 2145 ShowErrormessage(); 2146 return -1; 2147 } 2148 else 2149 ParObjet->ThreadParsersCopy(); 2150 return 1; 2151 } 2152 2153 void MathMod::ParametricSurfaceProcess(int type) 2154 { 2155 if (!ParObjet->isRunning()) 2156 { 2157 if (type == 3) 2158 { 2159 ParObjet->masterthread->param4D = 1; 2160 ParObjet->param4D = 1; 2161 ParObjet->masterthread->param3d_C = false; 2162 } 2163 else 2164 { 2165 ParObjet->masterthread->param4D = -1; 2166 ParObjet->param4D = -1; 2167 ParObjet->masterthread->param4d_C = false; 2168 } 2169 int result = ParsePar(); 2170 if (result == -1) 2171 return; 2172 LocalScene.typedrawing = -1; 2173 ParObjet->localScene = &(LocalScene); 2174 ParObjet->start(QThread::LowPriority); 2175 } 2176 } 2177 2178 void MathMod::ParisoObjectProcess() 2179 { 2180 LocalScene.typedrawing = 0; 2181 LocalScene.updategl = false; 2182 LocalScene.componentsinfos.pariso = true; 2183 2184 if (!ParObjet->isRunning()) 2185 { 2186 ParObjet->masterthread->param4D = 2187 ParObjet->param4D = -1; 2188 ParObjet->masterthread->param4d_C = 2189 ParObjet->masterthread->param3d_C = false; 2190 int result = ParsePar(); 2191 if (result == -1) 2192 return; 2193 ParObjet->localScene = &(LocalScene); 2194 ParObjet->start(QThread::LowPriority); 2195 ParObjet->wait(); 2196 } 2197 if (!IsoObjet->isRunning()) 2198 { 2199 int result = ParseIso(); 2200 if (result == -1) 2201 return; 2202 IsoObjet->localScene = &(LocalScene); 2203 IsoObjet->start(QThread::LowPriority); 2204 } 2205 } 2206 2207 int MathMod::ParseIso() 2208 { 2209 stError = IsoObjet->masterthread->ParserIso(); 2210 if (stError.iErrorIndex >= 0) 2211 { 2212 ShowErrormessage(); 2213 return -1; 2214 } 2215 else 2216 IsoObjet->ThreadParsersCopy(); 2217 return 1; 2218 } 2219 2220 void MathMod::ProcessNewIsoSurface() 2221 { 2222 if (!IsoObjet->isRunning()) 2223 { 2224 int result = ParseIso(); 2225 if (result == -1) 2226 return; 2227 LocalScene.typedrawing = 1; 2228 IsoObjet->localScene = &(LocalScene); 2229 IsoObjet->start(QThread::LowPriority); 2230 } 2231 } 2232 2233 void MathMod::slot_checkBox73_clicked(ModelType type) 2234 { 2235 xyzactivated *= -1; 2236 // process the new surface 2237 if (xyzactivated == 1) 2238 (type == PARISO_TYPE) ? ParisoObjectProcess() : ProcessNewIsoSurface(); 2239 } 2240 2241 void MathMod::slot_uv_clicked(ModelType type) 2242 { 2243 uvactivated *= -1; 2244 // process the new surface 2245 if (uvactivated == 1) 2246 (type == PARISO_TYPE) ? ParisoObjectProcess() : ParametricSurfaceProcess(1); 2247 } 2248 2249 void MathMod::slot_uv4D_clicked() 2250 { 2251 uvactivated4D *= -1; 2252 // process the new surface 2253 if (uvactivated4D == 1) 2254 ParametricSurfaceProcess(3); 2255 } 2256 2257 void MathMod::slot_triangles_clicked() 2258 { 2259 LocalScene.triangles *= -1; 2260 update(); 2261 } 2262 2263 void MathMod::Mesh() 2264 { 2265 LocalScene.mesh *= -1; 2266 update(); 2267 }