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
master
MitchellHansen 8 years ago
parent 394c9821fc
commit 15fb922c27
11 changed files with 322 additions and 400 deletions
Show Stats Download Patch File Download Diff File

2
include/Camera.h
Unescape View File

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

2
include/GL_Testing.h
Unescape View File

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

2
include/LightController.h
Unescape View File

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

2
include/LightHandle.h
Unescape View File

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

2
include/Map.h
Unescape View File

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

5
include/raycaster/Hardware_Caster.h
Unescape View File

@ -2,10 +2,9 @@
#include <raycaster/RayCaster.h> #include <raycaster/RayCaster.h>
#include <vector> #include <vector>
#include <iostream> #include <iostream>
#include "util.hpp"
#include <map> #include <map>
#include <string.h> #include <string.h>
#include "LightController.h"
#ifdef linux #ifdef linux
#include <CL/cl.h> #include <CL/cl.h>
@ -95,7 +94,7 @@ private:
void print_kernel_arguments(); 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_device_id getDeviceID();
cl_platform_id getPlatformID(); cl_platform_id getPlatformID();

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

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

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

2
src/Ray.cpp
Unescape View File

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

37
src/main.cpp
Unescape View File

@ -23,12 +23,12 @@
#endif #endif
#pragma once #pragma once
#include "util.cpp"
#include <iostream> #include <iostream>
#include <chrono> #include <chrono>
#include <SFML/Graphics.hpp> #include <SFML/Graphics.hpp>
#include <SFML/Network.hpp> #include <SFML/Network.hpp>
#include "Old_Map.h" #include "Old_Map.h"
#include "util.hpp"
#include "raycaster/RayCaster.h" #include "raycaster/RayCaster.h"
#include "raycaster/Hardware_Caster.h" #include "raycaster/Hardware_Caster.h"
#include "Vector4.hpp" #include "Vector4.hpp"
@ -41,6 +41,7 @@
#include "imgui/imgui-SFML.h" #include "imgui/imgui-SFML.h"
#include "imgui/imgui.h" #include "imgui/imgui.h"
const int WINDOW_X = 1440; const int WINDOW_X = 1440;
const int WINDOW_Y = 900; const int WINDOW_Y = 900;
const int WORK_SIZE = WINDOW_X * WINDOW_Y; const int WORK_SIZE = WINDOW_X * WINDOW_Y;
@ -236,48 +237,23 @@ int main() {
// ==== DELTA TIME LOCKED ==== // ==== DELTA TIME LOCKED ====
} }
// ==== FPS LOCKED ====
ImGui::SFML::Update(window, sf_delta_clock.restart()); 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); camera->update(delta_time);
handle->update(delta_time); handle->update(delta_time);
window.clear(sf::Color::Black);
// Run the raycast // Run the raycast
raycaster->compute(); raycaster->compute();
raycaster->draw(&window);
ImGui::Render();
//window.popGLStates(); window.clear(sf::Color::Black);
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); raycaster->draw(&window);
//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 // Give the frame counter the frame time and draw the average frame time
fps.frame(delta_time); fps.frame(delta_time);
fps.draw(&window); fps.draw();
cam_text_x.draw(&window); cam_text_x.draw(&window);
cam_text_y.draw(&window); cam_text_y.draw(&window);
@ -286,6 +262,7 @@ int main() {
cam_text_pos_y.draw(&window); cam_text_pos_y.draw(&window);
cam_text_pos_z.draw(&window); cam_text_pos_z.draw(&window);
ImGui::Render();
window.display(); window.display();
} }

44
src/raycaster/Hardware_Caster.cpp
Unescape View File

@ -1,6 +1,4 @@
#include "raycaster/Hardware_Caster.h" #include "raycaster/Hardware_Caster.h"
#include <raycaster/RayCaster.h>
#include "LightController.h"
Hardware_Caster::Hardware_Caster() { Hardware_Caster::Hardware_Caster() {
@ -15,23 +13,23 @@ int Hardware_Caster::init() {
// Initialize opencl up to the point where we start assigning buffers // Initialize opencl up to the point where we start assigning buffers
error = acquire_platform_and_device(); error = acquire_platform_and_device();
if(assert(error, "aquire_platform_and_device")) if(vr_assert(error, "aquire_platform_and_device"))
return error; return error;
error = check_cl_khr_gl_sharing(); 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; return error;
error = create_shared_context(); error = create_shared_context();
if (assert(error, "create_shared_context")) if (vr_assert(error, "create_shared_context"))
return error; return error;
error = create_command_queue(); error = create_command_queue();
if (assert(error, "create_command_queue")) if (vr_assert(error, "create_command_queue"))
return error; return error;
error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "raycaster"); 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 std::cin.get(); // hang the output window so we can read the error
return error; return error;
} }
@ -216,7 +214,7 @@ void Hardware_Caster::draw(sf::RenderWindow* window) {
int Hardware_Caster::debug_quick_recompile() int Hardware_Caster::debug_quick_recompile()
{ {
int error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "raycaster"); 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 std::cin.get(); // hang the output window so we can read the error
return error; return error;
} }
@ -306,7 +304,7 @@ int Hardware_Caster::acquire_platform_and_device() {
std::vector<cl_device_id> deviceIds(deviceIdCount); std::vector<cl_device_id> deviceIds(deviceIdCount);
error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL); 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; return OPENCL_ERROR;
for (unsigned int q = 0; q < deviceIdCount; q++) { for (unsigned int q = 0; q < deviceIdCount; q++) {
@ -409,7 +407,7 @@ int Hardware_Caster::create_shared_context() {
&error &error
); );
if (assert(error, "clCreateContext")) if (vr_assert(error, "clCreateContext"))
return OPENCL_ERROR; return OPENCL_ERROR;
return 1; return 1;
@ -422,7 +420,7 @@ int Hardware_Caster::create_command_queue() {
command_queue = clCreateCommandQueue(context, device_id, 0, &error); command_queue = clCreateCommandQueue(context, device_id, 0, &error);
if (assert(error, "clCreateCommandQueue")) if (vr_assert(error, "clCreateCommandQueue"))
return OPENCL_ERROR; return OPENCL_ERROR;
return 1; 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 // This is not for compilation, it only loads the source
if (assert(error, "clCreateProgramWithSource")) if (vr_assert(error, "clCreateProgramWithSource"))
return OPENCL_ERROR; 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); error = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
// Check to see if it errored out // Check to see if it errored out
if (assert(error, "clBuildProgram")) { if (vr_assert(error, "clBuildProgram")) {
// Get the size of the queued log // Get the size of the queued log
size_t log_size; 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 // Done initializing the kernel
cl_kernel kernel = clCreateKernel(program, kernel_name.c_str(), &error); cl_kernel kernel = clCreateKernel(program, kernel_name.c_str(), &error);
if (assert(error, "clCreateKernel")) if (vr_assert(error, "clCreateKernel"))
return OPENCL_ERROR; return OPENCL_ERROR;
// Do I want these to overlap when repeated?? // Do I want these to overlap when repeated??
@ -523,7 +521,7 @@ int Hardware_Caster::set_kernel_arg(
sizeof(cl_mem), sizeof(cl_mem),
(void *)&buffer_map.at(buffer_name)); (void *)&buffer_map.at(buffer_name));
if (assert(error, "clSetKernelArg")){ if (vr_assert(error, "clSetKernelArg")){
std::cout << buffer_name << std::endl; std::cout << buffer_name << std::endl;
std::cout << buffer_map.at(buffer_name) << std::endl; std::cout << buffer_map.at(buffer_name) << std::endl;
return OPENCL_ERROR; 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, getContext(), access_type, GL_TEXTURE_2D,
0, texture->getNativeHandle(), &error); 0, texture->getNativeHandle(), &error);
if (assert(error, "clCreateFromGLTexture")) if (vr_assert(error, "clCreateFromGLTexture"))
return OPENCL_ERROR; return OPENCL_ERROR;
store_buffer(buff, buffer_name); 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 size, data, &error
); );
if (assert(error, "clCreateBuffer")) if (vr_assert(error, "clCreateBuffer"))
return OPENCL_ERROR; return OPENCL_ERROR;
store_buffer(buff, buffer_name); 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 size, data, &error
); );
if (assert(error, "clCreateBuffer")) if (vr_assert(error, "clCreateBuffer"))
return OPENCL_ERROR; return OPENCL_ERROR;
store_buffer(buff, buffer_name); 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)); 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 << "Error releasing buffer : " << buffer_name;
std::cout << "Buffer not removed"; std::cout << "Buffer not removed";
return -1; 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); cl_kernel kernel = kernel_map.at(kernel_name);
error = clEnqueueAcquireGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, 0, 0); error = clEnqueueAcquireGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, 0, 0);
if (assert(error, "clEnqueueAcquireGLObjects")) if (vr_assert(error, "clEnqueueAcquireGLObjects"))
return OPENCL_ERROR; return OPENCL_ERROR;
//error = clEnqueueTask(command_queue, kernel, 0, NULL, NULL); //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, 1, NULL, global_work_size,
NULL, 0, NULL, NULL); NULL, 0, NULL, NULL);
if (assert(error, "clEnqueueNDRangeKernel")) if (vr_assert(error, "clEnqueueNDRangeKernel"))
return OPENCL_ERROR; return OPENCL_ERROR;
clFinish(getCommandQueue()); clFinish(getCommandQueue());
// What if errors out and gl objects are never released? // What if errors out and gl objects are never released?
error = clEnqueueReleaseGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, NULL, NULL); error = clEnqueueReleaseGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, NULL, NULL);
if (assert(error, "clEnqueueReleaseGLObjects")) if (vr_assert(error, "clEnqueueReleaseGLObjects"))
return OPENCL_ERROR; return OPENCL_ERROR;
return 1; 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_kernel Hardware_Caster::getKernel(std::string kernel_name) { return kernel_map.at(kernel_name); };
cl_command_queue Hardware_Caster::getCommandQueue() { return command_queue; }; 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 // Just gonna do a little jump table here, just error codes so who cares
std::string err_msg = "Error : "; std::string err_msg = "Error : ";

Write Preview
Loading…
Cancel
Save