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

master
MitchellHansen 8 years ago
parent 394c9821fc
commit 15fb922c27

@ -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{

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

@ -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>

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

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

@ -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();

@ -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;
}

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

@ -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();
raycaster->draw(&window);
ImGui::Render();
//window.popGLStates();
window.clear(sf::Color::Black);
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
//t.rotate(delta_time);
//t.transform();
//t.draw();
//glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//window.pushGLStates();
raycaster->draw(&window);
// 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();
}

@ -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 : ";

Loading…
Cancel
Save