From 518cc757a350c9dccdccd0d96d2d2fbf25acc8c7 Mon Sep 17 00:00:00 2001 From: MitchellHansen Date: Wed, 2 Nov 2016 00:09:32 -0700 Subject: [PATCH] Lots of work done moving the various raycasting implementations over to a consolidated RayCaster class. --- include/CL_Wrapper.h | 10 +- include/Hardware_Caster.h | 104 ++++++ include/Old_map.h | 1 - include/RayCaster.h | 27 +- include/Renderer.cpp | 10 +- include/Renderer.h | 4 +- src/CL_Wrapper.cpp | 6 +- src/Hardware_Caster.cpp | 733 ++++++++++++++++++++++++++++++++++++++ src/main.cpp | 2 + 9 files changed, 874 insertions(+), 23 deletions(-) create mode 100644 include/Hardware_Caster.h create mode 100644 src/Hardware_Caster.cpp diff --git a/include/CL_Wrapper.h b/include/CL_Wrapper.h index 08b8f5e..682f10b 100644 --- a/include/CL_Wrapper.h +++ b/include/CL_Wrapper.h @@ -22,11 +22,11 @@ #endif struct device { - cl_device_id id; - cl_device_type type; - cl_uint clock_frequency; - char version[128]; - cl_platform_id platform; + cl_device_id id; + cl_device_type type; + cl_uint clock_frequency; + char version[128]; + cl_platform_id platform; cl_uint comp_units; }; diff --git a/include/Hardware_Caster.h b/include/Hardware_Caster.h new file mode 100644 index 0000000..6db4c76 --- /dev/null +++ b/include/Hardware_Caster.h @@ -0,0 +1,104 @@ +#pragma once +#include +#include +#include +#include "util.hpp" +#include +#include + +#ifdef linux +#include +#include +#include + +#elif defined _WIN32 +#include +#include +#include +#include +#include + +#elif defined TARGET_OS_MAC +# include +# include + +#endif + +struct device { + cl_device_id id; + cl_device_type type; + cl_uint clock_frequency; + char version[128]; + cl_platform_id platform; + cl_uint comp_units; +}; + +class Hardware_Caster : public RayCaster +{ +public: + Hardware_Caster(); + + virtual ~Hardware_Caster(); + + int init(); + + // In interop mode, this will create a gl texture that we share + // Otherwise, it will create the pixel buffer and pass that in as an image, retreiving it each draw + // Both will create the view matrix, view res buffer + void create_viewport(int width, int height, float v_fov, float h_fov); + + void assign_light(Light light); + void assign_map(Old_Map *map); + void assign_camera(Camera *camera); + + // draw will abstract the gl sharing and software rendering + // methods of retrieving the screen buffer + void draw(sf::RenderWindow* window) = 0; + +private: + + + int acquire_platform_and_device(); + + int create_shared_context(); + + int create_command_queue(); + + int check_cl_khr_gl_sharing(); + + int create_image_buffer(std::string buffer_name, cl_uint size, void* data); + int create_buffer(std::string buffer_name, cl_uint size, void* data); + int create_buffer(std::string buffer_name, cl_uint size, void* data, cl_mem_flags flags); + int store_buffer(cl_mem, std::string buffer_name); + int release_buffer(std::string buffer_name); + + int compile_kernel(std::string kernel_source, bool is_path, std::string kernel_name); + + int set_kernel_arg(std::string kernel_name, int index, std::string buffer_name); + + int run_kernel(std::string kernel_name, const int work_size); + + bool assert(int error_code, std::string function_name); + + cl_device_id getDeviceID(); + cl_platform_id getPlatformID(); + cl_context getContext(); + cl_kernel getKernel(std::string kernel_name); + cl_command_queue getCommandQueue(); + + bool was_init_valid(); + + int error = 0; + bool initialized = false; + bool cl_khr_gl_sharing_fallback = false; + bool cl_supported = false; + + cl_platform_id platform_id; + cl_device_id device_id; + cl_context context; + cl_command_queue command_queue; + + std::map kernel_map; + std::map buffer_map; +}; + diff --git a/include/Old_map.h b/include/Old_map.h index 4740b2c..bbb9069 100644 --- a/include/Old_map.h +++ b/include/Old_map.h @@ -18,7 +18,6 @@ public: Old_Map(sf::Vector3i dim); ~Old_Map(); - void generate_from_data(char* dat, int len); void generate_terrain(); sf::Vector3i getDimensions(); diff --git a/include/RayCaster.h b/include/RayCaster.h index eb9dc78..a627107 100644 --- a/include/RayCaster.h +++ b/include/RayCaster.h @@ -3,30 +3,40 @@ #include #include #include "Old_map.h" +#include "Camera.h" -// What about a parent, child relationship between the raycaster and it's two -// different modes? Raycaster -> ClCaster, SoftwareCaster -class Camera; - class RayCaster { public: + enum ERROR_CODES { + SHARING_NOT_SUPPORTED = 800, + OPENCL_NOT_SUPPORTED = 801, + OPENCL_ERROR = 802, + ERROR = 803 + }; + RayCaster(); - ~RayCaster(); + virtual ~RayCaster(); + + virtual int init() = 0; virtual void assign_map(Old_Map *map) = 0; virtual void assign_camera(Camera *camera) = 0; - virtual void assign_viewport(int width, int height, float v_fov, float h_fov) = 0; + virtual void create_viewport(int width, int height, float v_fov, float h_fov) = 0; virtual void assign_light(Light light) = 0; // draw will abstract the gl sharing and software rendering // methods of retrieving the screen buffer virtual void draw(sf::RenderWindow* window) = 0; -private: +protected: - sf::Vector3 map_dimensions; + sf::Sprite viewport_sprite; + sf::Texture viewport_texture; + + + // A reference to the map Old_Map *map; // The XY resolution of the viewport @@ -38,7 +48,6 @@ private: // The direction of the camera in POLAR coordinates sf::Vector3 camera_direction; - // Convert the polar coordinates to CARTESIAN sf::Vector3 camera_direction_cartesian; diff --git a/include/Renderer.cpp b/include/Renderer.cpp index 0545cc4..7f119da 100644 --- a/include/Renderer.cpp +++ b/include/Renderer.cpp @@ -9,12 +9,12 @@ Renderer::Renderer() { } } -void Renderer::register_camera(Camera *camera) -{ - +void Renderer::register_camera(Camera *camera) { + this->camera = camera; } -void Renderer::draw() -{ +void Renderer::draw() { } + + diff --git a/include/Renderer.h b/include/Renderer.h index b7fb543..6b1773f 100644 --- a/include/Renderer.h +++ b/include/Renderer.h @@ -35,7 +35,7 @@ public: void register_map(Old_Map* map); void register_lights(); void create_viewport(float v_fov, float h_fov, int height, int width); - void register_light(light l); + void register_light(Light l); void draw(); sf::RenderWindow* get_window(); @@ -51,7 +51,7 @@ private: sf::Uint8 *drawing_surface; sf::RenderWindow* window; - std::vector lights; + std::vector lights; Old_Map* map; Camera* camera; sf::Uint8 *view_matrix; diff --git a/src/CL_Wrapper.cpp b/src/CL_Wrapper.cpp index af2cf84..3790f3b 100644 --- a/src/CL_Wrapper.cpp +++ b/src/CL_Wrapper.cpp @@ -5,9 +5,10 @@ CL_Wrapper::CL_Wrapper() { // Check to see if acquiring the platform failed out // This also catches when there are general errors, // falling back to the known good software renderer + if (acquire_platform_and_device() == -1) { std::cout << "Falling back to the software renderer" << std::endl; - return; + } cl_supported = true; @@ -390,6 +391,9 @@ bool CL_Wrapper::assert(int error_code, std::string function_name){ case CL_SUCCESS: return false; + + case 1: + return false; case CL_DEVICE_NOT_FOUND: err_msg += "CL_DEVICE_NOT_FOUND"; diff --git a/src/Hardware_Caster.cpp b/src/Hardware_Caster.cpp new file mode 100644 index 0000000..7aabbd6 --- /dev/null +++ b/src/Hardware_Caster.cpp @@ -0,0 +1,733 @@ +#include "Hardware_Caster.h" + + + +Hardware_Caster::Hardware_Caster() { + +} + + +Hardware_Caster::~Hardware_Caster() { +} + +int Hardware_Caster::init() { + + // Initialize opencl up to the point where we start assigning buffers + + int error = 0; + + error = acquire_platform_and_device(); + if(assert(error, "aquire_platform_and_device")) + return error; + + error = check_cl_khr_gl_sharing(); + if(assert(error, "check_cl_khr_gl_sharing")) + return error; + + error = create_shared_context(); + if (assert(error, "create_shared_context")) + return error; + + error = create_command_queue(); + if (assert(error, "create_command_queue")) + return error; + + error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "min_kern"); + if (assert(error, "compile_kernel")) { + std::cin.get(); // hang the output window so we can read the error + return error; + } + + return 1; + +} + +void Hardware_Caster::assign_map(Old_Map *map) { + + auto dimensions = map->getDimensions(); + + create_buffer("map_buffer", sizeof(char) * dimensions.x * dimensions.y * dimensions.z, map->get_voxel_data()); + create_buffer("dim_buffer", sizeof(int) * 3, &dimensions); + +} + +void Hardware_Caster::assign_camera(Camera *camera) { + + create_buffer("cam_dir_buffer", sizeof(float) * 4, (void*)camera->get_direction_pointer(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR); + create_buffer("cam_pos_buffer", sizeof(float) * 4, (void*)camera->get_position_pointer(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR); +} + +// There is a possibility that I would want to move this over to be all inside it's own +// container to make it so it can be changed via CL_MEM_USE_HOST_PTR. But I doubt it +// would ever be called enough to warrent that +void Hardware_Caster::create_viewport(int width, int height, float v_fov, float h_fov) { + + // CL needs the screen resolution + sf::Vector2i view_res(width, height); + create_buffer("res_buffer", sizeof(int) * 2, &view_res); + + // And an array of vectors describing the way the "lens" of our + // camera works + + // This could be modified to make some odd looking camera lenses + + double y_increment_radians = DegreesToRadians(v_fov / view_res.y); + double x_increment_radians = DegreesToRadians(h_fov / view_res.x); + + sf::Vector4f* view_matrix = new sf::Vector4f[width * height * 4]; + + for (int y = -view_res.y / 2; y < view_res.y / 2; y++) { + for (int x = -view_res.x / 2; x < view_res.x / 2; x++) { + + // The base ray direction to slew from + sf::Vector3f ray(1, 0, 0); + + // Y axis, pitch + ray = sf::Vector3f( + static_cast(ray.z * sin(y_increment_radians * y) + ray.x * cos(y_increment_radians * y)), + static_cast(ray.y), + static_cast(ray.z * cos(y_increment_radians * y) - ray.x * sin(y_increment_radians * y)) + ); + + + // Z axis, yaw + ray = sf::Vector3f( + static_cast(ray.x * cos(x_increment_radians * x) - ray.y * sin(x_increment_radians * x)), + static_cast(ray.x * sin(x_increment_radians * x) + ray.y * cos(x_increment_radians * x)), + static_cast(ray.z) + ); + + int index = (x + view_res.x / 2) + view_res.x * (y + view_res.y / 2); + ray = Normalize(ray); + + view_matrix[index] = sf::Vector4f( + ray.x, + ray.y, + ray.z, + 0 + ); + } + } + + create_buffer("view_matrix_buffer", sizeof(float) * 4 * view_res.x * view_res.y, view_matrix); + + // Create the image that opencl's rays write to + unsigned char* pixel_array = new sf::Uint8[width * height * 4]; + + for (int i = 0; i < width * height * 4; i += 4) { + + pixel_array[i] = 255; // R + pixel_array[i + 1] = 255; // G + pixel_array[i + 2] = 255; // B + pixel_array[i + 3] = 100; // A + } + + // Interop lets us keep a reference to it as a texture + viewport_texture.create(width, height); + viewport_texture.update(pixel_array); + viewport_sprite.setTexture(viewport_texture); + + // Pass the buffer to opencl + create_image_buffer("image_buffer", sizeof(sf::Uint8) * width * height * 4, pixel_array); + +} + +void Hardware_Caster::assign_light(Light light) { + +} + +void Hardware_Caster::draw(sf::RenderWindow* window) { + +} + +int Hardware_Caster::acquire_platform_and_device() { + + // Get the number of platforms + cl_uint plt_cnt = 0; + clGetPlatformIDs(0, nullptr, &plt_cnt); + + // Fetch the platforms + std::map> plt_ids; + + // buffer before map init + std::vector plt_buf(plt_cnt); + clGetPlatformIDs(plt_cnt, plt_buf.data(), nullptr); + + // Map init + for (auto id : plt_buf) { + plt_ids.emplace(std::make_pair(id, std::vector())); + } + + // For each platform, populate its devices + for (unsigned int i = 0; i < plt_cnt; i++) { + + cl_uint deviceIdCount = 0; + error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, 0, nullptr, &deviceIdCount); + + // Check to see if we even have opencl on this machine + if (deviceIdCount == 0) { + cl_supported = false; + std::cout << "There appears to be no platforms supporting opencl" << std::endl; + return OPENCL_NOT_SUPPORTED; + } + + // Get the device ids + std::vector deviceIds(deviceIdCount); + error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL); + + if (assert(error, "clGetDeviceIDs")) + return OPENCL_ERROR; + + for (int q = 0; q < deviceIdCount; q++) { + + device d; + + d.id = deviceIds[q]; + + clGetDeviceInfo(d.id, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &d.platform, NULL); + clGetDeviceInfo(d.id, CL_DEVICE_VERSION, sizeof(char) * 128, &d.version, NULL); + clGetDeviceInfo(d.id, CL_DEVICE_TYPE, sizeof(cl_device_type), &d.type, NULL); + clGetDeviceInfo(d.id, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(cl_uint), &d.clock_frequency, NULL); + clGetDeviceInfo(d.id, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(cl_uint), &d.comp_units, NULL); + + plt_ids.at(d.platform).push_back(d); + } + } + + + // The devices how now been queried we want to shoot for a gpu with the fastest clock, + // falling back to the cpu with the fastest clock if we weren't able to find one + + device current_best_device; + current_best_device.type = 0; // Set this to 0 so the first run always selects a new device + current_best_device.clock_frequency = 0; + current_best_device.comp_units = 0; + + + for (auto kvp : plt_ids) { + + for (auto device : kvp.second) { + + // Gonna just split this up into cases. There are so many devices I cant test with + // that opencl supports. I'm not going to waste my time making a generic implimentation + + // Upon success of a condition, set the current best device values + + if (device.type == CL_DEVICE_TYPE_GPU && current_best_device.type != CL_DEVICE_TYPE_GPU) { + current_best_device = device; + } + else if (device.comp_units > current_best_device.comp_units) { + current_best_device = device; + } + else if (current_best_device.type != CL_DEVICE_TYPE_GPU && device.clock_frequency > current_best_device.clock_frequency) { + current_best_device = device; + } + } + } + + platform_id = current_best_device.platform; + device_id = current_best_device.id; + + return 1; +}; + +int Hardware_Caster::create_shared_context() { + + // Hurray for standards! + // Setup the context properties to grab the current GL context + +#ifdef linux + + cl_context_properties context_properties[] = { + CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(), + CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(), + CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id, + 0 + }; + +#elif defined _WIN32 + + HGLRC hGLRC = wglGetCurrentContext(); + HDC hDC = wglGetCurrentDC(); + cl_context_properties context_properties[] = { + CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id, + CL_GL_CONTEXT_KHR, (cl_context_properties)hGLRC, + CL_WGL_HDC_KHR, (cl_context_properties)hDC, + 0 + }; + + +#elif defined TARGET_OS_MAC + + CGLContextObj glContext = CGLGetCurrentContext(); + CGLShareGroupObj shareGroup = CGLGetShareGroup(glContext); + cl_context_properties context_properties[] = { + CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, + (cl_context_properties)shareGroup, + 0 + }; + +#endif + + // Create our shared context + context = clCreateContext( + context_properties, + 1, + &device_id, + nullptr, nullptr, + &error + ); + + if (assert(error, "clCreateContext")) + return OPENCL_ERROR; + + return 1; +} + +int Hardware_Caster::create_command_queue() { + + if (context && device_id) { + // And the cl command queue + command_queue = clCreateCommandQueue(context, device_id, 0, &error); + + if (assert(error, "clCreateCommandQueue")) + return OPENCL_ERROR; + + return 1; + } + else { + std::cout << "Failed creating the command queue. Context or device_id not initialized"; + return OPENCL_ERROR; + } +} + +int Hardware_Caster::check_cl_khr_gl_sharing() { + + // Test for sharing + size_t ext_str_size = 1024; + char *ext_str = new char[ext_str_size]; + clGetDeviceInfo(device_id, CL_DEVICE_EXTENSIONS, ext_str_size, ext_str, &ext_str_size); + + if (std::string(ext_str).find("cl_khr_gl_sharing") == std::string::npos) { + std::cout << "No support for the cl_khr_gl_sharing extension"; + delete ext_str; + return RayCaster::SHARING_NOT_SUPPORTED; + } + + delete ext_str; + return 1; +} + +int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std::string kernel_name) { + + const char* source; + std::string tmp; + + if (is_path) { + //Load in the kernel, and c stringify it + tmp = read_file(kernel_source); + source = tmp.c_str(); + } + else { + source = kernel_source.c_str(); + } + + size_t kernel_source_size = strlen(source); + + // Load the source into CL's data structure + cl_program program = clCreateProgramWithSource( + context, 1, + &source, + &kernel_source_size, &error + ); + + // This is not for compilation, it only loads the source + if (assert(error, "clCreateProgramWithSource")) + return OPENCL_ERROR; + + + // Try and build the program + error = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL); + + // Check to see if it errored out + if (assert(error, "clBuildProgram")) { + + // Get the size of the queued log + size_t log_size; + clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size); + char *log = new char[log_size]; + + // Grab the log + clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, log_size, log, NULL); + + std::cout << log; + return OPENCL_ERROR; + } + + // Done initializing the kernel + cl_kernel kernel = clCreateKernel(program, kernel_name.c_str(), &error); + + if (assert(error, "clCreateKernel")) + return OPENCL_ERROR; + + kernel_map.emplace(std::make_pair(kernel_name, kernel)); + + return 1; +} + +int Hardware_Caster::set_kernel_arg( + std::string kernel_name, + int index, + std::string buffer_name) { + + error = clSetKernelArg( + kernel_map.at(kernel_name), + index, + sizeof(cl_mem), + (void *)&buffer_map.at(buffer_name)); + + if (assert(error, "clSetKernelArg")) + return OPENCL_ERROR; + + return 0; + +} + +int Hardware_Caster::create_image_buffer(std::string buffer_name, cl_uint size, void* data) { + + // I can imagine overwriting buffers will be common, so I think + // this is safe to overwrite / release old buffers quietly + if (buffer_map.count(buffer_name) > 0) { + release_buffer(buffer_name); + } + + int error; + cl_mem buff = clCreateFromGLTexture( + getContext(), CL_MEM_WRITE_ONLY, GL_TEXTURE_2D, + 0, viewport_texture.getNativeHandle(), &error); + + if (assert(error, "clCreateFromGLTexture")) + return OPENCL_ERROR; + + store_buffer(buff, buffer_name); + + return 1; +} + +int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void* data, cl_mem_flags flags) { + + // I can imagine overwriting buffers will be common, so I think + // this is safe to overwrite / release old buffers quietly + if (buffer_map.count(buffer_name) > 0) { + release_buffer(buffer_name); + } + + cl_mem buff = clCreateBuffer( + getContext(), flags, + size, data, &error + ); + + if (assert(error, "clCreateBuffer")) + return OPENCL_ERROR; + + store_buffer(buff, buffer_name); + + return 1; + +} + +int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void* data) { + + // I can imagine overwriting buffers will be common, so I think + // this is safe to overwrite / release old buffers quietly + if (buffer_map.count(buffer_name) > 0) { + release_buffer(buffer_name); + } + + cl_mem buff = clCreateBuffer( + getContext(), CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, + size, data, &error + ); + + if (assert(error, "clCreateBuffer")) + return OPENCL_ERROR; + + store_buffer(buff, buffer_name); + + return 1; + +} + +int Hardware_Caster::release_buffer(std::string buffer_name) { + + if (buffer_map.count(buffer_name) > 0) { + + int error = clReleaseMemObject(buffer_map.at(buffer_name)); + + if (assert(error, "clReleaseMemObject")) { + std::cout << "Error releasing buffer : " << buffer_name; + std::cout << "Buffer not removed"; + return -1; + + } else { + buffer_map.erase(buffer_name); + } + + } else { + std::cout << "Error releasing buffer : " << buffer_name; + std::cout << "Buffer not found"; + return -1; + } + + return 1; + +} + +int Hardware_Caster::store_buffer(cl_mem buffer, std::string buffer_name) { + buffer_map.emplace(std::make_pair(buffer_name, buffer)); + return 1; +} + +int Hardware_Caster::run_kernel(std::string kernel_name, const int work_size) { + + size_t global_work_size[1] = { static_cast(work_size) }; + + cl_kernel kernel = kernel_map.at(kernel_name); + + error = clEnqueueAcquireGLObjects(getCommandQueue(), 1, &buffer_map.at("image_buffer"), 0, 0, 0); + if (assert(error, "clEnqueueAcquireGLObjects")) + return OPENCL_ERROR; + + //error = clEnqueueTask(command_queue, kernel, 0, NULL, NULL); + error = clEnqueueNDRangeKernel( + command_queue, kernel, + 1, NULL, global_work_size, + NULL, 0, NULL, NULL); + + if (assert(error, "clEnqueueNDRangeKernel")) + return OPENCL_ERROR; + + clFinish(getCommandQueue()); + + // What if errors out and gl objects are never released? + error = clEnqueueReleaseGLObjects(getCommandQueue(), 1, &buffer_map.at("image_buffer"), 0, NULL, NULL); + if (assert(error, "clEnqueueReleaseGLObjects")) + return OPENCL_ERROR; + + return 1; +} + +cl_device_id Hardware_Caster::getDeviceID() { return device_id; }; +cl_platform_id Hardware_Caster::getPlatformID() { return platform_id; }; +cl_context Hardware_Caster::getContext() { return context; }; +cl_kernel Hardware_Caster::getKernel(std::string kernel_name) { return kernel_map.at(kernel_name); }; +cl_command_queue Hardware_Caster::getCommandQueue() { return command_queue; }; + +bool Hardware_Caster::was_init_valid() { + return cl_supported; +} + +bool Hardware_Caster::assert(int error_code, std::string function_name) { + + // Just gonna do a little jump table here, just error codes so who cares + std::string err_msg = "Error : "; + + switch (error_code) { + + case CL_SUCCESS: + return false; + + case 1: + return false; + + case CL_DEVICE_NOT_FOUND: + err_msg += "CL_DEVICE_NOT_FOUND"; + break; + case CL_DEVICE_NOT_AVAILABLE: + err_msg = "CL_DEVICE_NOT_AVAILABLE"; + break; + case CL_COMPILER_NOT_AVAILABLE: + err_msg = "CL_COMPILER_NOT_AVAILABLE"; + break; + case CL_MEM_OBJECT_ALLOCATION_FAILURE: + err_msg = "CL_MEM_OBJECT_ALLOCATION_FAILURE"; + break; + case CL_OUT_OF_RESOURCES: + err_msg = "CL_OUT_OF_RESOURCES"; + break; + case CL_OUT_OF_HOST_MEMORY: + err_msg = "CL_OUT_OF_HOST_MEMORY"; + break; + case CL_PROFILING_INFO_NOT_AVAILABLE: + err_msg = "CL_PROFILING_INFO_NOT_AVAILABLE"; + break; + case CL_MEM_COPY_OVERLAP: + err_msg = "CL_MEM_COPY_OVERLAP"; + break; + case CL_IMAGE_FORMAT_MISMATCH: + err_msg = "CL_IMAGE_FORMAT_MISMATCH"; + break; + case CL_IMAGE_FORMAT_NOT_SUPPORTED: + err_msg = "CL_IMAGE_FORMAT_NOT_SUPPORTED"; + break; + case CL_BUILD_PROGRAM_FAILURE: + err_msg = "CL_BUILD_PROGRAM_FAILURE"; + break; + case CL_MAP_FAILURE: + err_msg = "CL_MAP_FAILURE"; + break; + case CL_MISALIGNED_SUB_BUFFER_OFFSET: + err_msg = "CL_MISALIGNED_SUB_BUFFER_OFFSET"; + break; + case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: + err_msg = "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST"; + break; + case CL_COMPILE_PROGRAM_FAILURE: + err_msg = "CL_COMPILE_PROGRAM_FAILURE"; + break; + case CL_LINKER_NOT_AVAILABLE: + err_msg = "CL_LINKER_NOT_AVAILABLE"; + break; + case CL_LINK_PROGRAM_FAILURE: + err_msg = "CL_LINK_PROGRAM_FAILURE"; + break; + case CL_DEVICE_PARTITION_FAILED: + err_msg = "CL_DEVICE_PARTITION_FAILED"; + break; + case CL_KERNEL_ARG_INFO_NOT_AVAILABLE: + err_msg = "CL_KERNEL_ARG_INFO_NOT_AVAILABLE"; + break; + case CL_INVALID_VALUE: + err_msg = "CL_INVALID_VALUE"; + break; + case CL_INVALID_DEVICE_TYPE: + err_msg = "CL_INVALID_DEVICE_TYPE"; + break; + case CL_INVALID_PLATFORM: + err_msg = "CL_INVALID_PLATFORM"; + break; + case CL_INVALID_DEVICE: + err_msg = "CL_INVALID_DEVICE"; + break; + case CL_INVALID_CONTEXT: + err_msg = "CL_INVALID_CONTEXT"; + break; + case CL_INVALID_QUEUE_PROPERTIES: + err_msg = "CL_INVALID_QUEUE_PROPERTIES"; + break; + case CL_INVALID_COMMAND_QUEUE: + err_msg = "CL_INVALID_COMMAND_QUEUE"; + break; + case CL_INVALID_HOST_PTR: + err_msg = "CL_INVALID_HOST_PTR"; + break; + case CL_INVALID_MEM_OBJECT: + err_msg = "CL_INVALID_MEM_OBJECT"; + break; + case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: + err_msg = "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"; + break; + case CL_INVALID_IMAGE_SIZE: + err_msg = "CL_INVALID_IMAGE_SIZE"; + break; + case CL_INVALID_SAMPLER: + err_msg = "CL_INVALID_SAMPLER"; + break; + case CL_INVALID_BINARY: + err_msg = "CL_INVALID_BINARY"; + break; + case CL_INVALID_BUILD_OPTIONS: + err_msg = "CL_INVALID_BUILD_OPTIONS"; + break; + case CL_INVALID_PROGRAM: + err_msg = "CL_INVALID_PROGRAM"; + break; + case CL_INVALID_PROGRAM_EXECUTABLE: + err_msg = "CL_INVALID_PROGRAM_EXECUTABLE"; + break; + case CL_INVALID_KERNEL_NAME: + err_msg = "CL_INVALID_KERNEL_NAME"; + break; + case CL_INVALID_KERNEL_DEFINITION: + err_msg = "CL_INVALID_KERNEL_DEFINITION"; + break; + case CL_INVALID_KERNEL: + err_msg = "CL_INVALID_KERNEL"; + break; + case CL_INVALID_ARG_INDEX: + err_msg = "CL_INVALID_ARG_INDEX"; + break; + case CL_INVALID_ARG_VALUE: + err_msg = "CL_INVALID_ARG_VALUE"; + break; + case CL_INVALID_ARG_SIZE: + err_msg = "CL_INVALID_ARG_SIZE"; + break; + case CL_INVALID_KERNEL_ARGS: + err_msg = "CL_INVALID_KERNEL_ARGS"; + break; + case CL_INVALID_WORK_DIMENSION: + err_msg = "CL_INVALID_WORK_DIMENSION"; + break; + case CL_INVALID_WORK_GROUP_SIZE: + err_msg = "CL_INVALID_WORK_GROUP_SIZE"; + break; + case CL_INVALID_WORK_ITEM_SIZE: + err_msg = "CL_INVALID_WORK_ITEM_SIZE"; + break; + case CL_INVALID_GLOBAL_OFFSET: + err_msg = "CL_INVALID_GLOBAL_OFFSET"; + break; + case CL_INVALID_EVENT_WAIT_LIST: + err_msg = "CL_INVALID_EVENT_WAIT_LIST"; + break; + case CL_INVALID_EVENT: + err_msg = "CL_INVALID_EVENT"; + break; + case CL_INVALID_OPERATION: + err_msg = "CL_INVALID_OPERATION"; + break; + case CL_INVALID_GL_OBJECT: + err_msg = "CL_INVALID_GL_OBJECT"; + break; + case CL_INVALID_BUFFER_SIZE: + err_msg = "CL_INVALID_BUFFER_SIZE"; + break; + case CL_INVALID_MIP_LEVEL: + err_msg = "CL_INVALID_MIP_LEVEL"; + break; + case CL_INVALID_GLOBAL_WORK_SIZE: + err_msg = "CL_INVALID_GLOBAL_WORK_SIZE"; + break; + case CL_INVALID_PROPERTY: + err_msg = "CL_INVALID_PROPERTY"; + break; + case CL_INVALID_IMAGE_DESCRIPTOR: + err_msg = "CL_INVALID_IMAGE_DESCRIPTOR"; + break; + case CL_INVALID_COMPILER_OPTIONS: + err_msg = "CL_INVALID_COMPILER_OPTIONS"; + break; + case CL_INVALID_LINKER_OPTIONS: + err_msg = "CL_INVALID_LINKER_OPTIONS"; + break; + case CL_INVALID_DEVICE_PARTITION_COUNT: + err_msg = "CL_INVALID_DEVICE_PARTITION_COUNT"; + break; + case RayCaster::SHARING_NOT_SUPPORTED: + err_msg = "SHARING_NOT_SUPPORTED"; + break; + case RayCaster::OPENCL_NOT_SUPPORTED: + err_msg = "OPENCL_NOT_SUPPORTED"; + break; + case RayCaster::OPENCL_ERROR: + err_msg = "OPENCL_ERROR"; + break; + case RayCaster::ERROR: + err_msg = "ERROR"; + break; + } + + std::cout << err_msg << " =at= " << function_name << std::endl; + return true; +} \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index 1cf11e0..778c49c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -30,6 +30,7 @@ #include "Curses.h" #include "util.hpp" #include "RayCaster.h" +#include "Hardware_Caster.h" #include "CL_Wrapper.h" #include "Vector4.hpp" #include @@ -67,6 +68,7 @@ int main() { sf::RenderWindow window(sf::VideoMode(WINDOW_X, WINDOW_Y), "SFML"); + RayCaster rc = new Hardware_Caster() CL_Wrapper c; if (c.compile_kernel("../kernels/ray_caster_kernel.cl", true, "min_kern") < 0) {