bjoernager/mandelbrotsdl
bjoernager/mandelbrotsdl
Archived
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update to newest version (but with fixed source and Makefile).

Browse source 
Add .gitignore.
This commit is contained in:
Gabriel Bjørnager Jensen 2021-02-08 13:18:40 +01:00
parent 03c9b4c6f5
commit 1fe84887aa
26 changed files with 717 additions and 433 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
*.bin
*.o

29
Makefile Normal file
View file

@ -0,0 +1,29 @@
CXX = clang++
CXXFLAGS = -Iinclude -std=c++17 -Wall -Wextra -Wpedantic
CXXFLAGS += -march=native -mtune=native -O3
LDFLAGS = -lSDL2
HDRS_CXX = \
src/fractal.hh \
src/fractData.hh \
src/genf.hh \
src/mansdl.hh
SRCS_CXX = \
src/genf-burningShip.cc \
src/genf-julia.cc \
src/genf-mandelbrot.cc \
src/genf-mandelbrot3.cc \
src/genf-mandelbrot4.cc \
src/genf-mandelbrot5.cc \
src/genf-tricorn.cc \
src/main.cc \
src/mansdl-applyArgs.cc \
src/mansdl-checkEvent.cc \
src/mansdl-genf.cc \
src/mansdl-init.cc
OBJS_CXX=$(SRCS_CXX:.cc=.o)
mansdl.bin: $(OBJS_CXX)
$(CXX) $(LDFLAGS) -o $@ $(OBJS_CXX)
$(OBJS_CXX): $(HDRS_CXX) $(SRCS_CXX)
.PHONY: clean
clean:
rm mansdl.bin $(OBJ)

25
src/Makefile
View file

@ -1,25 +0,0 @@
CXX=g++
CXXFLAGS=-std=c++17 -Wall -Wextra -Wpedantic
CXXFLAGS+=-O3 -march=native
CXXFLAGS+=-Xlinker -zmuldefs
CXXFLAGS+=-lSDL2
OBJ=\
applyArgs.o cleanup.o dataTypes.o genf.o genf-julia.o genf-mandelbrot.o init_success.o main.o onInput.o
mansdl: $(OBJ)
$(CXX) $(OBJ) $(CXXFLAGS) -o $@
applyArgs.o: dataTypes.hh mansdl.hh applyArgs.cc
cleanup.o: dataTypes.hh mansdl.hh cleanup.cc
dataTypes.o: dataTypes.hh dataTypes.cc
genf.o: fractal.hh genf.hh genf.cc
genf-julia.o: dataTypes.hh fractal.hh genf-julia.cc
genf-mandebrot.o: dataTypes.hh fractal.hh genf-mandelbrot.cc
init_success.o: dataTypes.hh mansdl.hh init_success.cc
main.o: dataTypes.hh mansdl.hh main.cc
onInput.o: dataTypes.hh fractal.hh mansdl.hh onInput.cc
clean:
rm mansdl $(OBJ)

48
src/applyArgs.cc
View file

@ -1,48 +0,0 @@
/* Include external file(s) */
#include <iostream>
#include <string>
/* Include local file(s) */
#include "mansdl.hh"
bool mansdl::applyArgs(const int argc, const char** argv) { /* Declared as "bool" so we can know if we should continue */
if(argc > 1) {
for(int i = 1; i < argc; ++i) {
if(std::string(argv[i]) == "--help") {
std::cout << "Usage:" "\n"
" mansdl [arguements]" "\n"
"\n"
"Arguements(1):" "\n" /* Arguements that don't require parameter(s) */
" --help Displays a list of arguements" "\n"
"\n"
"Arguements(2):" "\n" /* Arguements that do require parameter(s) */
" -f Sets the fractal" "\n"
<< std::endl;
return -1; /* Not an error, but don't continue anyway */
}
if(std::string(argv[i]) == "-f") {
if(argc > ++i) {
if(std::string(argv[i]) == "julia") {
fractal = julia;
}
else if(std::string(argv[i]) == "mandelbrot") {
fractal = mandelbrot;
}
else {
std::cout << R"(")" << argv[i] << R"(")" " is an invalid fractal!" << std::endl;
return -2; /* An error, so don't continue */
}
}
else {
std::cout << R"(")" "-f" R"(")" " requires a parameter!" << std::endl;
return -2;
}
}
}
}
return true;
}

14
src/cleanup.cc
View file

@ -1,14 +0,0 @@
/* Include external file(s) */
#include <SDL2/SDL.h>
/* Include local file(s) */
#include "mansdl.hh"
int mansdl::cleanup() {
SDL_DestroyWindow(theWindow);
SDL_DestroyRenderer(theRenderer);
SDL_Quit();
return 0;
}

4
src/dataTypes.cc
View file

@ -1,4 +0,0 @@
/* Include external file(s) */
/* Include local file(s) */
#include "dataTypes.hh"

21
src/dataTypes.hh
View file

@ -1,21 +0,0 @@
#ifndef _DATATYPES_HH_
#define _DATATYPES_HH_
/* Include external file(s) */
/* Include local file(s) */
struct position {
public:
long double x = 0;
long double y = 0;
};
struct rgb {
public:
unsigned short int r = 0;
unsigned short int g = 0;
unsigned short int b = 0;
};
#endif /* #ifndef _DATATYPES_HH_ */

27
src/fractData.hh Normal file
View file

@ -0,0 +1,27 @@
#ifndef _FRACTDATA_HH_
#define _FRACTDATA_HH_
class fractData;
/* Include libraries */
/* Include header files */
#include "fractal.hh"
#include "mansdl.hh"
class fractData {
public:
long double real = 0.0;
long double imag = 0.0;
long double julia_real = 0.0;
long double julia_imag = 0.0;
long double zoom = 1.0;
fractal fract = mandelbrot;
unsigned int maxIter = 128;
unsigned int width = WINDOW_WIDTH;
unsigned int height = WINDOW_HEIGHT;
};
#endif /* #ifndef _FRACTDATA_HH_ */

26
src/fractal.hh
View file

@ -1,13 +1,11 @@
#ifndef _FRACTAL_HH_
#define _FRACTAL_HH_
/* Include external file(s) */
#include <SDL2/SDL.h>
/* Include libraries */
/* Include local file(s) */
#include "dataTypes.hh"
/* Include header files */
enum fractalT {
typedef enum {
burningShip = 2,
julia = 1,
mandelbrot = 0,
@ -15,20 +13,6 @@ enum fractalT {
mandelbrot4 = 6,
mandelbrot5 = 5,
tricorn = 3
};
} fractal;
namespace fractalData {
long double zoom = 1.0;
unsigned int maxIter = 128;
position pos;
namespace mandelbrot {
long double julia_real;
long double julia_imag;
}
}
#endif /* #ifndef _FRACTAL_HH_ */
#endif /* #ifndef _FRACTAL_HH_*/

51
src/genf-burningShip.cc Normal file
View file

@ -0,0 +1,51 @@
/* Include libraries */
#include <SDL2/SDL.h>
/* Include header files */
#include "fractData.hh"
#include "genf.hh"
#include "mansdl.hh"
void genf::burningShip(SDL_Renderer* renderer,fractData* fd) {
constexpr double max = 2.25;
constexpr double min = -2.25;
for(unsigned int x = 0; x < fd->width; ++x)
for(unsigned int y = 0; y < fd->height; ++y) {
long double r = x * ((max + fd->real * fd->zoom) / fd->zoom - (min + fd->real * fd->zoom) / fd->zoom) / fd->width + (min + fd->real * fd->zoom) / fd->zoom;
long double i = y * ((max + fd->imag * fd->zoom) / fd->zoom - (min + fd->imag * fd->zoom) / fd->zoom) / fd->width + (min + fd->imag * fd->zoom) / fd->zoom;
long double r2 = 0.0;
long double i2 = 0.0;
unsigned int iter;
for(iter = 0; iter < fd->maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
long double r2Temp = fabs(r2 * r2 - i2 * i2 + r);
long double i2Temp = fabs(2.0 * r2 * i2) + i;
if(r2 == r2Temp && i2 == i2Temp) {
iter = fd->maxIter;
break;
}
r2 = r2Temp;
i2 = i2Temp;
}
unsigned short int red = 0;
unsigned short int green = 0;
unsigned short int blue = 0;
if(iter != fd->maxIter) {
double t = (double)(iter) / (double)(fd->maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
}
SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(renderer, x, y);
}
}

87
src/genf-julia.cc
View file

@ -1,62 +1,51 @@
/* Include external file(s) */
/* Include libraries */
#include <SDL2/SDL.h>
/* Include local file(s) */
#include "fractal.hh"
/* Include header files */
#include "fractData.hh"
#include "genf.hh"
#include "mansdl.hh"
inline unsigned int iterate(long double r2, long double i2) {
using namespace fractalData;
using namespace fractalData::mandelbrot;
void genf::julia(SDL_Renderer* renderer, fractData* fd) {
constexpr double max = 2.25;
constexpr double min = -2.25;
unsigned int iter;
for(iter = 0; iter < maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
for(unsigned int x = 0; x < fd->width; ++x)
for(unsigned int y = 0; y < fd->height; ++y) {
long double r = fd->julia_real;
long double i = fd->julia_imag;
long double r2 = x * ((max + fd->real * fd->zoom) / fd->zoom - (min + fd->real * fd->zoom) / fd->zoom) / fd->width + (min + fd->real * fd->zoom) / fd->zoom;
long double i2 = y * ((max + fd->imag * fd->zoom) / fd->zoom - (min + fd->imag * fd->zoom) / fd->zoom) / fd->width + (min + fd->imag * fd->zoom) / fd->zoom;
long double r2Temp = r2 * r2 - i2 * i2 + julia_real;
long double i2Temp = 2.0 * r2 * i2 + julia_imag;
unsigned int iter;
for(iter = 0; iter < fd->maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
if(r2 == r2Temp && i2 == i2Temp) {
iter = maxIter;
break;
}
long double r2Temp = r2 * r2 - i2 * i2 + r;
long double i2Temp = 2.0 * r2 * i2 + i;
r2 = r2Temp;
i2 = i2Temp;
}
if(r2 == r2Temp && i2 == i2Temp) {
iter = fd->maxIter;
break;
}
return iter;
}
void genf::julia() {
using namespace fractalData;
using namespace fractalData::mandelbrot;
const double maxR = 2.25;
const double minR = -2.25;
const double maxI = 2.25;
const double minI = -2.25;
for(unsigned int x = 0; x < width; ++x)
for(unsigned int y = 0; y < height; ++y) {
long double r2 = x * ((maxR + pos.x * zoom) / zoom - (minR + pos.x * zoom) / zoom) / width + (minR + pos.x * zoom) / zoom;
long double i2 = y * ((maxI + pos.y * zoom) / zoom - (minI + pos.y * zoom) / zoom) / height + (minI + pos.y * zoom) / zoom;
unsigned int iter = iterate(r2, i2);
short unsigned int red = 0;
short unsigned int green = 0;
short unsigned int blue = 0;
if(iter != maxIter) {
float t = (float)(iter) / (float)(maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
r2 = r2Temp;
i2 = i2Temp;
}
SDL_SetRenderDrawColor(theRenderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(theRenderer, x, y);
unsigned short int red = 0;
unsigned short int green = 0;
unsigned short int blue = 0;
if(iter != fd->maxIter) {
double t = (double)(iter) / (double)(fd->maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
}
SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(renderer, x, y);
}
}

87
src/genf-mandelbrot.cc
View file

@ -1,64 +1,53 @@
/* Include external file(s) */
/* Include libraries */
#include <SDL2/SDL.h>
/* Include local file(s) */
#include "fractal.hh"
/* Include header files */
#include "fractData.hh"
#include "genf.hh"
#include "mansdl.hh"
inline unsigned int iterate(unsigned int width, unsigned int height, unsigned int x, unsigned int y) {
using namespace fractalData;
using namespace fractalData::mandelbrot;
const double maxR = 2.25;
void genf::mandelbrot(SDL_Renderer* renderer, fractData* fd) {
const double maxR = 2.25;
const double minR = -2.25;
const double maxI = 2.25;
const double maxI = 2.25;
const double minI = -2.25;
long double r = x * ((maxR + pos.x * zoom) / zoom - (minR + pos.x * zoom) / zoom) / width + (minR + pos.x * zoom) / zoom;
long double i = y * ((maxI + pos.y * zoom) / zoom - (minI + pos.y * zoom) / zoom) / height + (minI + pos.y * zoom) / zoom;
long double r2 = 0.0;
long double i2 = 0.0;
for(unsigned int x = 0; x < fd->width; ++x)
for(unsigned int y = 0; y < fd->height; ++y) {
long double r = x * ((maxR + fd->real * fd->zoom) / fd->zoom - (minR + fd->real * fd->zoom) / fd->zoom) / fd->width + (minR + fd->real * fd->zoom) / fd->zoom;
long double i = y * ((maxI + fd->imag * fd->zoom) / fd->zoom - (minI + fd->imag * fd->zoom) / fd->zoom) / fd->width + (minI + fd->imag * fd->zoom) / fd->zoom;
long double r2 = 0.0;
long double i2 = 0.0;
unsigned int iter;
for(iter = 0; iter < maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
unsigned int iter;
for(iter = 0; iter < fd->maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
long double r2Temp = r2 * r2 - i2 * i2 + r;
long double i2Temp = 2.0 * r2 * i2 + i;
long double r2Temp = r2 * r2 - i2 * i2 + r;
long double i2Temp = 2.0 * r2 * i2 + i;
if(r2 == r2Temp && i2 == i2Temp) {
iter = maxIter;
break;
}
if(r2 == r2Temp && i2 == i2Temp) {
iter = fd->maxIter;
break;
}
r2 = r2Temp;
i2 = i2Temp;
}
return iter;
}
void genf::mandelbrot() {
using namespace fractalData;
using namespace fractalData::mandelbrot;
for(unsigned int x = 0; x < width; ++x)
for(unsigned int y = 0; y < height; ++y) {
unsigned int iter = iterate(width, height, x, y);
short unsigned int red = 0;
short unsigned int green = 0;
short unsigned int blue = 0;
if(iter != maxIter) {
float t = (float)(iter) / (float)(maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
r2 = r2Temp;
i2 = i2Temp;
}
SDL_SetRenderDrawColor(theRenderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(theRenderer, x, y);
unsigned short int red = 0;
unsigned short int green = 0;
unsigned short int blue = 0;
if(iter != fd->maxIter) {
double t = (double)(iter) / (double)(fd->maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
}
SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(renderer, x, y);
}
}

51
src/genf-mandelbrot3.cc Normal file
View file

@ -0,0 +1,51 @@
/* Include libraries */
#include <SDL2/SDL.h>
/* Include header files */
#include "fractData.hh"
#include "genf.hh"
#include "mansdl.hh"
void genf::mandelbrot3(SDL_Renderer* renderer, fractData* fd) {
constexpr double max = 2.25;
constexpr double min = -2.25;
for(unsigned int x = 0; x < fd->width; ++x)
for(unsigned int y = 0; y < fd->height; ++y) {
long double r = x * ((max + fd->real * fd->zoom) / fd->zoom - (min + fd->real * fd->zoom) / fd->zoom) / fd->width + (min + fd->real * fd->zoom) / fd->zoom;
long double i = y * ((max + fd->imag * fd->zoom) / fd->zoom - (min + fd->imag * fd->zoom) / fd->zoom) / fd->width + (min + fd->imag * fd->zoom) / fd->zoom;
long double r2 = 0.0;
long double i2 = 0.0;
unsigned int iter;
for(iter = 0; iter < fd->maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
long double r2Temp = r2 * r2 * r2 - 3.0 * r2 * i2 * i2 + r;
long double i2Temp = 3.0 * r2 * r2 * i2 - i2 * i2 * i2 + i;
if(r2 == r2Temp && i2 == i2Temp) {
iter = fd->maxIter;
break;
}
r2 = r2Temp;
i2 = i2Temp;
}
unsigned short int red = 0;
unsigned short int green = 0;
unsigned short int blue = 0;
if(iter != fd->maxIter) {
double t = (double)(iter) / (double)(fd->maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
}
SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(renderer, x, y);
}
}

51
src/genf-mandelbrot4.cc Normal file
View file

@ -0,0 +1,51 @@
/* Include libraries */
#include <SDL2/SDL.h>
/* Include header files */
#include "fractData.hh"
#include "genf.hh"
#include "mansdl.hh"
void genf::mandelbrot4(SDL_Renderer* renderer, fractData* fd) {
constexpr double max = 2.25;
constexpr double min = -2.25;
for(unsigned int x = 0; x < fd->width; ++x)
for(unsigned int y = 0; y < fd->height; ++y) {
long double r = x * ((max + fd->real * fd->zoom) / fd->zoom - (min + fd->real * fd->zoom) / fd->zoom) / fd->width + (min + fd->real * fd->zoom) / fd->zoom;
long double i = y * ((max + fd->imag * fd->zoom) / fd->zoom - (min + fd->imag * fd->zoom) / fd->zoom) / fd->width + (min + fd->imag * fd->zoom) / fd->zoom;
long double r2 = 0.0;
long double i2 = 0.0;
unsigned int iter;
for(iter = 0; iter < fd->maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
long double r2Temp = (r2 * r2 + i2 * i2) * (r2 * r2 + i2 * i2) * cos(4.0 * atan2(i2, r2)) + r;
long double i2Temp = (r2 * r2 + i2 * i2) * (r2 * r2 + i2 * i2) * sin(4.0 * atan2(i2, r2)) + i;
if(r2 == r2Temp && i2 == i2Temp) {
iter = fd->maxIter;
break;
}
r2 = r2Temp;
i2 = i2Temp;
}
unsigned short int red = 0;
unsigned short int green = 0;
unsigned short int blue = 0;
if(iter != fd->maxIter) {
double t = (double)(iter) / (double)(fd->maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
}
SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(renderer, x, y);
}
}

51
src/genf-mandelbrot5.cc Normal file
View file

@ -0,0 +1,51 @@
/* Include libraries */
#include <SDL2/SDL.h>
/* Include header files */
#include "fractData.hh"
#include "genf.hh"
#include "mansdl.hh"
void genf::mandelbrot5(SDL_Renderer* renderer, fractData* fd) {
constexpr double max = 2.25;
constexpr double min = -2.25;
for(unsigned int x = 0; x < fd->width; ++x)
for(unsigned int y = 0; y < fd->height; ++y) {
long double r = x * ((max + fd->real * fd->zoom) / fd->zoom - (min + fd->real * fd->zoom) / fd->zoom) / fd->width + (min + fd->real * fd->zoom) / fd->zoom;
long double i = y * ((max + fd->imag * fd->zoom) / fd->zoom - (min + fd->imag * fd->zoom) / fd->zoom) / fd->width + (min + fd->imag * fd->zoom) / fd->zoom;
long double r2 = 0.0;
long double i2 = 0.0;
unsigned int iter;
for(iter = 0; iter < fd->maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
long double r2Temp = r2 * r2 * r2 * r2 * r2 - 10.0 * r2 * r2 * r2 * i2 * i2 + 5.0 * r2 * i2 * i2 * i2 * i2 + r;
long double i2Temp = 5.0 * r2 * r2 * r2 * r2 * i2 - 10.0 * r2 * r2 * i2 * i2 * i2 + i2 * i2 * i2 * i2 * i2 + i;
if(r2 == r2Temp && i2 == i2Temp) {
iter = fd->maxIter;
break;
}
r2 = r2Temp;
i2 = i2Temp;
}
unsigned short int red = 0;
unsigned short int green = 0;
unsigned short int blue = 0;
if(iter != fd->maxIter) {
double t = (double)(iter) / (double)(fd->maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
}
SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(renderer, x, y);
}
}

51
src/genf-tricorn.cc Normal file
View file

@ -0,0 +1,51 @@
/* Include libraries */
#include <SDL2/SDL.h>
/* Include header files */
#include "fractData.hh"
#include "genf.hh"
#include "mansdl.hh"
void genf::tricorn(SDL_Renderer* renderer, fractData* fd) {
constexpr double max = 2.25;
constexpr double min = -2.25;
for(unsigned int x = 0; x < fd->width; ++x)
for(unsigned int y = 0; y < fd->height; ++y) {
long double r = x * ((max + fd->real * fd->zoom) / fd->zoom - (min + fd->real * fd->zoom) / fd->zoom) / fd->width + (min + fd->real * fd->zoom) / fd->zoom;
long double i = y * ((max + fd->imag * fd->zoom) / fd->zoom - (min + fd->imag * fd->zoom) / fd->zoom) / fd->width + (min + fd->imag * fd->zoom) / fd->zoom;
long double r2 = 0.0;
long double i2 = 0.0;
unsigned int iter;
for(iter = 0; iter < fd->maxIter; ++iter) {
if(r2 * r2 + i2 * i2 >= 4.0)
break;
long double r2Temp = r2 * r2 - i2 * i2 + r;
long double i2Temp = -2.0 * r2 * i2 + i;
if(r2 == r2Temp && i2 == i2Temp) {
iter = fd->maxIter;
break;
}
r2 = r2Temp;
i2 = i2Temp;
}
unsigned short int red = 0;
unsigned short int green = 0;
unsigned short int blue = 0;
if(iter != fd->maxIter) {
double t = (double)(iter) / (double)(fd->maxIter);
red = (int)(9.0 * (1.0 - t) * t * t * t * 255.0);
green = (int)(15.0 * (1.0 - t) * (1.0 - t) * t * t * 255.0);
blue = (int)(8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t * 255.0);
}
SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);
SDL_RenderDrawPoint(renderer, x, y);
}
}

28
src/genf.cc
View file

@ -1,28 +0,0 @@
/* Include external file(s) */
#include <SDL2/SDL.h>
/* Include local file(s) */
#include "fractal.hh"
#include "genf.hh"
genf::genf(SDL_Renderer* r, unsigned int w, unsigned int h, fractalT f) {
theRenderer = r;
width = w;
height = h;
fractal = f;
}
void genf::start() {
SDL_SetRenderDrawColor(theRenderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
SDL_RenderClear(theRenderer);
switch(fractal) {
case fractalT::julia:
genf::julia();
break;
default:
genf::mandelbrot();
break;
}
}

35
src/genf.hh
View file

@ -1,32 +1,23 @@
#ifndef _GENF_HH_
#define _GENF_HH_
/* Include external file(s) */
#include <SDL2/SDL.h>
class genf;
/* Include local file(s) */
#include "fractal.hh"
/* Include libraries */
/* Include header files */
#include "fractData.hh"
#include "mansdl.hh"
class genf {
private:
SDL_Renderer* theRenderer = NULL;
unsigned int width;
unsigned int height;
fractalT fractal;
public:
genf(SDL_Renderer* renderer, const unsigned int w, const unsigned int h, fractalT f);
void start();
void burningShip();
void julia();
void mandelbrot();
void mandelbrot3();
void mandelbrot4();
void mandelbrot5();
void tricorn();
void burningShip(SDL_Renderer* renderer, fractData* fractData);
void julia(SDL_Renderer* renderer, fractData* fractData);
void mandelbrot(SDL_Renderer* renderer, fractData* fractData);
void mandelbrot3(SDL_Renderer* renderer, fractData* fractData);
void mandelbrot4(SDL_Renderer* renderer, fractData* fractData);
void mandelbrot5(SDL_Renderer* renderer, fractData* fractData);
void tricorn(SDL_Renderer* renderer, fractData* fractData);
};
#endif /* #ifndef _GENF_HH_ */

18
src/init_success.cc
View file

@ -1,18 +0,0 @@
/* Include external file(s) */
#include <SDL2/SDL.h>
/* Include local file(s) */
#include "mansdl.hh"
bool mansdl::init_success() {
if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
return false;
if((theWindow = SDL_CreateWindow("MandelbrotSDL", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, windowWidth, windowHeight, SDL_WINDOW_RESIZABLE)) == NULL)
return false;
if((theRenderer = SDL_CreateRenderer(theWindow, -1, SDL_RENDERER_ACCELERATED)) == NULL)
return false;
return true; /* Initialized successfully */
}

54
src/main.cc
View file

@ -1,49 +1,47 @@
/* Include external file(s) */
#include <chrono>
#include <iomanip>
/* Include libraries */
#include <iostream>
#include <SDL2/SDL.h>
/* Include local file(s) */
#include "genf.hh"
/* Include header files */
#include "fractData.hh"
#include "mansdl.hh"
int mansdl::main(const int argc, const char** argv) {
if(!applyArgs(argc, argv))
return cleanup();
fractData fd;
if(!init_success())
if(!mansdl::applyArgs(&fd, argc, argv))
return 0;
if(!mansdl::init())
return -1;
if(fd.fract == mandelbrot4)
std::cout << "\033[035m" << "WARNING!" << "\033[000m" << " The current fractal generator is REALLY unoptimized." << std::endl;
while(!quit) {
for(SDL_Event event; SDL_PollEvent(&event); )
onInput(&event);
mansdl::checkEvent(&fd, &event);
if(doGenf) {
doGenf = false;
auto timer_start = std::chrono::high_resolution_clock::now();
genf genf(theRenderer, windowWidth, windowHeight, fractal);
genf.start();
auto timer_stop = std::chrono::high_resolution_clock::now();
SDL_RenderPresent(theRenderer);
std::chrono::duration<double> seconds = timer_stop - timer_start;
std::cout << "\r" "Took " "\033[033m" << std::setprecision(3) << std::fixed << seconds.count() << "\033[000m" " seconds." << std::flush;
if(doGenerate) {
mansdl::genF(&fd); /* If fractal is not generated, generate it */
SDL_RenderPresent(renderer);
}
SDL_Delay(10);
SDL_Delay(5);
}
std::cout << "\n" "Goodbye!" << std::endl;
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
return cleanup();
SDL_Quit();
std::cout << "\n" << "Goodbye!" << std::endl;
return 0;
}
int main(const int argc, const char** argv) {
mansdl a;
return a.main(argc, argv);
mansdl mansdl;
return mansdl.main(argc, argv);
}

76
src/mansdl-applyArgs.cc Normal file
View file

@ -0,0 +1,76 @@
/* Include libraries */
#include <iostream>
#include <string>
/* Include header files */
#include "mansdl.hh"
bool mansdl::applyArgs(fractData* fd, const int argc, const char** argv) {
if(argc > 1)
for(int i = 1; i < argc; ++i) {
std::string arg = argv[i];
if(arg == "--help") {
std::cout << "Usage:" << "\n" <<
" mansdl [arguements]" << "\n" <<
"\n" <<
"Arguements(1):" << "\n" << /* Arguements that don't require extra arguements */
" --help Displays this message" << "\n" <<
"\n" <<
"Arguements(2):" << "\n" << /* Arguements that require extra arguements */
" -f Sets the fractal" << "\n" <<
" -w Sets the width of the calculated image" << "\n" <<
" -h Sets the height of the calculated image" << "\n" <<
std::endl;
return false;
}
else if(argc > i + 1) {
if(arg == "-f") {
++i;
arg = argv[i];
if(arg == "burningShip")
fd->fract = burningShip;
else if(arg == "julia")
fd->fract = julia;
else if(arg == "mandelbrot")
fd->fract = mandelbrot;
else if(arg == "mandelbrot3")
fd->fract = mandelbrot3;
else if(arg == "mandelbrot4")
fd->fract = mandelbrot4;
else if(arg == "mandelbrot5")
fd->fract = mandelbrot5;
else if(arg == "tricorn")
fd->fract = tricorn;
else
std::cout << "\033[035m" << "WARNING!" << "\033[000m" << " Invalid fractal! Continuing with the Mandelbrot Set." << std::endl;
}
else if(arg == "-w") {
++i;
arg = argv[i];
if(std::stoul(arg) <= fd->width)
fd->width = std::stoul(arg);
} else if(arg == "-h") {
++i;
arg = argv[i];
if(std::stoul(arg) <= fd->height)
fd->height = std::stoul(arg);
}
}
}
return true;
}

103
src/mansdl-checkEvent.cc Normal file
View file

@ -0,0 +1,103 @@
/* Include libraries */
#include <SDL2/SDL.h>
/* Include header files */
#include "fractData.hh"
#include "mansdl.hh"
void mansdl::checkEvent(fractData* fd, SDL_Event* event) {
const Uint8* keyState = SDL_GetKeyboardState(NULL);
bool ctrl = keyState[SDL_SCANCODE_LCTRL] || keyState[SDL_SCANCODE_RCTRL];
switch(event->type) {
case SDL_QUIT:
quit = true;
break;
case SDL_MOUSEWHEEL:
if(event->wheel.y > 0) {
switch(ctrl) {
case true: {
unsigned int result = fd->maxIter * 2;
if(result > 2) {
fd->maxIter = result;
doGenerate = true;
}
break;
}
case false:
fd->zoom = fd->zoom * 1.25;
doGenerate = true;
break;
}
} else if(event->wheel.y < 0) {
switch(ctrl) {
case true: {
unsigned int result = fd->maxIter / 2;
if(result >= 2) {
fd->maxIter = result;
doGenerate = true;
}
break;
}
case false:
fd->zoom = fd->zoom / 1.25;
doGenerate = true;
break;
}
}
break;
case SDL_KEYDOWN:
switch(ctrl) {
case true:
if(keyState[SDL_SCANCODE_X])
quit = true;
if(fd->fract == julia) {
if(keyState[SDL_SCANCODE_W]) {
fd->julia_imag = fd->julia_imag - 0.005;
doGenerate = true;
} if(keyState[SDL_SCANCODE_S]) {
fd->julia_imag = fd->julia_imag + 0.005;
doGenerate = true;
} if(keyState[SDL_SCANCODE_A]) {
fd->julia_real = fd->julia_real - 0.005;
doGenerate = true;
} if(keyState[SDL_SCANCODE_D]) {
fd->julia_real = fd->julia_real + 0.005;
doGenerate = true;
}
}
break;
case false:
if(keyState[SDL_SCANCODE_A]) {
fd->real = fd->real - 0.1 / fd->zoom;
doGenerate = true;
} if(keyState[SDL_SCANCODE_D]) {
fd->real = fd->real + 0.1 / fd->zoom;
doGenerate = true;
} if(keyState[SDL_SCANCODE_W]) {
fd->imag = fd->imag - 0.1 / fd->zoom;
doGenerate = true;
} if(keyState[SDL_SCANCODE_S]) {
fd->imag = fd->imag + 0.1 / fd->zoom;
doGenerate = true;
}
break;
}
break;
}
}

57
src/mansdl-genf.cc Normal file
View file

@ -0,0 +1,57 @@
/* Include libraries */
#include <chrono>
#include <iomanip>
#include <iostream>
/* Include header files */
#include "mansdl.hh"
/* To-do list: */
/* Banish Windows from this world */
/* Optimize the Mandelbrot^4 renderer */
void mansdl::genF(fractData* fd) {
doGenerate = false;
auto timer_start = std::chrono::high_resolution_clock::now();
genf genf;
switch(fd->fract) {
case burningShip:
genf.burningShip(renderer, fd);
break;
case julia:
genf.julia(renderer, fd);
break;
case mandelbrot3:
genf.mandelbrot3(renderer, fd);
break;
case mandelbrot4:
genf.mandelbrot4(renderer, fd);
break;
case mandelbrot5:
genf.mandelbrot5(renderer, fd);
break;
case tricorn:
genf.tricorn(renderer, fd);
break;
default:
genf.mandelbrot(renderer, fd);
break;
}
auto timer_stop = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> duration = timer_stop - timer_start;
if(duration > std::chrono::seconds(5))
std::cout << "\a";
std::cout << "\r" << "\033[033m" << "Done!" << "\033[000m" << " (Took " << std::setprecision(3) << std::fixed << duration.count() << " seconds)" << std::flush;
}

22
src/mansdl-init.cc Normal file
View file

@ -0,0 +1,22 @@
/* Include libraries */
#include <SDL2/SDL.h>
/* Include header files */
#include "mansdl.hh"
bool mansdl::init(void) {
if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
return false;
if((window = SDL_CreateWindow("MandelbrotSDL", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, 0)) == NULL)
return false;
if((renderer = SDL_CreateRenderer(window, -1, 0)) == NULL)
return false;
SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
SDL_RenderClear(renderer);
SDL_RenderPresent(renderer);
return true; /* Initialized successfully */
}

48
src/mansdl.hh
View file

@ -1,34 +1,38 @@
#ifndef _MANSDL_HH_
#define _MANSDL_HH_
/* Include external file(s) */
#define WINDOW_WIDTH 512
#define WINDOW_HEIGHT 512
class mansdl;
/* Include libraries */
#include <SDL2/SDL.h>
/* Include local file(s) */
#include "dataTypes.hh"
/* Include header files */
#include "fractal.hh"
#include "fractData.hh"
#include "genf.hh"
class mansdl {
private:
bool doGenf = true;
fractalT fractal = mandelbrot;
unsigned int windowWidth = 512;
unsigned int windowHeight = 512;
SDL_Window* theWindow = NULL;
SDL_Renderer* theRenderer = NULL;
bool quit = false;
private:
bool applyArgs(const int argc, const char** argv);
int cleanup();
bool init_success();
void onInput(SDL_Event* event);
public:
int main(const int argc, const char** argv);
int main(const int argc, const char** argv);
/* Variables needed by all members */
private:
bool doGenerate = true;
bool quit = false;
SDL_Window* window = NULL;
SDL_Renderer* renderer = NULL;
/* Functions */
bool applyArgs(fractData* fd, const int argc, const char** argv);
bool init(void);
void checkEvent(fractData* fd, SDL_Event* event);
void genF(fractData* fd);
};
#endif /* #ifndef _MANSDL_HH_ */

84
src/onInput.cc
View file

@ -1,84 +0,0 @@
/* Include external file(s) */
#include <SDL2/SDL.h>
/* Include local file(s) */
#include "fractal.hh"
#include "mansdl.hh"
void mansdl::onInput(SDL_Event* event) {
using namespace fractalData;
const Uint8* key = SDL_GetKeyboardState(NULL);
bool ctrl = key[SDL_SCANCODE_LCTRL] || key[SDL_SCANCODE_RCTRL];
switch(event->type) {
case SDL_QUIT:
quit = true;
break;
case SDL_MOUSEWHEEL:
if(ctrl) {
if(event->wheel.y > 0) {
maxIter *= 2;
doGenf = true;
}
else if(event->wheel.y < 0) {
if(maxIter >= 4) {
maxIter /= 2;
doGenf = true;
}
}
}
else {
if(event->wheel.y > 0) {
zoom = zoom * 1.25;
doGenf = true;
}
else if(event->wheel.y < 0) {
zoom = zoom / 1.25;
doGenf = true;
}
}
break;
case SDL_KEYDOWN:
if(ctrl) {
if(fractal == julia) {
if(key[SDL_SCANCODE_W]) {
mandelbrot::julia_imag -= 0.001;
doGenf = true;
}
if(key[SDL_SCANCODE_S]) {
mandelbrot::julia_imag += 0.001;
doGenf = true;
}
if(key[SDL_SCANCODE_A]) {
mandelbrot::julia_real -= 0.001;
doGenf = true;
}
if(key[SDL_SCANCODE_D]) {
mandelbrot::julia_real += 0.001;
doGenf = true;
}
}
} else {
if(key[SDL_SCANCODE_W]) {
pos.y -= (0.1 / zoom);
doGenf = true;
}
if(key[SDL_SCANCODE_S]) {
pos.y += 0.1 / zoom;
doGenf = true;
}
if(key[SDL_SCANCODE_A]) {
pos.x -= 0.1 / zoom;
doGenf = true;
}
if(key[SDL_SCANCODE_D]) {
pos.x += 0.1 / zoom;
doGenf = true;
}
}
break;
}
}