342 lines
12 KiB
C
342 lines
12 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
|
|
#include <time.h>
|
|
|
|
#ifdef __APPLE__
|
|
#include <OpenCL/opencl.h>
|
|
#else
|
|
#include <CL/cl.h>
|
|
#endif
|
|
|
|
#include <SDL.h>
|
|
#include <SDL_ttf.h>
|
|
|
|
#define MAX_SOURCE_SIZE (0x100000)
|
|
|
|
int main(int argn, char **argv) {
|
|
|
|
// Init SDL
|
|
if(SDL_Init(SDL_INIT_VIDEO) != 0)
|
|
fprintf(stderr, "Could not initialize SDL: %s\n", SDL_GetError());
|
|
|
|
printf("SDL Initialized\n");
|
|
|
|
// Create screen surface
|
|
SDL_Surface *screen, *message;
|
|
int res_x = 800;
|
|
int res_y = 600;
|
|
int current_line = 0;
|
|
int julia_mode = 0;
|
|
|
|
if (argn == 1)
|
|
{
|
|
julia_mode = 0;
|
|
}
|
|
else if ((argn == 2) && (strcmp(argv[1], "-julia") == 0))
|
|
{
|
|
julia_mode = 1;
|
|
printf("Julia mode activated...\n");
|
|
}
|
|
|
|
SDL_Window *window = SDL_CreateWindow("CLFract",
|
|
SDL_WINDOWPOS_UNDEFINED,
|
|
SDL_WINDOWPOS_UNDEFINED,
|
|
0, 0,
|
|
SDL_WINDOW_FULLSCREEN_DESKTOP);
|
|
|
|
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
|
|
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"); // make the scaled rendering look smoother.
|
|
SDL_RenderSetLogicalSize(renderer, res_x, res_y);
|
|
|
|
if ((!window) || (!renderer))
|
|
fprintf(stderr,"Could not set video mode: %s\n",SDL_GetError());
|
|
|
|
// Blank the window
|
|
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
|
|
SDL_RenderClear(renderer);
|
|
SDL_RenderPresent(renderer);
|
|
|
|
SDL_Texture *texture_screen = SDL_CreateTexture(renderer,
|
|
SDL_PIXELFORMAT_ARGB8888,
|
|
SDL_TEXTUREACCESS_STREAMING,
|
|
res_x, res_y);
|
|
|
|
screen = SDL_CreateRGBSurface(0, res_x, res_y , 32, 0, 0, 0, 0);
|
|
|
|
//Initialize SDL_ttf
|
|
if( TTF_Init() == -1 )
|
|
{
|
|
printf("Error setting up TTF module.\n");
|
|
return 1;
|
|
}
|
|
|
|
// Load a font
|
|
TTF_Font *font;
|
|
font = TTF_OpenFont("font.ttf", 24);
|
|
if (font == NULL)
|
|
{
|
|
printf("TTF_OpenFont() Failed: %s", TTF_GetError());
|
|
SDL_Quit();
|
|
return 1;
|
|
}
|
|
|
|
//The color of the font
|
|
SDL_Color textColor = { 255, 255, 255 };
|
|
|
|
// Prepare the resolution and sizes and colors...
|
|
const int ITERATIONS = 256;
|
|
|
|
// Load the kernel source code into the array source_str
|
|
FILE *fp;
|
|
char *source_str;
|
|
size_t source_size;
|
|
|
|
if (julia_mode == 0)
|
|
fp = fopen("mandelbrot_kernel.cl", "r");
|
|
else
|
|
fp = fopen("julia_kernel.cl", "r");
|
|
|
|
if (!fp) {
|
|
fprintf(stderr, "Failed to load kernel.\n");
|
|
exit(1);
|
|
}
|
|
source_str = (char*)malloc(MAX_SOURCE_SIZE);
|
|
source_size = fread( source_str, 1, MAX_SOURCE_SIZE, fp);
|
|
fclose( fp );
|
|
|
|
// Get platform and device information
|
|
cl_platform_id platform_id = NULL;
|
|
cl_device_id device_id = NULL;
|
|
cl_uint ret_num_devices;
|
|
cl_uint ret_num_platforms;
|
|
cl_int ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);
|
|
ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_GPU, 1,
|
|
&device_id, &ret_num_devices);
|
|
|
|
// Create an OpenCL context
|
|
cl_context context = clCreateContext( NULL, 1, &device_id, NULL, NULL, &ret);
|
|
|
|
// Create a command queue
|
|
cl_command_queue command_queue = clCreateCommandQueueWithProperties(context, device_id, 0, &ret);
|
|
|
|
// Create memory buffers on the device for returning iterations
|
|
// Input parameters
|
|
cl_mem kernel_res_x = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
sizeof(int), &res_x, &ret);
|
|
cl_mem kernel_res_y = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
sizeof(int), &res_y, &ret);
|
|
cl_mem kernel_current_line = clCreateBuffer(context, CL_MEM_READ_ONLY,
|
|
sizeof(int), NULL, &ret);
|
|
cl_mem kernel_zoom_level = clCreateBuffer(context, CL_MEM_READ_ONLY,
|
|
sizeof(float), NULL, &ret);
|
|
// Output buffer
|
|
cl_mem graph_mem_obj = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
|
res_x * sizeof(int), NULL, &ret);
|
|
|
|
// Create a program from the kernel source
|
|
cl_program program = clCreateProgramWithSource(context, 1,
|
|
(const char **)&source_str, (const size_t *)&source_size, &ret);
|
|
|
|
// Build the program
|
|
ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
|
|
|
|
if (ret != CL_SUCCESS) {
|
|
printf("Program build failed, error code: %d", ret);
|
|
|
|
// Check if it is correct
|
|
printf("clBuildProgram\n");
|
|
cl_build_status build_status;
|
|
ret = clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_STATUS, sizeof(cl_build_status), &build_status, NULL);
|
|
|
|
char *build_log;
|
|
size_t ret_val_size;
|
|
ret = clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
|
|
|
|
build_log = (char *) malloc((ret_val_size + 1) * sizeof(char));
|
|
ret = clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
|
|
build_log[ret_val_size] = '\0';
|
|
|
|
printf("BUILD LOG: \n %s", build_log);
|
|
exit(1);
|
|
|
|
}
|
|
|
|
printf("program built\n");
|
|
|
|
// Create the OpenCL kernel
|
|
cl_kernel kernel = clCreateKernel(program, "fractal_point", &ret);
|
|
|
|
if (ret != CL_SUCCESS) {
|
|
printf("Error when loading the kernel: %d", ret);
|
|
exit(1);
|
|
}
|
|
|
|
// Common kernel params
|
|
ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *) &kernel_res_x);
|
|
ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *) &kernel_res_y);
|
|
ret = clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *) &graph_mem_obj);
|
|
|
|
int graph_line[res_x]; // (int*)malloc(res_x * sizeof(int));
|
|
float zoom = 1.0; // Our current zoom level
|
|
float stop_point;
|
|
|
|
if (julia_mode == 0)
|
|
stop_point = 0.00001;
|
|
else
|
|
stop_point = -2.5;
|
|
|
|
clock_t start = clock();
|
|
|
|
while(zoom > stop_point)
|
|
{
|
|
for (current_line = 0; current_line < res_y; current_line++)
|
|
{
|
|
// Set the arguments of the kernel
|
|
ret = clEnqueueWriteBuffer(command_queue, kernel_current_line, CL_TRUE, 0,
|
|
sizeof(int), ¤t_line, 0, NULL, NULL);
|
|
|
|
ret = clEnqueueWriteBuffer(command_queue, kernel_zoom_level, CL_TRUE, 0,
|
|
sizeof(float), &zoom, 0, NULL, NULL);
|
|
|
|
clFinish(command_queue);
|
|
|
|
ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *) &kernel_current_line);
|
|
if (ret != CL_SUCCESS) {
|
|
printf("Error setting current_line %d", ret);
|
|
exit(1);
|
|
}
|
|
ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *) &kernel_zoom_level);
|
|
if (ret != CL_SUCCESS) {
|
|
printf("Error setting zoom_level %d", ret);
|
|
exit(1);
|
|
}
|
|
|
|
// Execute the OpenCL kernel on the list
|
|
size_t global_item_size = res_x; // Process the entire line
|
|
size_t local_item_size = 16; // Process in groups of 64
|
|
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL,
|
|
&global_item_size, &local_item_size, 0, NULL, NULL);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
{
|
|
printf("Error while executing kernel\n");
|
|
printf("Error code %d\n", ret);
|
|
exit(1);
|
|
}
|
|
|
|
// Wait for the computation to finish
|
|
clFinish(command_queue);
|
|
|
|
// Read the memory buffer graph_mem_obj on the device to the local variable graph_dots
|
|
ret = clEnqueueReadBuffer(command_queue, graph_mem_obj, CL_TRUE, 0,
|
|
res_x * sizeof(int), graph_line, 0, NULL, NULL);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
printf("Error while reading results buffer\n");
|
|
|
|
clFinish(command_queue);
|
|
|
|
int line_count;
|
|
Uint32 *pixel;
|
|
// Lock surface
|
|
// SDL_LockSurface(screen);
|
|
// rank = screen->pitch/sizeof(Uint32);
|
|
pixel = (Uint32*)screen->pixels;
|
|
int iteration;
|
|
|
|
for (line_count = 0; line_count < res_x; line_count++)
|
|
{
|
|
// int temp_val = graph_line[line_count];
|
|
// graph_dots[(current_line * res_x) + line_count] = temp_val;
|
|
// Get the iterations for the point
|
|
// printf("Point %d\n", i);
|
|
iteration = graph_line[line_count];
|
|
if ((iteration < 128) && (iteration > 0)) {
|
|
pixel[(current_line * res_x) + line_count] = SDL_MapRGBA(screen->format,
|
|
0,
|
|
20 + iteration,
|
|
0,
|
|
255);
|
|
}
|
|
else if ((iteration >= 128) && (iteration < ITERATIONS))
|
|
{
|
|
pixel[(current_line * res_x) + line_count] = SDL_MapRGBA(screen->format,
|
|
iteration,
|
|
148,
|
|
iteration,
|
|
255);
|
|
}
|
|
else
|
|
{
|
|
pixel[(current_line * res_x) + line_count] = SDL_MapRGBA(screen->format,
|
|
0,
|
|
0,
|
|
0,
|
|
255);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Step, iterate our zoom levels if we're doing mandelbrot or julia set
|
|
if (julia_mode == 0)
|
|
zoom = zoom * 0.98;
|
|
else
|
|
zoom -= 0.01;
|
|
|
|
// Draw message on a corner...
|
|
char* msg = (char *)malloc(100 * sizeof(char));
|
|
sprintf(msg, "Zoom level: %0.3f", zoom * 100.0);
|
|
message = TTF_RenderText_Solid( font, msg, textColor );
|
|
free(msg);
|
|
if (message != NULL)
|
|
SDL_BlitSurface(message, NULL, screen, NULL);
|
|
|
|
free(message);
|
|
|
|
SDL_UpdateTexture(texture_screen, NULL, (Uint32*)screen->pixels, 800 * sizeof (Uint32));
|
|
SDL_RenderClear(renderer);
|
|
SDL_RenderCopy(renderer, texture_screen, NULL, NULL);
|
|
SDL_RenderPresent(renderer);
|
|
// Draw to the screen
|
|
// SDL_Flip(screen);
|
|
}
|
|
|
|
printf("Time elapsed %0.5f seconds\n", ((double)clock() - start) / CLOCKS_PER_SEC);
|
|
|
|
// Clean up
|
|
ret = clFlush(command_queue);
|
|
ret = clFinish(command_queue);
|
|
ret = clReleaseKernel(kernel);
|
|
ret = clReleaseProgram(program);
|
|
ret = clReleaseMemObject(kernel_res_x);
|
|
ret = clReleaseMemObject(kernel_res_y);
|
|
ret = clReleaseMemObject(kernel_current_line);
|
|
ret = clReleaseMemObject(graph_mem_obj);
|
|
ret = clReleaseCommandQueue(command_queue);
|
|
ret = clReleaseContext(context);
|
|
// free(A);
|
|
// free(B);
|
|
// free(graph_dots);
|
|
// free(graph_line);
|
|
|
|
SDL_Event ev;
|
|
int active;
|
|
|
|
active = 1;
|
|
while(active)
|
|
{
|
|
/* Handle events */
|
|
while(SDL_PollEvent(&ev))
|
|
{
|
|
if(ev.type == SDL_QUIT)
|
|
active = 0; /* End */
|
|
}
|
|
}
|
|
|
|
SDL_Quit();
|
|
|
|
return 0;
|
|
}
|
|
|