mitchellhansen/voxel-raycaster
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Had some include troubles, renamed util but need to rename it back to .hpp. Switched the fps counter to run with imgui

Browse Source
This commit is contained in:
MitchellHansen
2017-03-16 23:47:05 -07:00
parent 394c9821fc
commit 15fb922c27
11 changed files with 324 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/Camera.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include <SFML/System/Vector3.hpp>
#include <SFML/System/Vector2.hpp>
#include "util.hpp"
#include "util.cpp"
#include "Pub_Sub.h"
class Camera : public VrEventSubscriber{

2
include/GL_Testing.h
View File

@@ -1,6 +1,6 @@
#pragma once
#include <string>
#include <util.hpp>
#include <util.cpp>
#include <cstring>
#ifdef _WIN32

2
include/LightController.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include <SFML/System/Vector3.hpp>
#include <SFML/System/Vector2.hpp>
#include "util.hpp"
#include "util.cpp"
#include "Pub_Sub.h"
#include "raycaster/RayCaster.h"
#include <list>

2
include/LightHandle.h
View File

@@ -1,6 +1,6 @@
#pragma once
#include <SFML/Graphics.hpp>
#include <util.hpp>
#include <util.cpp>
#include <memory>
#include "Pub_Sub.h"

2
include/Map.h
View File

@@ -8,7 +8,7 @@
#include <iostream>
#include <functional>
#include <cmath>
#include "util.hpp"
#include "util.cpp"
#include <deque>
#include <unordered_map>
#include <bitset>

5
include/raycaster/Hardware_Caster.h
View File

@@ -2,10 +2,9 @@
#include <raycaster/RayCaster.h>
#include <vector>
#include <iostream>
#include "util.hpp"
#include <map>
#include <string.h>
#include "LightController.h"
#ifdef linux
#include <CL/cl.h>
@@ -95,7 +94,7 @@ private:
void print_kernel_arguments();
bool assert(int error_code, std::string function_name);
bool vr_assert(int error_code, std::string function_name);
cl_device_id getDeviceID();
cl_platform_id getPlatformID();

622
include/util.hpp → include/util.cpp
View File

@@ -1,338 +1,286 @@
#pragma once
#include <SFML/Graphics.hpp>
#include "Vector4.hpp"
#include <math.h>
#include <bitset>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <iterator>
#include <list>
#include <algorithm>
const double PI = 3.141592653589793238463;
const float PI_F = 3.14159265358979f;
struct fps_counter {
public:
fps_counter() :
backdrop(sf::Vector2f(200, 100)), vertex_array(sf::LinesStrip) {
backdrop.setFillColor(sf::Color(0x0000003F));
if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
}
else {
t.setFont(f);
t.setCharacterSize(18);
t.setColor(sf::Color::White);
}
}
void frame(double delta_time) {
// Apply 100 units of smoothing
if (frame_count == 100) {
frame_count = 0;
fps_average = 0;
}
frame_count++;
fps_average += (delta_time - fps_average) / frame_count;
}
void flip_units() {
if (milliseconds)
milliseconds = false;
else
milliseconds = true;
}
void set_position(sf::Vector2f position) {
backdrop.setPosition(position);
}
sf::Vector2f get_position() {
return backdrop.getPosition();
}
void draw(sf::RenderWindow *r) {
// FPS Line graph
r->draw(backdrop);
if (vertex_position == 200)
vertex_position = 0;
sf::Vector2f origin = backdrop.getPosition();
sf::Vector2f point = origin + sf::Vector2f(vertex_position, backdrop.getSize().y - (1.0 / fps_average));
if (vertex_array.getVertexCount() < 200)
vertex_array.append(sf::Vertex(point, sf::Color::Red));
else
vertex_array[vertex_position] = sf::Vertex(point, sf::Color::Red);
r->draw(vertex_array);
vertex_position++;
// FPS Text
std::string out;
if (milliseconds)
out = std::to_string(fps_average);
else
out = std::to_string(floor(1 / fps_average));
t.setPosition(origin);
t.setString(out);
r->draw(t);
}
private:
sf::RectangleShape backdrop;
sf::VertexArray vertex_array;
sf::Font f;
sf::Text t;
int frame_count = 0;
double fps_average = 0;
bool milliseconds = false;
int vertex_position = 0;
};
struct debug_text {
public:
debug_text(int slot, int pixel_spacing, void* data_, std::string prefix_) : data(data_), prefix(prefix_) {
if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
}
else {
t.setFont(f);
t.setCharacterSize(20);
t.setPosition(static_cast<float>(20), static_cast<float>(slot * pixel_spacing));
}
}
void draw(sf::RenderWindow *r) {
t.setString(prefix + std::to_string(*(float*)data));
r->draw(t);
}
private:
void* data;
std::string prefix;
sf::Font f;
sf::Text t;
};
inline sf::Vector3f SphereToCart(sf::Vector2f i) {
auto r = sf::Vector3f(
(1 * sin(i.y) * cos(i.x)),
(1 * sin(i.y) * sin(i.x)),
(1 * cos(i.y))
);
return r;
};
inline sf::Vector3f SphereToCart(sf::Vector3f i) {
auto r = sf::Vector3f(
(i.x * sin(i.z) * cos(i.y)),
(i.x * sin(i.z) * sin(i.y)),
(i.x * cos(i.z))
);
return r;
};
inline sf::Vector3f CartToSphere(sf::Vector3f in) {
auto r = sf::Vector3f(
sqrt(in.x * in.x + in.y * in.y + in.z * in.z),
atan(in.y / in.x),
atan(sqrt(in.x * in.x + in.y * in.y) / in.z)
);
return r;
};
inline sf::Vector2f CartToNormalizedSphere(sf::Vector3f in) {
auto r = sf::Vector2f(
atan2(sqrt(in.x * in.x + in.y * in.y), in.z),
atan2(in.y, in.x)
);
return r;
}
inline sf::Vector3f FixOrigin(sf::Vector3f base, sf::Vector3f head) {
return head - base;
}
inline sf::Vector3f Normalize(sf::Vector3f in) {
float multiplier = sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
auto r = sf::Vector3f(
in.x / multiplier,
in.y / multiplier,
in.z / multiplier
);
return r;
}
inline float DotProduct(sf::Vector3f a, sf::Vector3f b){
return a.x * b.x + a.y * b.y + a.z * b.z;
}
inline float Magnitude(sf::Vector3f in){
return sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
}
inline float AngleBetweenVectors(sf::Vector3f a, sf::Vector3f b){
return acos(DotProduct(a, b) / (Magnitude(a) * Magnitude(b)));
}
inline float DistanceBetweenPoints(sf::Vector3f a, sf::Vector3f b) {
return sqrt(DotProduct(a, b));
}
inline float DegreesToRadians(float in) {
return static_cast<float>(in * PI / 180.0f);
}
inline float RadiansToDegrees(float in) {
return static_cast<float>(in * 180.0f / PI);
}
inline std::string read_file(std::string file_name){
std::ifstream input_file(file_name);
if (!input_file.is_open()){
std::cout << file_name << " could not be opened" << std::endl;
return "";
}
std::stringstream buf;
buf << input_file.rdbuf();
input_file.close();
return buf.str();
}
inline void PrettyPrintUINT64(uint64_t i, std::stringstream* ss) {
*ss << "[" << std::bitset<15>(i) << "]";
*ss << "[" << std::bitset<1>(i >> 15) << "]";
*ss << "[" << std::bitset<8>(i >> 16) << "]";
*ss << "[" << std::bitset<8>(i >> 24) << "]";
*ss << "[" << std::bitset<32>(i >> 32) << "]";
}
inline void PrettyPrintUINT64(uint64_t i) {
std::cout << "[" << std::bitset<15>(i) << "]";
std::cout << "[" << std::bitset<1>(i >> 15) << "]";
std::cout << "[" << std::bitset<8>(i >> 16) << "]";
std::cout << "[" << std::bitset<8>(i >> 24) << "]";
std::cout << "[" << std::bitset<32>(i >> 32) << "]" << std::endl;
}
inline void DumpLog(std::stringstream* ss, std::string file_name) {
std::ofstream log_file;
log_file.open(file_name);
log_file << ss->str();
log_file.close();
}
inline std::string sfml_get_input(sf::RenderWindow *window) {
std::stringstream ss;
sf::Event event;
while (window->pollEvent(event)) {
if (event.type == sf::Event::TextEntered) {
ss << event.text.unicode;
}
else if (event.type == sf::Event::KeyPressed) {
if (event.key.code == sf::Keyboard::Return) {
return ss.str();
}
}
}
}
inline std::vector<float> sfml_get_float_input(sf::RenderWindow *window) {
std::stringstream ss;
sf::Event event;
while (true) {
if (window->pollEvent(event)) {
if (event.type == sf::Event::TextEntered) {
if (event.text.unicode > 47 && event.text.unicode < 58 || event.text.unicode == 32)
ss << static_cast<char>(event.text.unicode);
}
else if (event.type == sf::Event::KeyPressed) {
if (event.key.code == sf::Keyboard::Return) {
break;
}
}
}
}
std::istream_iterator<std::string> begin(ss);
std::istream_iterator<std::string> end;
std::vector<std::string> vstrings(begin, end);
std::vector<float> ret;
for (auto i: vstrings) {
ret.push_back(std::stof(i));
}
return ret;
}
inline int count_bits(int32_t v) {
v = v - ((v >> 1) & 0x55555555); // reuse input as temporary
v = (v & 0x33333333) + ((v >> 2) & 0x33333333); // temp
return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; // count
}
inline int count_bits(int64_t v) {
int32_t left = (int32_t)(v);
int32_t right = (int32_t)(v >> 32);
left = left - ((left >> 1) & 0x55555555); // reuse input as temporary
left = (left & 0x33333333) + ((left >> 2) & 0x33333333); // temp
left = ((left + (left >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
right = right - ((right >> 1) & 0x55555555); // reuse input as temporary
right = (right & 0x33333333) + ((right >> 2) & 0x33333333); // temp
right = ((right + (right >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
return left + right;
#pragma once
#include <SFML/Graphics.hpp>
#include "Vector4.hpp"
#include <math.h>
#include <string.h>
#include <bitset>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <iterator>
#include <list>
#include <algorithm>
#include <imgui/imgui.h>
const double PI = 3.141592653589793238463;
const float PI_F = 3.14159265358979f;
struct fps_counter {
public:
fps_counter() {};
void frame(double delta_time) {
// Apply 100 units of smoothing
if (frame_count == 100) {
frame_count = 0;
fps_average = 0;
}
frame_count++;
fps_average += (delta_time - fps_average) / frame_count;
}
void draw() {
if (arr_pos == 200)
arr_pos = 0;
fps_array[arr_pos] = (1.0 / fps_average);
arr_pos++;
ImGui::Begin("Performance");
ImGui::PlotLines("FPS", fps_array, 200, 0, std::to_string(1.0 / fps_average).c_str(), 0.0f, 150.0f, ImVec2(0, 80));
ImGui::End();
}
private:
float fps_array[200]{60};
int arr_pos = 0;
int frame_count = 0;
double fps_average = 0;
};
struct debug_text {
public:
debug_text(int slot, int pixel_spacing, void* data_, std::string prefix_) : data(data_), prefix(prefix_) {
if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
}
else {
t.setFont(f);
t.setCharacterSize(20);
t.setPosition(static_cast<float>(20), static_cast<float>(slot * pixel_spacing));
}
}
void draw(sf::RenderWindow *r) {
t.setString(prefix + std::to_string(*(float*)data));
r->draw(t);
}
private:
void* data;
std::string prefix;
sf::Font f;
sf::Text t;
};
inline sf::Vector3f SphereToCart(sf::Vector2f i) {
auto r = sf::Vector3f(
(1 * sin(i.y) * cos(i.x)),
(1 * sin(i.y) * sin(i.x)),
(1 * cos(i.y))
);
return r;
};
inline sf::Vector3f SphereToCart(sf::Vector3f i) {
auto r = sf::Vector3f(
(i.x * sin(i.z) * cos(i.y)),
(i.x * sin(i.z) * sin(i.y)),
(i.x * cos(i.z))
);
return r;
};
inline sf::Vector3f CartToSphere(sf::Vector3f in) {
auto r = sf::Vector3f(
sqrt(in.x * in.x + in.y * in.y + in.z * in.z),
atan(in.y / in.x),
atan(sqrt(in.x * in.x + in.y * in.y) / in.z)
);
return r;
};
inline sf::Vector2f CartToNormalizedSphere(sf::Vector3f in) {
auto r = sf::Vector2f(
atan2(sqrt(in.x * in.x + in.y * in.y), in.z),
atan2(in.y, in.x)
);
return r;
}
inline sf::Vector3f FixOrigin(sf::Vector3f base, sf::Vector3f head) {
return head - base;
}
inline sf::Vector3f Normalize(sf::Vector3f in) {
float multiplier = sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
auto r = sf::Vector3f(
in.x / multiplier,
in.y / multiplier,
in.z / multiplier
);
return r;
}
inline float DotProduct(sf::Vector3f a, sf::Vector3f b){
return a.x * b.x + a.y * b.y + a.z * b.z;
}
inline float Magnitude(sf::Vector3f in){
return sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
}
inline float AngleBetweenVectors(sf::Vector3f a, sf::Vector3f b){
return acos(DotProduct(a, b) / (Magnitude(a) * Magnitude(b)));
}
inline float DistanceBetweenPoints(sf::Vector3f a, sf::Vector3f b) {
return sqrt(DotProduct(a, b));
}
inline float DegreesToRadians(float in) {
return static_cast<float>(in * PI / 180.0f);
}
inline float RadiansToDegrees(float in) {
return static_cast<float>(in * 180.0f / PI);
}
inline std::string read_file(std::string file_name){
std::ifstream input_file(file_name);
if (!input_file.is_open()){
std::cout << file_name << " could not be opened" << std::endl;
return "";
}
std::stringstream buf;
buf << input_file.rdbuf();
input_file.close();
return buf.str();
}
inline void PrettyPrintUINT64(uint64_t i, std::stringstream* ss) {
*ss << "[" << std::bitset<15>(i) << "]";
*ss << "[" << std::bitset<1>(i >> 15) << "]";
*ss << "[" << std::bitset<8>(i >> 16) << "]";
*ss << "[" << std::bitset<8>(i >> 24) << "]";
*ss << "[" << std::bitset<32>(i >> 32) << "]";
}
inline void PrettyPrintUINT64(uint64_t i) {
std::cout << "[" << std::bitset<15>(i) << "]";
std::cout << "[" << std::bitset<1>(i >> 15) << "]";
std::cout << "[" << std::bitset<8>(i >> 16) << "]";
std::cout << "[" << std::bitset<8>(i >> 24) << "]";
std::cout << "[" << std::bitset<32>(i >> 32) << "]" << std::endl;
}
inline void DumpLog(std::stringstream* ss, std::string file_name) {
std::ofstream log_file;
log_file.open(file_name);
log_file << ss->str();
log_file.close();
}
inline std::string sfml_get_input(sf::RenderWindow *window) {
std::stringstream ss;
sf::Event event;
while (window->pollEvent(event)) {
if (event.type == sf::Event::TextEntered) {
ss << event.text.unicode;
}
else if (event.type == sf::Event::KeyPressed) {
if (event.key.code == sf::Keyboard::Return) {
return ss.str();
}
}
}
}
inline std::vector<float> sfml_get_float_input(sf::RenderWindow *window) {
std::stringstream ss;
sf::Event event;
while (true) {
if (window->pollEvent(event)) {
if (event.type == sf::Event::TextEntered) {
if (event.text.unicode > 47 && event.text.unicode < 58 || event.text.unicode == 32)
ss << static_cast<char>(event.text.unicode);
}
else if (event.type == sf::Event::KeyPressed) {
if (event.key.code == sf::Keyboard::Return) {
break;
}
}
}
}
std::istream_iterator<std::string> begin(ss);
std::istream_iterator<std::string> end;
std::vector<std::string> vstrings(begin, end);
std::vector<float> ret;
for (auto i: vstrings) {
ret.push_back(std::stof(i));
}
return ret;
}
inline int count_bits(int32_t v) {
v = v - ((v >> 1) & 0x55555555); // reuse input as temporary
v = (v & 0x33333333) + ((v >> 2) & 0x33333333); // temp
return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; // count
}
inline int count_bits(int64_t v) {
int32_t left = (int32_t)(v);
int32_t right = (int32_t)(v >> 32);
left = left - ((left >> 1) & 0x55555555); // reuse input as temporary
left = (left & 0x33333333) + ((left >> 2) & 0x33333333); // temp
left = ((left + (left >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
right = right - ((right >> 1) & 0x55555555); // reuse input as temporary
right = (right & 0x33333333) + ((right >> 2) & 0x33333333); // temp
right = ((right + (right >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
return left + right;
}

2
src/Old_Map.cpp
View File

@@ -1,7 +1,7 @@
#include <iostream>
#include <SFML/System/Vector3.hpp>
#include <SFML/System/Vector2.hpp>
#include "util.hpp"
#include "util.cpp"
#include <Old_Map.h>
#include <algorithm>

2
src/Ray.cpp
View File

@@ -2,7 +2,7 @@
#include <iostream>
#include "Map.h"
#include <Ray.h>
#include "util.hpp"
#include "util.cpp"
Ray::Ray(
Map *map,

41
src/main.cpp
View File

@@ -23,12 +23,12 @@
#endif
#pragma once
#include "util.cpp"
#include <iostream>
#include <chrono>
#include <SFML/Graphics.hpp>
#include <SFML/Network.hpp>
#include "Old_Map.h"
#include "util.hpp"
#include "raycaster/RayCaster.h"
#include "raycaster/Hardware_Caster.h"
#include "Vector4.hpp"
@@ -41,6 +41,7 @@
#include "imgui/imgui-SFML.h"
#include "imgui/imgui.h"
const int WINDOW_X = 1440;
const int WINDOW_Y = 900;
const int WORK_SIZE = WINDOW_X * WINDOW_Y;
@@ -236,48 +237,23 @@ int main() {
// ==== DELTA TIME LOCKED ====
}
// ==== FPS LOCKED ====
ImGui::SFML::Update(window, sf_delta_clock.restart());
ImGui::Begin("Sample window"); // begi
ImGui::InputText("Window title", "asdfoij", 255);
float values[] = { 0, 1, 2, 3, 4, 5 };
ImGui::PlotLines("graph", values, 6);
if (ImGui::Button("Print")) {
std::cout << "print" << std::endl;
}
ImGui::End(); // end window
// ==== FPS LOCKED ====
camera->update(delta_time);
handle->update(delta_time);
window.clear(sf::Color::Black);
// Run the raycast
raycaster->compute();
window.clear(sf::Color::Black);
raycaster->draw(&window);
ImGui::Render();
//window.popGLStates();
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
//t.rotate(delta_time);
//t.transform();
//t.draw();
//glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//window.pushGLStates();
// Give the frame counter the frame time and draw the average frame time
fps.frame(delta_time);
fps.draw(&window);
fps.draw();
cam_text_x.draw(&window);
cam_text_y.draw(&window);
@@ -286,6 +262,7 @@ int main() {
cam_text_pos_y.draw(&window);
cam_text_pos_z.draw(&window);
ImGui::Render();
window.display();
}

44
src/raycaster/Hardware_Caster.cpp
View File

@@ -1,6 +1,4 @@
#include "raycaster/Hardware_Caster.h"
#include <raycaster/RayCaster.h>
#include "LightController.h"
Hardware_Caster::Hardware_Caster() {
@@ -15,23 +13,23 @@ int Hardware_Caster::init() {
// Initialize opencl up to the point where we start assigning buffers
error = acquire_platform_and_device();
if(assert(error, "aquire_platform_and_device"))
if(vr_assert(error, "aquire_platform_and_device"))
return error;
error = check_cl_khr_gl_sharing();
if(assert(error, "check_cl_khr_gl_sharing"))
if(vr_assert(error, "check_cl_khr_gl_sharing"))
return error;
error = create_shared_context();
if (assert(error, "create_shared_context"))
if (vr_assert(error, "create_shared_context"))
return error;
error = create_command_queue();
if (assert(error, "create_command_queue"))
if (vr_assert(error, "create_command_queue"))
return error;
error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "raycaster");
if (assert(error, "compile_kernel")) {
if (vr_assert(error, "compile_kernel")) {
std::cin.get(); // hang the output window so we can read the error
return error;
}
@@ -216,7 +214,7 @@ void Hardware_Caster::draw(sf::RenderWindow* window) {
int Hardware_Caster::debug_quick_recompile()
{
int error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "raycaster");
if (assert(error, "compile_kernel")) {
if (vr_assert(error, "compile_kernel")) {
std::cin.get(); // hang the output window so we can read the error
return error;
}
@@ -306,7 +304,7 @@ int Hardware_Caster::acquire_platform_and_device() {
std::vector<cl_device_id> deviceIds(deviceIdCount);
error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL);
if (assert(error, "clGetDeviceIDs"))
if (vr_assert(error, "clGetDeviceIDs"))
return OPENCL_ERROR;
for (unsigned int q = 0; q < deviceIdCount; q++) {
@@ -409,7 +407,7 @@ int Hardware_Caster::create_shared_context() {
&error
);
if (assert(error, "clCreateContext"))
if (vr_assert(error, "clCreateContext"))
return OPENCL_ERROR;
return 1;
@@ -422,7 +420,7 @@ int Hardware_Caster::create_command_queue() {
command_queue = clCreateCommandQueue(context, device_id, 0, &error);
if (assert(error, "clCreateCommandQueue"))
if (vr_assert(error, "clCreateCommandQueue"))
return OPENCL_ERROR;
return 1;
@@ -477,7 +475,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
);
// This is not for compilation, it only loads the source
if (assert(error, "clCreateProgramWithSource"))
if (vr_assert(error, "clCreateProgramWithSource"))
return OPENCL_ERROR;
@@ -485,7 +483,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
error = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
// Check to see if it errored out
if (assert(error, "clBuildProgram")) {
if (vr_assert(error, "clBuildProgram")) {
// Get the size of the queued log
size_t log_size;
@@ -502,7 +500,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
// Done initializing the kernel
cl_kernel kernel = clCreateKernel(program, kernel_name.c_str(), &error);
if (assert(error, "clCreateKernel"))
if (vr_assert(error, "clCreateKernel"))
return OPENCL_ERROR;
// Do I want these to overlap when repeated??
@@ -523,7 +521,7 @@ int Hardware_Caster::set_kernel_arg(
sizeof(cl_mem),
(void *)&buffer_map.at(buffer_name));
if (assert(error, "clSetKernelArg")){
if (vr_assert(error, "clSetKernelArg")){
std::cout << buffer_name << std::endl;
std::cout << buffer_map.at(buffer_name) << std::endl;
return OPENCL_ERROR;
@@ -545,7 +543,7 @@ int Hardware_Caster::create_image_buffer(std::string buffer_name, cl_uint size,
getContext(), access_type, GL_TEXTURE_2D,
0, texture->getNativeHandle(), &error);
if (assert(error, "clCreateFromGLTexture"))
if (vr_assert(error, "clCreateFromGLTexture"))
return OPENCL_ERROR;
store_buffer(buff, buffer_name);
@@ -566,7 +564,7 @@ int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void*
size, data, &error
);
if (assert(error, "clCreateBuffer"))
if (vr_assert(error, "clCreateBuffer"))
return OPENCL_ERROR;
store_buffer(buff, buffer_name);
@@ -588,7 +586,7 @@ int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void*
size, data, &error
);
if (assert(error, "clCreateBuffer"))
if (vr_assert(error, "clCreateBuffer"))
return OPENCL_ERROR;
store_buffer(buff, buffer_name);
@@ -603,7 +601,7 @@ int Hardware_Caster::release_buffer(std::string buffer_name) {
int error = clReleaseMemObject(buffer_map.at(buffer_name));
if (assert(error, "clReleaseMemObject")) {
if (vr_assert(error, "clReleaseMemObject")) {
std::cout << "Error releasing buffer : " << buffer_name;
std::cout << "Buffer not removed";
return -1;
@@ -634,7 +632,7 @@ int Hardware_Caster::run_kernel(std::string kernel_name, const int work_size) {
cl_kernel kernel = kernel_map.at(kernel_name);
error = clEnqueueAcquireGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, 0, 0);
if (assert(error, "clEnqueueAcquireGLObjects"))
if (vr_assert(error, "clEnqueueAcquireGLObjects"))
return OPENCL_ERROR;
//error = clEnqueueTask(command_queue, kernel, 0, NULL, NULL);
@@ -643,14 +641,14 @@ int Hardware_Caster::run_kernel(std::string kernel_name, const int work_size) {
1, NULL, global_work_size,
NULL, 0, NULL, NULL);
if (assert(error, "clEnqueueNDRangeKernel"))
if (vr_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"), 0, NULL, NULL);
if (assert(error, "clEnqueueReleaseGLObjects"))
if (vr_assert(error, "clEnqueueReleaseGLObjects"))
return OPENCL_ERROR;
return 1;
@@ -678,7 +676,7 @@ 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::assert(int error_code, std::string function_name) {
bool Hardware_Caster::vr_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 : ";