diff --git a/CMakeLists.txt b/CMakeLists.txt index 4a74af1..02bef69 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,5 +34,6 @@ add_executable(${PROJECT_NAME} ${SRC_FILES} ${IMGUI_FILES}) target_include_directories(${PROJECT_NAME} PUBLIC ${IMGUI_DIR}) # Compiler Flags Debug(-g -O0) Release(-O3) set(OPT_FLAG -O3) -target_compile_options(${PROJECT_NAME} PUBLIC ${OPT_FLAG} -Wall -Wno-unused-variable -Wno-comment) +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdiagnostics-color=always") +target_compile_options(${PROJECT_NAME} PUBLIC ${OPT_FLAG} -fdiagnostics-color=always -Wall -Wno-unused-variable -Wno-comment) target_link_libraries(${PROJECT_NAME} PUBLIC -static-libgcc -static-libstdc++ SDL2 SDL2main OpenCL quadmath ${OpenCV_LIBS}) diff --git a/icons/ABS-Data-Icon.ico b/icons/ABS-Data-Icon.ico new file mode 100644 index 0000000..cb1aca7 Binary files /dev/null and b/icons/ABS-Data-Icon.ico differ diff --git a/icons/ABS-Icon.ico b/icons/ABS-Icon.ico new file mode 100644 index 0000000..367a38f Binary files /dev/null and b/icons/ABS-Icon.ico differ diff --git a/icons/README.txt b/icons/README.txt new file mode 100644 index 0000000..c97fb12 --- /dev/null +++ b/icons/README.txt @@ -0,0 +1,5 @@ +ABS-Fractal-Explorer icons were made August 24th, 2023. + +The red icon is intended for ABS-Fractal-Explorer.exe, the blue one is intended for .fracExp and .fracExpKB files. + +Resolutions supported: 16x16, 24x24, 32x32, 48x48, 64x64, 96x96, 128x128 \ No newline at end of file diff --git a/src/Program_Def.h b/src/Program_Def.h index 1f4b1dc..9d98e92 100644 --- a/src/Program_Def.h +++ b/src/Program_Def.h @@ -20,10 +20,10 @@ //#define MONOCHROME_MODE #define PROGRAM_NAME "ABS-Fractal-Explorer" -#define PROGRAM_DATE "2024/01/07" /* YYYY/MM/DD */ +#define PROGRAM_DATE "2024/01/31" /* YYYY/MM/DD */ #define PROGRAM_V_MAJOR 1 #define PROGRAM_V_MINOR 1 -#define PROGRAM_V_PATCH 1 +#define PROGRAM_V_PATCH 2 #define PROGRAM_V_TAG "Alpha" #define PROGRAM_VERSION STR_N(PROGRAM_V_MAJOR) "." STR_N(PROGRAM_V_MINOR) "." STR_N(PROGRAM_V_PATCH) " " PROGRAM_V_TAG diff --git a/src/fracMulti.cpp b/src/fracMulti.cpp index d256454..c581d7f 100644 --- a/src/fracMulti.cpp +++ b/src/fracMulti.cpp @@ -78,6 +78,9 @@ x *= sample;\ y *= sample;\ uint32_t sResX = resX - 1;\ uint32_t sResY = resY - 1;\ +fpX zoomVal = pow((fpX)10.0, zoom);\ +fpX rotSin = sin((fpX)param.rot);\ +fpX rotCos = cos((fpX)param.rot);\ fpX numY = ((fpX)sResY / (fpX)2.0);\ fpX numX = ((fpX)sResX / (fpX)2.0);\ fpX numZ = (sResX >= sResY) ? numY * pow((fpX)10.0, zoom) : numX * pow((fpX)10.0, zoom); @@ -93,11 +96,11 @@ for (; x < resX; x += sample) {\ for (u32 v = 0; v < sample; v++) {\ for (u32 u = 0; u < sample; u++) {\ if (param.juliaSet == true) {\ - cpu_pixel_to_coordinate(x, y, &zr, &zi, ¶m, resX, resY, subSample);\ + cpu_pixel_to_coordinate(x, y, &zr, &zi, zoomVal, rotSin, rotCos, ¶m, resX, resY, subSample);\ cr = param.zr;\ ci = param.zi;\ } else {\ - cpu_pixel_to_coordinate(x, y, &cr, &ci, ¶m, resX, resY, subSample);\ + cpu_pixel_to_coordinate(x, y, &cr, &ci, zoomVal, rotSin, rotCos, ¶m, resX, resY, subSample);\ zr = (param.startingZ == false) ? (fpX)0.0 : param.zr;\ zi = (param.startingZ == false) ? (fpX)0.0 : param.zi;\ }\ @@ -683,52 +686,77 @@ void renderCPU_ABS_Mandelbrot(BufferBox* buf, Render_Data ren, ABS_Mandelbrot pa //printfInterval(0.3,"\nr: %.6lf i: %.6lf zoom: 10^%.4lf maxItr: %u",param.r,param.i,param.zoom,param.maxItr); // Default is FP64 - if (param.power == 2) { - if (ren.CPU_Precision == 32) { generateThreads(quadraticRenderFP32); } else - #ifdef enableFP80andFP128 - if (ren.CPU_Precision == 80) { generateThreads(quadraticRenderFP80); } else - if (ren.CPU_Precision == 128) { generateThreads(quadraticRenderFP128); } else - #endif - { generateThreads(quadraticRenderFP64); } - } else if (param.power == 3) { - if (ren.CPU_Precision == 32) { generateThreads(cubicRenderFP32); } else - #ifdef enableFP80andFP128 - if (ren.CPU_Precision == 80) { generateThreads(cubicRenderFP80); } else - if (ren.CPU_Precision == 128) { generateThreads(cubicRenderFP128); } else - #endif - { generateThreads(cubicRenderFP64); } - } else if (param.power == 4) { - if (ren.CPU_Precision == 32) { generateThreads(quarticRenderFP32); } else - #ifdef enableFP80andFP128 - if (ren.CPU_Precision == 80) { generateThreads(quarticRenderFP80); } else - if (ren.CPU_Precision == 128) { generateThreads(quarticRenderFP128); } else - #endif - { generateThreads(quarticRenderFP64); } - } else if (param.power == 5) { - if (ren.CPU_Precision == 32) { generateThreads(quinticRenderFP32); } else - #ifdef enableFP80andFP128 - if (ren.CPU_Precision == 80) { generateThreads(quinticRenderFP80); } else - if (ren.CPU_Precision == 128) { generateThreads(quinticRenderFP128); } else - #endif - { generateThreads(quinticRenderFP64); } - } else if (param.power == 6) { - if (ren.CPU_Precision == 32) { generateThreads(sexticRenderFP32); } else - #ifdef enableFP80andFP128 - if (ren.CPU_Precision == 80) { generateThreads(sexticRenderFP80); } else - if (ren.CPU_Precision == 128) { generateThreads(sexticRenderFP128); } else - #endif - { generateThreads(sexticRenderFP64); } - } else { - // if (ren.CPU_Precision == 32) { generateThreads(polynomialRenderFP32); } else - // #ifdef enableFP80andFP128 - // if (ren.CPU_Precision == 80) { generateThreads(polynomialRenderFP80); } else - // if (ren.CPU_Precision == 128) { generateThreads(polynomialRenderFP128); } else - // #endif - // { generateThreads(polynomialRenderFP64); } - printfInterval(0.5,"\nError: Unknown render parameters\nPower: %u CPU_Precision: %u",param.power,ren.CPU_Precision); - return; - //generateThreads(renderRow); //Original Method - } + switch(param.power) { + case 2: + switch(ren.CPU_Precision) { + case 32: generateThreads(quadraticRenderFP32); break; + #ifdef enableFP80andFP128 + case 80: generateThreads(quadraticRenderFP80); break; + case 128: generateThreads(quadraticRenderFP128); break; + #endif + default: // 64 + generateThreads(quadraticRenderFP64); + }; + break; + case 3: + switch(ren.CPU_Precision) { + case 32: generateThreads(cubicRenderFP32); break; + #ifdef enableFP80andFP128 + case 80: generateThreads(cubicRenderFP80); break; + case 128: generateThreads(cubicRenderFP128); break; + #endif + default: // 64 + generateThreads(cubicRenderFP64); + }; + break; + case 4: + switch(ren.CPU_Precision) { + case 32: generateThreads(quarticRenderFP32); break; + #ifdef enableFP80andFP128 + case 80: generateThreads(quarticRenderFP80); break; + case 128: generateThreads(quarticRenderFP128); break; + #endif + default: // 64 + generateThreads(quarticRenderFP64); + }; + break; + case 5: + switch(ren.CPU_Precision) { + case 32: generateThreads(quinticRenderFP32); break; + #ifdef enableFP80andFP128 + case 80: generateThreads(quinticRenderFP80); break; + case 128: generateThreads(quinticRenderFP128); break; + #endif + default: // 64 + generateThreads(quinticRenderFP64); + }; + break; + case 6: + switch(ren.CPU_Precision) { + case 32: generateThreads(sexticRenderFP32); break; + #ifdef enableFP80andFP128 + case 80: generateThreads(sexticRenderFP80); break; + case 128: generateThreads(sexticRenderFP128); break; + #endif + default: // 64 + generateThreads(sexticRenderFP64); + }; + break; + default: + // switch(ren.CPU_Precision) { + // case 32: generateThreads(polynomialRenderFP32); break; + // #ifdef enableFP80andFP128 + // case 80: generateThreads(polynomialRenderFP80); break; + // case 128: generateThreads(polynomialRenderFP128); break; + // #endif + // default: // 64 + // generateThreads(polynomialRenderFP64); + // }; + printfInterval(0.5,"\nError: Unknown render parameters\nPower: %u CPU_Precision: %u",param.power,ren.CPU_Precision); + return; + //generateThreads(renderRow); //Original Method + }; + for (u32 t = 0; t < tc; t++) { renderThread.at(t).join(); } @@ -786,9 +814,12 @@ polarAngle_template(fp64); y *= sample;\ uint32_t sResX = resX - 1;\ uint32_t sResY = resY - 1;\ + fpX zoomVal = pow((fpX)10.0, zoom);\ + fpX rotSin = sin((fpX)param.rot);\ + fpX rotCos = cos((fpX)param.rot);\ fpX numY = ((fpX)sResY / (fpX)2.0);\ fpX numX = ((fpX)sResX / (fpX)2.0);\ - fpX numZ = (sResX >= sResY) ? numY * pow((fpX)10.0, zoom) : numX * pow((fpX)10.0, zoom);\ + fpX numZ = (sResX >= sResY) ? numY * zoomVal : numX * zoomVal;\ const fpX power = (fpX)param.polarPower;\ const fpX powerHalf = (fpX)(param.polarPower / 2.0);\ const fp64 powerLog2 = 1.0 / log2((fp64)param.polarPower);\ @@ -803,11 +834,11 @@ polarAngle_template(fp64); for (uint32_t v = 0; v < sample; v++) {\ for (uint32_t u = 0; u < sample; u++) {\ if (param.juliaSet == true) {\ - cpu_pixel_to_coordinate(x, y, &zr, &zi, ¶m, resX, resY, subSample);\ + cpu_pixel_to_coordinate(x, y, &zr, &zi, zoomVal, rotSin, rotCos, ¶m, resX, resY, subSample);\ cr = param.zr;\ ci = param.zi;\ } else {\ - cpu_pixel_to_coordinate(x, y, &cr, &ci, ¶m, resX, resY, subSample);\ + cpu_pixel_to_coordinate(x, y, &cr, &ci, zoomVal, rotSin, rotCos, ¶m, resX, resY, subSample);\ zr = (param.startingZ == false) ? (fpX)0.0 : param.zr;\ zi = (param.startingZ == false) ? (fpX)0.0 : param.zi;\ }\ @@ -880,12 +911,15 @@ void renderCPU_Polar_Mandelbrot(BufferBox* buf, Render_Data ren, ABS_Mandelbrot /* Thread Creation */ // Default is FP64 - if (ren.CPU_Precision == 32) { generateThreads(polarRenderFP32); } else + switch(ren.CPU_Precision) { + case 32: generateThreads(polarRenderFP32); break; #ifdef enableFP80andFP128 - if (ren.CPU_Precision == 80) { generateThreads(polarRenderFP80); } else - if (ren.CPU_Precision == 128) { generateThreads(polarRenderFP128); } else + case 80: generateThreads(polarRenderFP80); break; + case 128: generateThreads(polarRenderFP128); break; #endif - { generateThreads(polarRenderFP64); } + default: // 64 + generateThreads(polarRenderFP64); + }; for (u32 t = 0; t < tc; t++) { renderThread.at(t).join(); } diff --git a/src/fractal.cpp b/src/fractal.cpp index 9ebef65..5cf5541 100644 --- a/src/fractal.cpp +++ b/src/fractal.cpp @@ -229,19 +229,20 @@ coordinate_to_pixel_template(fp64); #endif #define cpu_pixel_to_coordinate_template(fpX); \ -void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fpX* xO, fpX* yO, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample) { \ +void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fpX* xO, fpX* yO, fpX zoomVal, fpX rotSin, fpX rotCos, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample) { \ /* Normalizes Coordinates */\ uint32_t resX = ResX - 1;\ uint32_t resY = ResY - 1;\ fpX numX = ((fpX)resX / 2.0);\ fpX numY = ((fpX)resY / 2.0);\ - fpX numZ = (resX >= resY) ? numY * pow((fpX)10.0, (fpX)param->zoom) : numX * pow((fpX)10.0, (fpX)param->zoom);\ + fpX numZ = (resX >= resY) ? numY * zoomVal : numX * zoomVal;\ /* Applies Transformations */\ fpX xC = ((xI - numX) / numZ) * (fpX)param->sX;\ fpX yC = -((yI - numY) / numZ) * (fpX)param->sY;\ - *xO = (xC * cos((fpX)param->rot) - yC * sin((fpX)param->rot)) + param->r;\ - *yO = (yC * cos((fpX)param->rot) + xC * sin((fpX)param->rot)) + param->i;\ + *xO = (xC * rotCos - yC * rotSin) + (fpX)param->r;\ + *yO = (yC * rotCos + xC * rotSin) + (fpX)param->i;\ } + cpu_pixel_to_coordinate_template(fp32); cpu_pixel_to_coordinate_template(fp64); #ifdef enableFP80andFP128 diff --git a/src/fractal.h b/src/fractal.h index 8536a50..243d82e 100644 --- a/src/fractal.h +++ b/src/fractal.h @@ -143,11 +143,11 @@ void pixel_to_coordinate(int32_t xI, int32_t yI, fp32* xO, fp32* yO, ABS_Mandelb void pixel_to_coordinate(int32_t xI, int32_t yI, fp128* xO, fp128* yO, ABS_Mandelbrot* param, Render_Data* ren); #endif -void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fp32* xO, fp32* yO, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample); -void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fp64* xO, fp64* yO, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample); +void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fp32* xO, fp32* yO, fp32 zoomVal, fp32 rotSin, fp32 rotCos, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample); +void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fp64* xO, fp64* yO, fp64 zoomVal, fp64 rotSin, fp64 rotCos, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample); #ifdef enableFP80andFP128 - void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fp80* xO, fp80* yO, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample); - void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fp128* xO, fp128* yO, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample); + void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fp80* xO, fp80* yO, fp80 zoomVal, fp80 rotSin, fp80 rotCos, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample); + void cpu_pixel_to_coordinate(int32_t xI, int32_t yI, fp128* xO, fp128* yO, fp128 zoomVal, fp128 rotSin, fp128 rotCos, ABS_Mandelbrot* param, uint32_t ResX, uint32_t ResY, uint32_t subSample); #endif #define POLAR_POWER_MINIMUM 1.0100