int
main(int argc, char **argv)
{
struct state state;
if (initialize_state(&state)) {
printf("ERROR in initialization\n");
return 1;
}
if (parse_args(argc, argv, &state)) {
printf("ERROR parsing arguments\n");
return 1; // TODO: cleanup_state()
}
if (bmp_load(state.inf, state.inname, &state)) {
printf("ERROR loading BMP!\n");
return 1; // TODO: cleanup_state()
}
if (font_save(state.outf, state.outname, &state)) {
printf("ERROR saving font!\n");
return 1; // TODO: cleanup_state()
}
cleanup_state(&state);
return 0;
}
//generic constructing function for Control.
Control * ControlCreate(char * filename, SDL_Rect * rect)
{
Control * ctl = mymalloc (sizeof (Control));
//handle memory failure.
//TODO make global function/macro.
if (!ctl)
{
return NULL;
};
ctl->surface = NULL;
ctl->rect = rect;
ctl->children = NULL;
ctl->parent = NULL;
ctl->extra_data = NULL;
//by default a control does nothing.
ctl->HandleEvents = NULL;
//load the image (if exists) into ctl's surface
if (filename)
{
bmp_load(filename, &(ctl->surface));
}
return ctl;
}
int main2 ()
{
/* Initialize SDL and make sure it quits*/
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("ERROR: unable to init SDL: %s\n", SDL_GetError());
return 1;
}
atexit(SDL_Quit);
//initialize screen/window
SDL_Surface * screen;
/*
* Initialize the display in a 640x480 8-bit palettized mode,
* requesting a software surface
*/
screen = SDL_SetVideoMode(WIN_W, WIN_H, 0, SDL_SWSURFACE | SDL_DOUBLEBUF);
if ( screen == NULL )
{
fprintf(stderr, "Couldn't set video mode: %s\n",
SDL_GetError());
exit(1);
}
//load background image
bmp_load("imgs/background.bmp", &screen);
//display ?
//is done seperately
//poll events
int quit = 0 ;
while (!quit)
{
/* Poll for keyboard & mouse events*/
SDL_Event e;
while (SDL_PollEvent(&e) != 0) {
switch (e.type) {
case (SDL_QUIT):
quit = 1;
break;
case (SDL_KEYUP):
if (e.key.keysym.sym == SDLK_ESCAPE)
{
quit = 1;
}
break;
case (SDL_MOUSEBUTTONUP):
//if ((e.button.x > rect.x) && (e.button.x < rect.x + rect.w) && (e.button.y > rect.y) && (e.button.y < rect.y+rect.h))
quit = 1;
break;
default:
break;
}
}
/* Wait a little before redrawing*/
SDL_Delay(200);
}
return 0;
}
static int bmp_show(char* file)
{
void* bmp = bmp_load(file, 1);
if (!bmp) return 0;
bmp_draw_scaled_ex(bmp, 0, 0, 720, 480, 0);
free(bmp);
return 1;
}
void menu_help_show_page(int page)
{
menu_help_active = 1;
#ifndef CONFIG_RELEASE_BUILD
if (page == 1) { draw_beta_warning(); return; } // display this instead of the main About page
#endif
if (page == 0) { draw_404_page(); return; } // help page not found
if (page == -1) { draw_help_not_installed_page(); return; } // help page not found
char path[100];
struct bmp_file_t * doc = (void*) -1;
#ifdef CONFIG_HELP_CACHE
char rpath[30];
snprintf(rpath, sizeof(rpath), CARD_DRIVE "ML/doc/page-%03d.vrm", page);
if (load_vram(rpath)==-1)
#endif
{
snprintf(path, sizeof(path), CARD_DRIVE "ML/doc/page-%03d.bmh", page);
doc = bmp_load(path, 1);
if (!doc)
{
snprintf(path, sizeof(path), CARD_DRIVE "ML/doc/page-%03d.bmp", page);
doc = bmp_load(path, 1);
}
if (doc)
{
bmp_draw_scaled_ex(doc, 0, 0, 720, 480, 0);
#ifdef CONFIG_HELP_CACHE
extern int _bmp_draw_should_stop;
if (!_bmp_draw_should_stop) save_vram(rpath);
#endif
FreeMemory(doc);
}
else
{
clrscr();
bmp_printf(FONT_MED, 0, 0, "Could not load help page %s.", path);
}
}
}
SINT HPBmpDisp(SINT CoType,LONG x1,LONG y1,CHAR *file)
{
SINT x,bmp;
LONG y;
LONG pos;
SINT HdlLocal;
CHAR *BufLocal;
CHAR *BufCompress;
CHAR serv[80];
struct BMP_HD BmpHead;
struct BMPINFO BmpInfo;
if (CoType==HP_GRID) {x1*=Grid_X; y1*=Grid_Y;}
bmp=bmp_load(file,&BmpInfo,RAM_AUTO);
if (bmp<0) return bmp;
memo_leggivar(bmp,0,&BmpHead,sizeof(BmpHead));
pos=sizeof(BmpHead);
HdlLocal=memo_chiedi(RAM_HEAP,BmpHead.riga+(BmpHead.riga*2),"HPlocal");
if (HdlLocal<0) goto FINE;
BufLocal=memo_heap(HdlLocal);
BufCompress=BufLocal+BmpHead.riga;
HPCursor(HP_DOT,x1,y1);
sprintf(serv,"*r%lds0t1A",BmpHead.larg); // Raster area
HPEsc(serv);
for (y=0;y<BmpHead.alt;y++)
{
// int pixel,mask,pt;
memo_leggivar(bmp,pos,BufLocal,BmpHead.riga);
x=HPcompress(BufLocal,BufCompress,BmpHead.riga);
if (x<=0)
{sprintf(serv,"*b0m%dW",(SINT) -x); HPEsc(serv);
lpt_send(BufLocal,-x);
}
else
{sprintf(serv,"*b1m%dW",(SINT ) x); HPEsc(serv);
lpt_send(BufCompress,x);
}
pos+=BmpHead.riga;
}
memo_libera(HdlLocal,"HP");
HPEsc("*rb"); // end raster
// uscita
FINE:
memo_libera(bmp,"disp_lpt");
return 0;
}
int doTest(const char *ext, int width, int align, int height, enum BMPPF pf,
enum BMPORN orientation)
{
char filename[80], *md5sum, md5buf[65];
int pitch=BMPPAD(width*bmp_ps[pf], align), loadWidth=0, loadHeight=0,
retval=0;
unsigned char *buf=NULL;
char *md5ref=!stricmp(ext, "ppm")? "c0c9f772b464d1896326883a5c79c545":
"b03eec1eaaad38fed9cab5082bf37e52";
if((buf=(unsigned char *)malloc(pitch*height))==NULL)
_throw("Could not allocate memory");
initBuf(buf, width, pitch, height, pf, orientation);
snprintf(filename, 80, "bmptest_%s_%d_%s.%s", pfStr[pf], align,
orientation==BMPORN_TOPDOWN? "td":"bu", ext);
if(bmp_save(filename, buf, width, pitch, height, pf, orientation)==-1)
_throw(bmp_geterr());
md5sum=MD5File(filename, md5buf);
if(stricmp(md5sum, md5ref))
_throwmd5(filename, md5sum, md5ref);
free(buf); buf=NULL;
if(bmp_load(filename, &buf, &loadWidth, align, &loadHeight, pf,
orientation)==-1)
_throw(bmp_geterr());
if(width!=loadWidth || height!=loadHeight)
{
printf("\n Image dimensions of %s are bogus\n", filename);
retval=-1; goto bailout;
}
if(!cmpBuf(buf, width, pitch, height, pf, orientation))
{
printf("\n Pixel data in %s is bogus\n", filename);
retval=-1; goto bailout;
}
unlink(filename);
bailout:
if(buf) free(buf);
return retval;
}
int main()
{
srand(time(0));
s_settings settings;
settings.mode = MODE_AUTO;
settings.w = 960;
settings.h = 480;
settings.tiled_view = true;
settings.paused = false;
if(glfwInit() == GL_FALSE)
{
std::cerr << "Failed to init GLFW" << std::endl;
return 1;
}
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
GLFWwindow *window;
if((window = glfwCreateWindow(settings.w, settings.h, "Painting Evolution", 0, 0)) == 0)
{
std::cerr << "Failed to open window" << std::endl;
glfwTerminate();
return 1;
}
glfwSetWindowUserPointer(window, &settings);
glfwMakeContextCurrent(window);
glfwSetWindowSizeCallback(window, glfw_window_size_callback);
glfwSetCursorPosCallback(window, glfw_cursor_position_callback);
glfwSetScrollCallback(window, glfw_mouse_scroll_callback);
glfwSetKeyCallback(window, glfw_keyboard_callback);
glfwSetMouseButtonCallback(window, glfw_mouse_button_callback);
// start GLEW extension handler
glewExperimental = GL_TRUE;
GLenum err = glewInit();
while((err = glGetError()) != GL_NO_ERROR)
{
std::cout << "glewInit error: " << err << std::endl;
std::cout << std::endl;
}
#ifndef NDEBUG
const GLubyte* renderer = glGetString(GL_RENDERER);
const GLubyte* version = glGetString(GL_VERSION);
std::cout << "Debug info:" << std::endl;
std::cout << " Date: " << __DATE__ << std::endl;
std::cout << " Time: " << __TIME__ << std::endl;
std::cout << " Renderer: " << renderer << std::endl;
std::cout << " OpenGL version supported: " << version << std::endl;
std::cout << " Max textures: " << GL_MAX_TEXTURE_UNITS << std::endl;
std::cout << std::endl;
#endif
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
bool r;
GLuint vertex_shader, fragment_shader, compute_shader;
r = vertex_shader_load(&vertex_shader, "shaders\\vertex_shader.glsl");
if(r == false)
{
glfwDestroyWindow(window);
glfwTerminate();
}
r = fragment_shader_load(&fragment_shader, "shaders\\fragment_shader.glsl");
if(r == false)
{
glfwDestroyWindow(window);
glfwTerminate();
}
r = compute_shader_load(&compute_shader, "shaders\\compute_shader.glsl");
if(r == false)
{
glfwDestroyWindow(window);
glfwTerminate();
}
GLuint shader_program, similarity_program;
// create program
shader_program = glCreateProgram();
glAttachShader(shader_program, vertex_shader);
glAttachShader(shader_program, fragment_shader);
glLinkProgram(shader_program);
check_program_link_status(shader_program);
// create program
similarity_program = glCreateProgram();
glAttachShader(similarity_program, compute_shader);
glLinkProgram(similarity_program);
check_program_link_status(similarity_program);
/**** side by side view ****/
GLuint vao, vbo, cbo, uvbo;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// Vertices
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (char*)0 + 0*sizeof(GLfloat));
// Colours
glGenBuffers(1, &cbo);
glBindBuffer(GL_ARRAY_BUFFER, cbo);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (char*)0 + 0*sizeof(GLfloat));
// uvs
glGenBuffers(1, &uvbo);
glBindBuffer(GL_ARRAY_BUFFER, uvbo);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, (char*)0 + 0*sizeof(GLfloat));
/**** side by side view ****/
s_sim sim;
bmp_load(&sim.target, "input.bmp");
sim.grid_pos = 0;
sim.grid_w = 8;
sim.grid_h = 8;
sim.tile_w = sim.target.w/sim.grid_w;
sim.tile_h = sim.target.h/sim.grid_h;
settings.sim = ∼
assert(sim.target.w%16 == 0);
assert(sim.target.h%16 == 0);
assert(sim.tile_w%16 == 0);
assert(sim.tile_h%16 == 0);
s_painting temp;
for(int p = 0; p < 36; ++p)
{
sim.paintings.push_back(temp);
painting_init(&sim.paintings[p], sim.tile_w, sim.tile_h);
}
for(int p = 0; p < sim.grid_w*sim.grid_h; ++p)
{
sim.grid_paintings.push_back(temp);
painting_init(&sim.grid_paintings[p], sim.tile_w, sim.tile_h);
}
int num_workgroups = sim.tile_w*sim.tile_h/16/16;
std::vector<GLfloat> scores(num_workgroups);
// generate vao_compute and scores_bo
GLuint vao_compute, scores_bo;
glGenVertexArrays(1, &vao_compute);
glBindVertexArray(vao_compute);
glGenBuffers(1, &scores_bo);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, scores_bo);
glBufferData(GL_SHADER_STORAGE_BUFFER, num_workgroups*sizeof(scores[0]), &scores[0], GL_DYNAMIC_DRAW); // GL_STATIC_DRAW
glGenTextures(1, &sim.target_id);
glBindTexture(GL_TEXTURE_2D, sim.target_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // GL_LINEAR
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // GL_LINEAR
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, sim.target.w, sim.target.h, 0, GL_RGB, GL_UNSIGNED_BYTE, sim.target.data);
glGenTextures(1, &sim.result_id);
glBindTexture(GL_TEXTURE_2D, sim.result_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // GL_LINEAR
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // GL_LINEAR
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, sim.target.w, sim.target.h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
std::vector<GLubyte> emptyData(3 * sim.target.w * sim.target.h, 0);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, sim.target.w, sim.target.h, GL_RGB, GL_UNSIGNED_BYTE, &emptyData[0]);
GLuint highres_texture_id = 0;
glGenTextures(1, &highres_texture_id);
glBindTexture(GL_TEXTURE_2D, highres_texture_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // GL_LINEAR
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // GL_LINEAR
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, sim.tile_w, sim.tile_h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
// create a framebuffer object
GLuint highres_fbo = 0;
glGenFramebuffers(1, &highres_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, highres_fbo);
// attach the texture to FBO color attachment point
glFramebufferTexture2D(GL_FRAMEBUFFER, // 1. fbo target: GL_FRAMEBUFFER
GL_COLOR_ATTACHMENT0, // 2. attachment point
GL_TEXTURE_2D, // 3. tex target: GL_TEXTURE_2D
highres_texture_id, // 4. tex ID
0); // 5. mipmap level: 0(base)
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindTexture(GL_TEXTURE_2D, 0);
// check FBO status
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(status != GL_FRAMEBUFFER_COMPLETE)
{
std::cout << "Framebuffer error:" << status<< std::endl;
return -1;
}
GLuint texture_slice = 0;
glGenTextures(1, &texture_slice);
glActiveTexture(GL_TEXTURE0 + texture_slice);
glBindTexture(GL_TEXTURE_2D, texture_slice);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // GL_LINEAR
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // GL_LINEAR
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, sim.tile_w, sim.tile_h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glPointSize(2.0);
GLuint query;
glGenQueries(1, &query);
GLubyte *data = new GLubyte[3*sim.tile_w*sim.tile_h];
unsigned int parent1_id = 0;
unsigned int parent2_id = 0;
float parent1_score = FLT_MIN;
float parent2_score = FLT_MIN;
int x_offset = 0;
int y_offset = 0;
int tile_x = 0;
int tile_y = 0;
int last_grid_pos = -1;
int auto_generation = 0;
float start_score = 0.0;
while(!glfwWindowShouldClose(window))
{
glBeginQuery(GL_TIME_ELAPSED, query);
if(settings.paused == false)
{
// Auto mode will spend a set number of generations per grid position and then move to the new lowest scoring
if(settings.mode == MODE_AUTO && auto_generation >= AUTO_GENERATIONS)
{
// Set score rate
sim.grid_paintings[sim.grid_pos].score_rate = (sim.grid_paintings[sim.grid_pos].score - start_score)/AUTO_GENERATIONS;
assert(sim.grid_paintings[sim.grid_pos].score_rate >= 0.0);
assert(sim.grid_paintings[sim.grid_pos].score_rate <= 1.0/AUTO_GENERATIONS);
float fastest = FLT_MIN;
for(unsigned int p = 0; p < sim.grid_paintings.size(); ++p)
{
if(sim.grid_paintings[p].score_rate > fastest)
{
sim.grid_pos = p;
fastest = sim.grid_paintings[p].score_rate;
}
}
start_score = sim.grid_paintings[sim.grid_pos].score;
auto_generation = 0;
}
// Next tile
if(last_grid_pos != sim.grid_pos)
{
if(last_grid_pos != -1)
{
// Update results texture - do all grid paintings because new ones might've been loaded in
for(unsigned int p = 0; p < sim.grid_paintings.size(); ++p)
{
if(sim.grid_paintings[p].generation == 0) {continue;}
tile_x = p%sim.grid_w;
tile_y = p/sim.grid_w;
x_offset = tile_x * sim.tile_w;
y_offset = tile_y * sim.tile_h;
// Save current best paiting to the results
glViewport(0, 0, sim.tile_w, sim.tile_h);
// Redraw
glBindFramebuffer(GL_FRAMEBUFFER, highres_fbo);
glClearColor(sim.grid_paintings[p].r, sim.grid_paintings[p].g, sim.grid_paintings[p].b, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind the current vao
glBindVertexArray(vao);
// Vertices
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 2 * 3 * sim.grid_paintings[p].num_triangles * sizeof(GLfloat), &sim.grid_paintings[p].positions[0], GL_STATIC_DRAW);
// Colours
glBindBuffer(GL_ARRAY_BUFFER, cbo);
glBufferData(GL_ARRAY_BUFFER, 3 * 3 * sim.grid_paintings[p].num_triangles * sizeof(GLfloat), &sim.grid_paintings[p].colours[0], GL_STATIC_DRAW);
// Texture coords
glBindBuffer(GL_ARRAY_BUFFER, uvbo);
glBufferData(GL_ARRAY_BUFFER, 2 * 3 * sim.grid_paintings[p].num_triangles * sizeof(GLfloat), &sim.grid_paintings[p].uvs[0], GL_STATIC_DRAW);
glUseProgram(shader_program);
// Set the uniforms
glm::mat4 view = glm::ortho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
glUniformMatrix4fv(0, 1, GL_FALSE, glm::value_ptr(view));
// Draw
glDrawArrays(GL_TRIANGLES, 0, 3*sim.grid_paintings[p].num_triangles);
// Get tile data
glBindTexture(GL_TEXTURE_2D, highres_texture_id);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
// Write tile to result texture
glBindTexture(GL_TEXTURE_2D, sim.result_id);
glTexSubImage2D(GL_TEXTURE_2D, 0, x_offset, y_offset, sim.tile_w, sim.tile_h, GL_RGB, GL_UNSIGNED_BYTE, data);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, settings.w, settings.h);
}
// If we've never been at this grid position before, we should start with some random paintings
// If we have been here before, just copy the painting in storage
if(sim.grid_paintings[sim.grid_pos].generation == 0)
{
for(unsigned int p = 0; p < sim.paintings.size(); ++p)
{
painting_randomise(&sim.paintings[p]);
}
}
else
{
for(unsigned int p = 0; p < sim.paintings.size(); ++p)
{
painting_copy(&sim.paintings[p], &sim.grid_paintings[sim.grid_pos]);
}
}
tile_x = sim.grid_pos%sim.grid_w;
tile_y = sim.grid_pos/sim.grid_w;
x_offset = tile_x * sim.tile_w;
y_offset = tile_y * sim.tile_h;
for(int y = 0; y < sim.tile_h; ++y)
{
for(int x = 0; x < sim.tile_w; ++x)
{
data[3*y*sim.tile_w + 3*x + 0] = sim.target.data[3*(y + y_offset) *sim.target.w + 3*(x + x_offset) + 0];
data[3*y*sim.tile_w + 3*x + 1] = sim.target.data[3*(y + y_offset) *sim.target.w + 3*(x + x_offset) + 1];
data[3*y*sim.tile_w + 3*x + 2] = sim.target.data[3*(y + y_offset) *sim.target.w + 3*(x + x_offset) + 2];
}
}
glBindTexture(GL_TEXTURE_2D, texture_slice);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, sim.tile_w, sim.tile_h, GL_RGB, GL_UNSIGNED_BYTE, data);
std::cout << std::endl;
std::cout << "Pos: " << tile_x << " " << tile_y << std::endl;
std::cout << "Score: " << sim.grid_paintings[sim.grid_pos].score << std::endl;
std::cout << "Rate: " << sim.grid_paintings[sim.grid_pos].score_rate << std::endl;
std::cout << "Gen: " << sim.grid_paintings[sim.grid_pos].generation << std::endl;
std::cout << std::endl;
last_grid_pos = sim.grid_pos;
}
// Draw paintings
glViewport(0, 0, sim.tile_w, sim.tile_h);
for(unsigned int p = 0; p < sim.paintings.size(); ++p)
{
glBindFramebuffer(GL_FRAMEBUFFER, sim.paintings[p].fbo);
glClearColor(sim.paintings[p].r, sim.paintings[p].g, sim.paintings[p].b, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// bind the current vao
glBindVertexArray(vao);
// Vertices
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 2 * 3 * sim.paintings[p].num_triangles * sizeof(GLfloat), &sim.paintings[p].positions[0], GL_STATIC_DRAW);
// Colours
glBindBuffer(GL_ARRAY_BUFFER, cbo);
glBufferData(GL_ARRAY_BUFFER, 3 * 3 * sim.paintings[p].num_triangles * sizeof(GLfloat), &sim.paintings[p].colours[0], GL_STATIC_DRAW);
// Texture coords
glBindBuffer(GL_ARRAY_BUFFER, uvbo);
glBufferData(GL_ARRAY_BUFFER, 2 * 3 * sim.paintings[p].num_triangles * sizeof(GLfloat), &sim.paintings[p].uvs[0], GL_STATIC_DRAW);
glUseProgram(shader_program);
// Set the uniforms
glm::mat4 view = glm::ortho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
glUniformMatrix4fv(0, 1, GL_FALSE, glm::value_ptr(view));
// Draw
glDrawArrays(GL_TRIANGLES, 0, 3*sim.paintings[p].num_triangles);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, settings.w, settings.h);
// Comparisons
for(unsigned int p = 0; p < sim.paintings.size(); ++p)
{
glUseProgram(similarity_program);
glActiveTexture(GL_TEXTURE0 + texture_slice);
glBindTexture(GL_TEXTURE_2D, texture_slice);
glActiveTexture(GL_TEXTURE0 + sim.paintings[p].texture_id);
glBindTexture(GL_TEXTURE_2D, sim.paintings[p].texture_id);
// Setup uniforms
glUniform1i(0, texture_slice);
glUniform1i(1, sim.paintings[p].texture_id);
glUniform1i(2, p);
// Compute
int groups_x = sim.tile_w/16;
int groups_y = sim.tile_h/16;
glDispatchCompute(groups_x, groups_y, 1);
// Get scores
glBindBuffer(GL_SHADER_STORAGE_BUFFER, scores_bo);
glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, num_workgroups*sizeof(scores[0]), &scores[0]);
// Calculate similarity percentage
sim.paintings[p].score = 0.0;
for(int n = 0; n < num_workgroups; ++n)
{
sim.paintings[p].score += scores[n];
}
sim.paintings[p].score = 1.0 - sim.paintings[p].score/(3*sim.tile_w*sim.tile_h);
}
glActiveTexture(GL_TEXTURE0);
// Find best painting
parent1_id = sim.paintings.size();
parent1_score = FLT_MIN;
parent2_id = sim.paintings.size();
parent2_score = FLT_MIN;
for(unsigned int p = 0; p < sim.paintings.size(); ++p)
{
if(sim.paintings[p].score >= parent1_score)
{
parent2_id = parent1_id;
parent2_score = parent1_score;
parent1_id = p;
parent1_score = sim.paintings[p].score;
continue;
}
if(sim.paintings[p].score >= parent2_score)
{
parent2_id = p;
parent2_score = sim.paintings[p].score;
}
}
assert(parent1_id != sim.paintings.size());
assert(parent2_id != sim.paintings.size());
assert(parent1_id != parent2_id);
assert(parent1_score >= 0.0);
assert(parent2_score >= 0.0);
// To be used when a screenshot is taken
settings.best_painting = sim.result_id;
// Create new sim.paintings from best
for(unsigned int p = 0; p < sim.paintings.size(); ++p)
{
if(p == parent1_id || p == parent2_id) {continue;}
paintings_breed(&sim.paintings[p], &sim.paintings[parent1_id], &sim.paintings[parent2_id]);
}
// Mutate sim.paintings
for(unsigned int p = 0; p < sim.paintings.size(); ++p)
{
if(p == parent1_id || p == parent2_id) {continue;}
painting_jiggle(&sim.paintings[p]);
}
// Print scores occasionally
if(sim.grid_paintings[sim.grid_pos].generation%250 == 0)
{
//std::cout << "Gen " << sim.grid_paintings[sim.grid_pos].generation << ": " << parent1_id << " - " << sim.grid_paintings[sim.grid_pos].score*100.0 << "% " << std::endl;
//std::cout << "Gen " << sim.grid_paintings[sim.grid_pos].generation << ": " << parent1_id << " - " << sim.grid_paintings[sim.grid_pos].score*100.0 << "% " << sim.grid_paintings[sim.grid_pos].score_rate << std::endl;
}
// Save best painting if it's an improvement
if(sim.paintings[parent1_id].score > sim.grid_paintings[sim.grid_pos].score)
{
int temp = sim.grid_paintings[sim.grid_pos].generation;
painting_copy(&sim.grid_paintings[sim.grid_pos], &sim.paintings[parent1_id]);
sim.grid_paintings[sim.grid_pos].generation = temp;
}
// Count generations
sim.grid_paintings[sim.grid_pos].generation++;
if(settings.mode == MODE_AUTO)
{
auto_generation++;
}
}
// Render target and best sim.paintings
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindVertexArray(vao);
glUseProgram(shader_program);
glm::mat4 view = glm::ortho(-1.0, 1.0, 0.0, 1.0, -1.0, 1.0);
glUniformMatrix4fv(0, 1, GL_FALSE, glm::value_ptr(view));
// Render target to the screen
glBindTexture(GL_TEXTURE_2D, sim.target_id);
GLfloat positions[8] = {-1.0, 0.0,
-1.0, 1.0,
0.0, 1.0,
0.0, 0.0};
GLfloat colours[12] = {0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0};
GLfloat uvs[8] = {0.0, 0.0,
0.0, 1.0,
1.0, 1.0,
1.0, 0.0};
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &positions, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, cbo);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), &colours, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, uvbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &uvs, GL_STATIC_DRAW);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
if(settings.tiled_view == true)
{
unsigned int x_num = ceil(sqrt(sim.paintings.size()));
unsigned int y_num = ceil(sqrt(sim.paintings.size()));
if(x_num*(y_num-1) >= sim.paintings.size())
{
y_num -= 1;
}
float width = 1.0/x_num;
float height = 1.0/y_num;
for(unsigned int y = 0; y < y_num; ++y)
{
for(unsigned int x = 0; x < x_num; ++x)
{
if(y*x_num + x >= sim.paintings.size()) {break;}
glBindTexture(GL_TEXTURE_2D, sim.paintings[y*y_num + x].texture_id);
positions[0] = x*width; positions[1] = y*height;
positions[2] = x*width; positions[3] = (y+1)*height;
positions[4] = (x+1)*width; positions[5] = (y+1)*height;
positions[6] = (x+1)*width; positions[7] = y*height;
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &positions, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, cbo);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), &colours, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, uvbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &uvs, GL_STATIC_DRAW);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
}
}
else
{
// Draw the results texture
glBindTexture(GL_TEXTURE_2D, sim.result_id);
positions[0] = 0.0; positions[1] = 0.0;
positions[2] = 0.0; positions[3] = 1.0;
positions[4] = 1.0; positions[5] = 1.0;
positions[6] = 1.0; positions[7] = 0.0;
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &positions, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, cbo);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), &colours, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, uvbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &uvs, GL_STATIC_DRAW);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
// Draw current best over the top of the results texture
glBindTexture(GL_TEXTURE_2D, sim.paintings[parent1_id].texture_id);
float x_gap = 1.0/sim.grid_w;
float y_gap = 1.0/sim.grid_h;
positions[0] = x_gap*tile_x; positions[1] = y_gap*tile_y;
positions[2] = x_gap*tile_x; positions[3] = y_gap*(tile_y+1);
positions[4] = x_gap*(tile_x+1); positions[5] = y_gap*(tile_y+1);
positions[6] = x_gap*(tile_x+1); positions[7] = y_gap*tile_y;
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &positions, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, cbo);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), &colours, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, uvbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &uvs, GL_STATIC_DRAW);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
glfwSwapBuffers(window);
// check for errors
GLenum error = glGetError();
if(error != GL_NO_ERROR)
{
std::cout << "Error: " << error << std::endl;
}
// FPS
glEndQuery(GL_TIME_ELAPSED);
GLuint64 result;
glGetQueryObjectui64v(query, GL_QUERY_RESULT, &result);
std::stringstream tmp;
tmp << "Painting Evolution: " << int(1e9/result) << " FPS";
glfwSetWindowTitle(window, tmp.str().c_str());
glfwPollEvents();
}
delete[] data;
// delete the created objects
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &scores_bo);
glDetachShader(shader_program, vertex_shader);
glDetachShader(shader_program, fragment_shader);
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
glDeleteProgram(shader_program);
glDetachShader(similarity_program, compute_shader);
glDeleteShader(compute_shader);
glDeleteProgram(similarity_program);
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
int main() {
// Init components
components_init();
// Load fonts
f_small = font_load("font_small");
f_large = font_load("font_large");
// Load images
img_blood = bmp_load("images/blood.bmp");
bmp_image *img_space = bmp_load("images/space.bmp");
bmp_image *img_ufo1 = bmp_load("images/ufo1.bmp");
bmp_image *img_ufo2 = bmp_load("images/ufo2.bmp");
bmp_image *img_ufo3 = bmp_load("images/ufo3.bmp");
bmp_image *img_ufo4 = bmp_load("images/ufo4.bmp");
bmp_image *img_ufo5 = bmp_load("images/ufo5.bmp");
bmp_image *img_rabby = bmp_load("rabbit.bmp");
bmp_image *img_powerup1 = bmp_load("images/pow1.bmp");
bmp_image *img_powerup2 = bmp_load("images/pow1.bmp");
bmp_image *img_powerup3 = bmp_load("images/pow1.bmp");
bmp_image *img_powerup4 = bmp_load("images/pow1.bmp");
bmp_image *img_rabby_red = bmp_copy(img_rabby);
bmp_tint(img_rabby_red, 255, 128, 128);
bmp_tint(img_powerup3, 0, 250, 29);
bmp_tint(img_powerup2, 0, 0, 255);
bmp_tint(img_powerup1, 255, 255, 29);
// Create drawables
space = drawable_create_bmp(img_space);
ufo1 = drawable_create_bmp(img_ufo1);
ufo2 = drawable_create_bmp(img_ufo2);
ufo3 = drawable_create_bmp(img_ufo3);
ufo4 = drawable_create_bmp(img_ufo4);
ufo5 = drawable_create_bmp(img_ufo5);
rabby = drawable_create_bmp(img_rabby);
bullet = drawable_create_rect(4, 4, 255, 255, 255);
rabby_red = drawable_create_bmp(img_rabby_red);
power_sprite[0] = drawable_create_bmp(img_powerup1);
power_sprite[1] = drawable_create_bmp(img_powerup2);
power_sprite[2] = drawable_create_bmp(img_powerup3);
power_sprite[3] = drawable_create_bmp(img_powerup4);
// Start midi player in another thread
pthread_t thread_midi;
int result = pthread_create(&thread_midi, NULL, midi_run, NULL);
// Loop game
while (1) {
engine_init();
init();
engine_run();
dispose();
engine_dispose();
}
}
int main(int argc, char **argv)
{
unsigned char *img1=NULL, *img2=NULL, *errImg=NULL;
int usePPM=0;
unsigned char err, pixelErr, maxCompErr[4]={ 0, 0, 0, 0 },
minCompErr[4]={ 255, 255, 255, 255 }, maxTotalErr, minTotalErr;
double avgCompErr[4]={ 0., 0., 0., 0. }, avgTotalErr=0.,
compSumSquares[4]={ 0., 0., 0., 0. }, totalSumSquares=0.,
rms[4]={ 0., 0., 0., 0. }, totalRMS;
int width1, height1, ps1=3, width2, height2, ps2=3, width, height,
i, j, k, mag=0;
char *temp;
if(argc<3)
{
printf("\nUSAGE: %s <image 1> <image 2> [-mag]\n", argv[0]);
printf(" (images must be in BMP or PPM format)\n");
printf("\n-mag = show magnitude of differences using an artificial\n");
printf(" color scale\n\n");
exit(1);
}
if(argc>3 && !strcmp(argv[3], "-mag")) mag=1;
if((temp=strrchr(argv[1], '.'))!=NULL && !stricmp(temp, ".ppm"))
usePPM=1;
if(mag)
{
for(i=0; i<64; i++)
{
redMap[i]=0; greenMap[i]=i*4; blueMap[i]=0;
}
for(i=0; i<64; i++)
{
redMap[i+64]=i*4; greenMap[i+64]=255; blueMap[i+64]=0;
}
for(i=0; i<64; i++)
{
redMap[i+128]=255; greenMap[i+128]=255-i*4; blueMap[i+128]=0;
}
for(i=0; i<64; i++)
{
redMap[i+192]=255; greenMap[i+192]=i*4; blueMap[i+192]=i*4;
}
}
if(bmp_load(argv[1], &img1, &width1, 1, &height1, BMPPF_BGR,
BMPORN_TOPDOWN)==-1)
{
puts(bmp_geterr()); exit(1);
}
if(bmp_load(argv[2], &img2, &width2, 1, &height2, BMPPF_BGR,
BMPORN_TOPDOWN)==-1)
{
puts(bmp_geterr()); exit(1);
}
width=min(width1, width2); height=min(height1, height2);
if((errImg=(unsigned char *)malloc(width*height*ps1))==NULL)
{
puts("Could not allocate memory"); exit(1);
}
for(j=0; j<height; j++)
for(i=0; i<width; i++)
{
pixelErr=0;
for(k=0; k<ps1; k++)
{
err=(unsigned char)abs((int)img2[(width2*j+i)*ps2+k]
-(int)img1[(width1*j+i)*ps1+k]);
if(err>pixelErr) pixelErr=err;
if(err>maxCompErr[k]) maxCompErr[k]=err;
if(err<minCompErr[k]) minCompErr[k]=err;
avgCompErr[k]+=err; compSumSquares[k]+=err*err;
if(!mag) errImg[(width*j+i)*ps1+k]=err;
}
if(mag)
{
errImg[(width*j+i)*ps1]=blueMap[pixelErr];
errImg[(width*j+i)*ps1+1]=greenMap[pixelErr];
errImg[(width*j+i)*ps1+2]=redMap[pixelErr];
}
}
maxTotalErr=maxCompErr[0]; minTotalErr=minCompErr[0];
for(k=0; k<ps1; k++)
{
if(minCompErr[k]<maxTotalErr) minTotalErr=minCompErr[k];
if(maxCompErr[k]>maxTotalErr) maxTotalErr=maxCompErr[k];
avgTotalErr+=avgCompErr[k];
avgCompErr[k]/=((double)height*(double)width);
totalSumSquares+=compSumSquares[k];
compSumSquares[k]/=((double)height*(double)width);
rms[k]=sqrt(compSumSquares[k]);
}
avgTotalErr/=((double)height*(double)width*(double)ps1);
totalSumSquares/=((double)height*(double)width*(double)ps1);
totalRMS=sqrt(totalSumSquares);
if(bmp_save(usePPM? "diff.ppm":"diff.bmp", errImg, width, 0, height,
BMPPF_BGR, BMPORN_TOPDOWN)==-1)
{
puts(bmp_geterr()); exit(1);
}
free(errImg);
for(k=0; k<ps1; k++)
printf("%s: min err.= %d max err.= %d avg err.= %f rms= %f PSNR= %f\n",
k==0? "B":(k==1? "G":(k==2? "R":"A")), minCompErr[k], maxCompErr[k],
avgCompErr[k], rms[k], 20.*log10(255./rms[k]));
printf("T: min err.= %d max err.= %d avg err.= %f rms= %f PSNR= %f\n",
minTotalErr, maxTotalErr, avgTotalErr, totalRMS, 20.*log10(255./totalRMS));
return 0;
}
