1 /** 2 * Mandelbulber v2, a 3D fractal generator ,=#MKNmMMKmmßMNWy, 3 * ,B" ]L,,p%%%,,,§;, "K 4 * Copyright (C) 2014-21 Mandelbulber Team §R-==%w["'~5]m%=L.=~5N 5 * ,=mm=§M ]=4 yJKA"/-Nsaj "Bw,==,, 6 * This file is part of Mandelbulber. §R.r= jw",M Km .mM FW ",§=ß., ,TN 7 * ,4R =%["w[N=7]J '"5=],""]]M,w,-; T=]M 8 * Mandelbulber is free software: §R.ß~-Q/M=,=5"v"]=Qf,'§"M= =,M.§ Rz]M"Kw 9 * you can redistribute it and/or §w "xDY.J ' -"m=====WeC=\ ""%""y=%"]"" § 10 * modify it under the terms of the "§M=M =D=4"N #"%==A%p M§ M6 R' #"=~.4M 11 * GNU General Public License as §W =, ][T"]C § § '§ e===~ U !§[Z ]N 12 * published by the 4M",,Jm=,"=e~ § § j]]""N BmM"py=ßM 13 * Free Software Foundation, ]§ T,M=& 'YmMMpM9MMM%=w=,,=MT]M m§;'§, 14 * either version 3 of the License, TWw [.j"5=~N[=§%=%W,T ]R,"=="Y[LFT ]N 15 * or (at your option) TW=,-#"%=;[ =Q:["V"" ],,M.m == ]N 16 * any later version. J§"mr"] ,=,," =="""J]= M"M"]==ß" 17 * §= "=C=4 §"eM "=B:m|4"]#F,§~ 18 * Mandelbulber is distributed in "9w=,,]w em%wJ '"~" ,=,,ß" 19 * the hope that it will be useful, . "K= ,=RMMMßM""" 20 * but WITHOUT ANY WARRANTY; .''' 21 * without even the implied warranty 22 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 23 * 24 * See the GNU General Public License for more details. 25 * You should have received a copy of the GNU General Public License 26 * along with Mandelbulber. If not, see <http://www.gnu.org/licenses/>. 27 * 28 * ########################################################################### 29 * 30 * Authors: Krzysztof Marczak (buddhi1980@gmail.com) 31 * 32 * sFractal struct - container for fractal formula parameters 33 */ 34 35 #ifndef MANDELBULBER2_SRC_FRACTAL_H_ 36 #define MANDELBULBER2_SRC_FRACTAL_H_ 37 38 #include <memory> 39 40 #include "algebra.hpp" 41 42 #include "formula/definition/all_fractal_list_enums.hpp" 43 44 #ifndef M_PI_180 45 #define M_PI_180 0.01745329251994329576923690768489 46 #endif 47 48 // forward declarations 49 class cParameterContainer; 50 51 const int IFS_VECTOR_COUNT = 9; 52 const int HYBRID_COUNT = 5; 53 const int MANDELBOX_FOLDS = 2; 54 55 namespace fractal 56 { 57 enum enumOCLDEMode 58 { 59 ocl_DECalculated = 0, 60 ocl_deltaDE = 1, 61 ocl_noDE = 2 62 }; 63 } 64 65 enum enumGeneralizedFoldBoxType 66 { 67 generalizedFoldBoxType_foldTet = 0, 68 generalizedFoldBoxType_foldCube = 1, 69 generalizedFoldBoxType_foldOct = 2, 70 generalizedFoldBoxType_foldDodeca = 3, 71 generalizedFoldBoxType_foldOctCube = 4, 72 generalizedFoldBoxType_foldIcosa = 5, 73 generalizedFoldBoxType_foldBox6 = 6, 74 generalizedFoldBoxType_foldBox5 = 7 75 }; 76 struct sExtendedAux 77 { 78 int i; 79 80 CVector4 c; 81 CVector4 const_c; 82 CVector4 old_z; 83 // CVector4 sum_z; 84 double pos_neg; 85 86 double r; 87 double DE; 88 double DE0; 89 double dist; 90 double pseudoKleinianDE; 91 92 double actualScale; 93 double actualScaleA; 94 95 double color; 96 double colorHybrid; 97 98 double temp1000; 99 }; 100 101 struct sFoldColor 102 { 103 CVector3 factor; 104 CVector4 factor4D; 105 CVector4 difs0000; 106 double factorR; 107 double factorSp1; 108 double factorSp2; 109 double difs1; 110 bool auxColorEnabled; 111 bool auxColorEnabledA; 112 bool auxColorEnabledFalse; 113 bool auxColorEnabledAFalse; 114 int startIterationsA; 115 int stopIterationsA; 116 }; 117 118 struct sFractalGeneralizedFoldBox 119 { 120 enumGeneralizedFoldBoxType type; 121 CVector3 Nv_tet[4]; 122 CVector3 Nv_cube[6]; 123 CVector3 Nv_oct[8]; 124 CVector3 Nv_oct_cube[14]; 125 CVector3 Nv_dodeca[12]; 126 CVector3 Nv_icosa[20]; 127 CVector3 Nv_box6[8]; 128 CVector3 Nv_box5[7]; 129 int sides_tet; 130 int sides_cube; 131 int sides_oct; 132 int sides_oct_cube; 133 int sides_dodeca; 134 int sides_icosa; 135 int sides_box6; 136 int sides_box5; 137 }; 138 139 struct sFractalIFS 140 { 141 bool absX; 142 bool absY; 143 bool absZ; 144 bool enabled[IFS_VECTOR_COUNT]; 145 bool mengerSpongeMode; 146 bool rotationEnabled; 147 bool edgeEnabled; 148 CRotationMatrix mainRot; 149 CRotationMatrix rot[IFS_VECTOR_COUNT]; 150 CVector4 direction[IFS_VECTOR_COUNT]; 151 CVector3 edge; 152 CVector4 offset; 153 CVector3 rotations[IFS_VECTOR_COUNT]; 154 double distance[IFS_VECTOR_COUNT]; 155 double intensity[IFS_VECTOR_COUNT]; 156 CVector3 rotation; 157 double scale; 158 }; 159 160 struct sFractalMandelboxVary4D 161 { 162 double fold; 163 double minR; 164 double scaleVary; 165 double wadd; 166 double rPower; 167 }; 168 169 struct sFractalMandelbox 170 { 171 CVector3 rotationMain; 172 CVector3 rotation[MANDELBOX_FOLDS][3]; 173 sFoldColor color; 174 double scale; 175 double foldingLimit; 176 double foldingValue; 177 double foldingSphericalMin; 178 double foldingSphericalFixed; 179 double sharpness; 180 double solid; 181 double melt; 182 CVector4 offset; 183 bool rotationsEnabled; 184 bool mainRotationEnabled; 185 CRotationMatrix mainRot; 186 CRotationMatrix rot[MANDELBOX_FOLDS][3]; 187 CRotationMatrix rotinv[MANDELBOX_FOLDS][3]; 188 189 double fR2; 190 double mR2; 191 double mboxFactor1; 192 }; 193 194 struct sFractalBoxFoldBulbPow2 195 { 196 double zFactor; 197 double foldFactor; 198 }; 199 200 struct sFractalMandelbulb 201 { 202 double power; 203 double alphaAngleOffset; 204 double betaAngleOffset; 205 double gammaAngleOffset; 206 }; 207 208 struct sFractalAexion 209 { 210 double cadd; 211 }; 212 213 struct sFractalBuffalo 214 { 215 bool preabsx; 216 bool preabsy; 217 bool preabsz; 218 bool absx; 219 bool absy; 220 bool absz; 221 bool posz; 222 }; 223 224 struct sFractalDonut 225 { 226 double ringRadius; 227 double ringThickness; 228 double factor; 229 double number; 230 }; 231 232 //---------------------------------------------------------- 233 struct sFractalPlatonicSolid 234 { 235 double frequency; 236 double amplitude; 237 double rhoMul; 238 }; 239 240 // mandelbulb multi 241 enum enumMulti_acosOrAsin 242 { 243 multi_acosOrAsin_acos, 244 multi_acosOrAsin_asin 245 }; 246 247 enum enumMulti_atanOrAtan2 248 { 249 multi_atanOrAtan2_atan, 250 multi_atanOrAtan2_atan2 251 }; 252 253 enum enumMulti_OrderOfXYZ 254 { 255 multi_OrderOfXYZ_xyz, 256 multi_OrderOfXYZ_xzy, 257 multi_OrderOfXYZ_yxz, 258 multi_OrderOfXYZ_yzx, 259 multi_OrderOfXYZ_zxy, 260 multi_OrderOfXYZ_zyx 261 }; 262 struct sFractalMandelbulbMulti 263 { 264 enumMulti_acosOrAsin acosOrAsin; 265 enumMulti_acosOrAsin acosOrAsinA; 266 enumMulti_atanOrAtan2 atanOrAtan2; 267 enumMulti_atanOrAtan2 atanOrAtan2A; 268 269 enumMulti_OrderOfXYZ orderOfXYZ; 270 enumMulti_OrderOfXYZ orderOfXYZ2; 271 enumMulti_OrderOfXYZ orderOfXYZC; 272 }; 273 274 // sinTan2Trig 275 enum enumMulti_asinOrAcos 276 { 277 multi_asinOrAcos_asin, 278 multi_asinOrAcos_acos 279 }; 280 281 enum enumMulti_atan2OrAtan 282 { 283 multi_atan2OrAtan_atan2, 284 multi_atan2OrAtan_atan 285 }; 286 287 enum enumMulti_OrderOfZYX 288 { 289 multi_OrderOfZYX_zyx, 290 multi_OrderOfZYX_zxy, 291 multi_OrderOfZYX_yzx, 292 multi_OrderOfZYX_yxz, 293 multi_OrderOfZYX_xzy, 294 multi_OrderOfZYX_xyz 295 }; 296 struct sFractalSinTan2Trig 297 { 298 enumMulti_asinOrAcos asinOrAcos; 299 enumMulti_atan2OrAtan atan2OrAtan; 300 enumMulti_OrderOfZYX orderOfZYX; 301 }; 302 303 // surf fold box 304 enum enumMulti_orderOfFolds 305 { 306 multi_orderOfFolds_type1, 307 multi_orderOfFolds_type2, 308 multi_orderOfFolds_type3, 309 multi_orderOfFolds_type4, 310 multi_orderOfFolds_type5 311 }; 312 struct sFractalSurfFolds 313 { 314 enumMulti_orderOfFolds orderOfFolds1; 315 enumMulti_orderOfFolds orderOfFolds2; 316 enumMulti_orderOfFolds orderOfFolds3; 317 enumMulti_orderOfFolds orderOfFolds4; 318 enumMulti_orderOfFolds orderOfFolds5; 319 }; 320 321 // asurf mod2 322 enum enumMulti_orderOf3Folds 323 { 324 multi_orderOf3Folds_type1, 325 multi_orderOf3Folds_type2, 326 multi_orderOf3Folds_type3 327 }; 328 struct sFractalASurf3Folds 329 { 330 enumMulti_orderOf3Folds orderOf3Folds1; 331 enumMulti_orderOf3Folds orderOf3Folds2; 332 enumMulti_orderOf3Folds orderOf3Folds3; 333 }; 334 335 // benesi mag transforms 336 enum enumMulti_orderOfTransf 337 { 338 multi_orderOfTransf_typeT1, 339 multi_orderOfTransf_typeT1Mod, 340 multi_orderOfTransf_typeT2, 341 multi_orderOfTransf_typeT3, 342 multi_orderOfTransf_typeT4, 343 multi_orderOfTransf_typeT5b, 344 }; 345 struct sFractalMagTransforms 346 { 347 enumMulti_orderOfTransf orderOfTransf1; 348 enumMulti_orderOfTransf orderOfTransf2; 349 enumMulti_orderOfTransf orderOfTransf3; 350 enumMulti_orderOfTransf orderOfTransf4; 351 enumMulti_orderOfTransf orderOfTransf5; 352 }; 353 354 // combo3 355 enum enumMulti_combo3 356 { 357 multi_combo3_type1, 358 multi_combo3_type2, 359 multi_combo3_type3, 360 }; 361 struct sFractalCombo3 362 { 363 enumMulti_combo3 combo3; 364 }; 365 366 // combo4 367 enum enumMulti_combo4 368 { 369 multi_combo4_type1, 370 multi_combo4_type2, 371 multi_combo4_type3, 372 multi_combo4_type4, 373 }; 374 struct sFractalCombo4 375 { 376 enumMulti_combo4 combo4; 377 }; 378 379 // combo5 380 enum enumMulti_combo5 381 { 382 multi_combo5_type1, 383 multi_combo5_type2, 384 multi_combo5_type3, 385 multi_combo5_type4, 386 multi_combo5_type5, 387 }; 388 struct sFractalCombo5 389 { 390 enumMulti_combo5 combo5; 391 }; 392 393 // combo6 394 enum enumMulti_combo6 395 { 396 multi_combo6_type1, 397 multi_combo6_type2, 398 multi_combo6_type3, 399 multi_combo6_type4, 400 multi_combo6_type5, 401 multi_combo6_type6, 402 }; 403 struct sFractalCombo6 404 { 405 enumMulti_combo6 combo6; 406 }; 407 408 // basic combo 409 enum enumCombo 410 { 411 combo_mode0, 412 combo_mode1, 413 combo_mode2, 414 combo_mode3, 415 combo_mode4, 416 combo_mode5, 417 combo_mode6, 418 combo_mode7, 419 }; 420 struct sFractalCombo 421 { 422 enumCombo modeA; 423 // combo modeB; 424 // combo modeC; 425 }; 426 427 // for surfbox types 428 struct sFractalSurfBox 429 { 430 bool enabledX1; 431 bool enabledY1; 432 bool enabledZ1; 433 bool enabledX2False; 434 bool enabledY2False; 435 bool enabledZ2False; 436 bool enabledX3False; 437 bool enabledY3False; 438 bool enabledZ3False; 439 bool enabledX4False; 440 bool enabledY4False; 441 bool enabledZ4False; 442 bool enabledX5False; 443 bool enabledY5False; 444 bool enabledZ5False; 445 CVector4 offset1A111; 446 CVector4 offset1B111; 447 CVector4 offset2A111; 448 CVector4 offset2B111; 449 CVector4 offset3A111; 450 CVector4 offset3B111; 451 CVector4 offset1A222; 452 CVector4 offset1B222; 453 double scale1Z1; 454 }; 455 456 // for curvilinear 457 struct sFractalCpara 458 { 459 bool enabledLinear; 460 bool enabledCurves; 461 bool enabledParabFalse; 462 bool enabledParaAddP0; 463 double para00; 464 double paraA0; 465 double paraB0; 466 double paraC0; 467 double parabOffset0; 468 double para0; 469 double paraA; 470 double paraB; 471 double paraC; 472 double parabOffset; 473 double parabSlope; 474 double parabScale; 475 int iterA; 476 int iterB; 477 int iterC; 478 }; 479 480 struct sFractalAnalyticDE 481 { 482 bool enabled; 483 bool enabledFalse; 484 double scale1; 485 double tweak005; 486 double offset0; 487 double offset1; 488 double offset2; 489 }; 490 491 // common parameters for transforming formulas 492 struct sFractalTransformCommon 493 { 494 double angle0; 495 496 double angleDegA; 497 double angleDegB; 498 double angleDegC; 499 double cosA; 500 double cosB; 501 double cosC; 502 double sinA; 503 double sinB; 504 double sinC; 505 506 double angle72; 507 double alphaAngleOffset; 508 double betaAngleOffset; 509 double foldingValue; 510 double foldingLimit; 511 double invert0; 512 double invert1; 513 double offset; 514 double offset0; 515 double offsetA0; 516 double offsetB0; 517 double offsetC0; 518 double offsetD0; 519 double offsetE0; 520 double offsetF0; 521 double offsetR0; 522 double offset0005; 523 double offsetp01; 524 double offsetp05; 525 double offset01; 526 double offset02; 527 double offset05; 528 double offsetA05; 529 double offsetB05; 530 double offset1; 531 double offsetA1; 532 double offsetR1; 533 double offsetT1; 534 double offset105; 535 double offset2; 536 double offsetA2; 537 double offsetE2; 538 double offsetF2; 539 double offsetR2; 540 double offset3; 541 double offset4; 542 double multiplication; 543 double minR0; 544 double minR05; 545 double minR06; 546 double minR2p25; 547 double maxR2d1; 548 double maxMinR2factor; 549 double radius1; 550 double scaleNeg1; 551 double scale; 552 double scale0; 553 double scaleA0; 554 double scaleB0; 555 double scaleC0; 556 double scale025; 557 double scale05; 558 double scale08; 559 double scale1; 560 double scaleA1; 561 double scaleB1; 562 double scaleC1; 563 double scaleD1; 564 double scaleE1; 565 double scaleF1; 566 double scaleG1; 567 double scale1p1; 568 double scale015; 569 double scale2; 570 double scaleA2; 571 double scale3; 572 double scaleA3; 573 double scaleB3; 574 double scale4; 575 double scale6; 576 double scale8; 577 double scaleMain2; 578 double scaleVary0; 579 580 double pwr05; 581 double pwr4; 582 double pwr8; 583 double pwr8a; 584 double sqtR; 585 double mboxFactor1; 586 double inv0; 587 double inv1; 588 589 int startIterations; 590 int startIterations250; 591 int stopIterations; 592 int stopIterations15; 593 int stopIterations50; 594 int startIterationsA; 595 int stopIterationsA; 596 int startIterationsB; 597 int stopIterationsB; 598 int startIterationsC; 599 int stopIterationsC; 600 int stopIterationsC1; 601 int startIterationsCx; 602 int stopIterationsCx; 603 int startIterationsCy; 604 int stopIterationsCy; 605 int startIterationsD; 606 int stopIterationsD; 607 int stopIterationsD1; 608 int startIterationsE; 609 int stopIterationsE; 610 int startIterationsF; 611 int stopIterationsF; 612 int startIterationsG; 613 int stopIterationsG; 614 int startIterationsH; 615 int stopIterationsH; 616 int startIterationsI; 617 int stopIterationsI; 618 int startIterationsJ; 619 int stopIterationsJ; 620 int startIterationsK; 621 int stopIterationsK; 622 int startIterationsM; 623 int stopIterationsM; 624 int startIterationsN; 625 int stopIterationsN; 626 int startIterationsO; 627 int stopIterationsO; 628 int startIterationsP; 629 int stopIterationsP; 630 int stopIterationsP1; 631 int startIterationsR; 632 int stopIterationsR; 633 int stopIterationsR1; 634 int startIterationsRV; 635 int stopIterationsRV; 636 int startIterationsS; 637 int stopIterationsS; 638 int startIterationsT; 639 int stopIterationsT; 640 int stopIterationsT1; 641 int startIterationsTM; 642 int stopIterationsTM1; 643 int startIterationsX; 644 int stopIterationsX; 645 int startIterationsY; 646 int stopIterationsY; 647 int startIterationsZ; 648 int stopIterationsZ; 649 int startIterationsZc; 650 int stopIterationsZc; 651 int stopIterations1; 652 653 int intA; 654 int intB; 655 int int1; 656 int intA1; 657 int intB1; 658 int int2; 659 int int3; 660 int int3X; 661 int int3Y; 662 int int3Z; 663 int int6; 664 int int8X; 665 int int8Y; 666 int int8Z; 667 int int16; 668 669 CVector4 additionConstant0555; 670 CVector4 additionConstant0777; 671 CVector4 additionConstant000; 672 CVector4 additionConstantA000; 673 CVector4 additionConstantP000; 674 CVector4 additionConstant111; 675 CVector4 additionConstantA111; 676 CVector4 additionConstant222; 677 CVector4 additionConstantNeg100; 678 CVector4 constantMultiplier000; 679 CVector4 constantMultiplier001; 680 CVector4 constantMultiplier010; 681 CVector4 constantMultiplier100; 682 CVector4 constantMultiplierA100; 683 CVector4 constantMultiplier111; 684 CVector4 constantMultiplierA111; 685 CVector4 constantMultiplierB111; 686 CVector4 constantMultiplierC111; 687 CVector4 constantMultiplier121; 688 CVector4 constantMultiplier122; 689 CVector4 constantMultiplier221; 690 CVector4 constantMultiplier222; 691 CVector4 constantMultiplier441; 692 CVector4 juliaC; 693 CVector4 offset000; 694 CVector4 offsetA000; 695 CVector4 offsetF000; 696 CVector4 offset001; 697 CVector4 offset002; 698 CVector4 offset010; 699 CVector4 offset100; 700 CVector4 offset110; 701 CVector4 offset1105; 702 CVector4 offset111; 703 CVector4 offsetA111; 704 CVector4 offsetB111; 705 CVector4 offsetC111; 706 CVector4 offset200; 707 CVector4 offsetA200; 708 CVector4 offset222; 709 CVector4 offsetA222; 710 CVector4 offset333; 711 CVector4 power025; 712 CVector4 power8; 713 CVector4 vec111; 714 715 CVector3 rotation; // vec3s 716 CVector3 rotation2; 717 CVector3 rotationVary; 718 CVector3 rotation44a; //......................... 719 CVector3 rotation44b; //.......................... 720 721 CVector4 scaleP222; 722 CVector4 scale3D000; 723 CVector4 scale3D111; 724 CVector4 scale3D222; 725 CVector4 scale3Da222; 726 CVector4 scale3Db222; 727 CVector4 scale3Dc222; 728 CVector4 scale3Dd222; 729 CVector4 scale3D333; 730 CVector4 scale3D444; 731 732 CVector4 additionConstant0000; 733 CVector4 offset0000; 734 CVector4 offsetA0000; 735 CVector4 offsetp5555; 736 CVector4 offset1111; 737 CVector4 offsetA1111; 738 CVector4 offsetB1111; 739 CVector4 offsetNeg1111; 740 CVector4 offset2222; 741 CVector4 additionConstant111d5; 742 CVector4 constantMultiplier1220; 743 CVector4 scale0000; 744 CVector4 scale1111; 745 746 CRotationMatrix rotationMatrix; 747 CRotationMatrix rotationMatrix2; 748 CRotationMatrix rotationMatrixVary; 749 CRotationMatrix44 rotationMatrix44; //.................... 750 751 bool addCpixelEnabled; 752 bool addCpixelEnabledFalse; 753 bool alternateEnabledFalse; 754 bool benesiT1Enabled; 755 bool benesiT1EnabledFalse; 756 bool benesiT1MEnabledFalse; 757 bool functionEnabled4dFalse; 758 bool functionEnabled; 759 bool functionEnabledFalse; 760 bool functionEnabledx; 761 bool functionEnabledy; 762 bool functionEnabledz; 763 bool functionEnabledw; 764 bool functionEnabledxFalse; 765 bool functionEnabledyFalse; 766 bool functionEnabledzFalse; 767 bool functionEnabledwFalse; 768 bool functionEnabledAx; 769 bool functionEnabledAy; 770 bool functionEnabledAz; 771 bool functionEnabledAw; 772 bool functionEnabledAxFalse; 773 bool functionEnabledAyFalse; 774 bool functionEnabledAzFalse; 775 bool functionEnabledAwFalse; 776 bool functionEnabledBx; 777 bool functionEnabledBy; 778 bool functionEnabledBz; 779 bool functionEnabledBxFalse; 780 bool functionEnabledByFalse; 781 bool functionEnabledBzFalse; 782 bool functionEnabledCx; 783 bool functionEnabledCy; 784 bool functionEnabledCz; 785 bool functionEnabledCxFalse; 786 bool functionEnabledCyFalse; 787 bool functionEnabledCzFalse; 788 bool functionEnabledAFalse; 789 bool functionEnabledBFalse; 790 bool functionEnabledCFalse; 791 bool functionEnabledDFalse; 792 bool functionEnabledEFalse; 793 bool functionEnabledFFalse; 794 bool functionEnabledGFalse; 795 bool functionEnabledIFalse; 796 bool functionEnabledJFalse; 797 bool functionEnabledKFalse; 798 bool functionEnabledM; 799 bool functionEnabledMFalse; 800 bool functionEnabledNFalse; 801 bool functionEnabledOFalse; 802 bool functionEnabledPFalse; 803 bool functionEnabledRFalse; 804 bool functionEnabledSFalse; 805 bool functionEnabledSwFalse; 806 bool functionEnabledTFalse; 807 bool functionEnabledXFalse; 808 bool functionEnabledYFalse; 809 bool functionEnabledZcFalse; 810 bool juliaMode; 811 bool rotationEnabled; 812 bool rotationEnabledFalse; 813 bool rotation2EnabledFalse; 814 bool sphereInversionEnabledFalse; 815 bool spheresEnabled; 816 817 // bool functionEnabledTempFalse; 818 }; 819 820 struct sFractal 821 { 822 sFractal(const std::shared_ptr<cParameterContainer> par); 823 void RecalculateFractalParams(); 824 825 fractal::enumFractalFormula formula; 826 sFractalMandelbulb bulb; 827 sFractalIFS IFS; 828 sFractalMandelbox mandelbox; 829 sFractalGeneralizedFoldBox genFoldBox; 830 sFractalBoxFoldBulbPow2 foldingIntPow; 831 sFractalMandelboxVary4D mandelboxVary4D; 832 sFractalAexion aexion; 833 sFractalBuffalo buffalo; 834 sFractalPlatonicSolid platonicSolid; 835 sFractalTransformCommon transformCommon; 836 sFractalAnalyticDE analyticDE; 837 sFractalMandelbulbMulti mandelbulbMulti; 838 sFractalSinTan2Trig sinTan2Trig; 839 sFractalSurfBox surfBox; 840 sFractalSurfFolds surfFolds; 841 sFractalDonut donut; 842 sFoldColor foldColor; 843 sFractalMagTransforms magTransf; 844 sFractalCpara Cpara; 845 sFractalCombo combo; 846 sFractalASurf3Folds aSurf3Folds; 847 sFractalCombo3 combo3; 848 sFractalCombo4 combo4; 849 sFractalCombo5 combo5; 850 sFractalCombo6 combo6; 851 852 #ifdef USE_OPENCL 853 // double customParameters[15]; 854 // double deltaDEStep; 855 // char customOCLFormulaName[100]; 856 // fractal::enumOCLDEMode customOCLFormulaDEMode; 857 #endif 858 }; 859 860 #endif /* MANDELBULBER2_SRC_FRACTAL_H_ */ 861