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. For more information about "mathmod.cpp" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report:

11.0_vs_11.1.

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 }