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

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

@ -2,6 +2,7 @@
#include <SFML/Graphics.hpp> #include <SFML/Graphics.hpp>
#include "Vector4.hpp" #include "Vector4.hpp"
#include <math.h> #include <math.h>
#include <string.h>
#include <bitset> #include <bitset>
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
@ -10,26 +11,13 @@
#include <iterator> #include <iterator>
#include <list> #include <list>
#include <algorithm> #include <algorithm>
#include <imgui/imgui.h>
const double PI = 3.141592653589793238463; const double PI = 3.141592653589793238463;
const float PI_F = 3.14159265358979f; const float PI_F = 3.14159265358979f;
struct fps_counter { struct fps_counter {
public: public:
fps_counter() : 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) { void frame(double delta_time) {
// Apply 100 units of smoothing // Apply 100 units of smoothing
@ -41,67 +29,27 @@ public:
fps_average += (delta_time - fps_average) / frame_count; fps_average += (delta_time - fps_average) / frame_count;
} }
void flip_units() { void draw() {
if (milliseconds)
milliseconds = false;
else
milliseconds = true;
}
void set_position(sf::Vector2f position) { if (arr_pos == 200)
backdrop.setPosition(position); arr_pos = 0;
}
sf::Vector2f get_position() { fps_array[arr_pos] = (1.0 / fps_average);
return backdrop.getPosition(); arr_pos++;
}
void draw(sf::RenderWindow *r) { 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));
// FPS Line graph ImGui::End();
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: private:
sf::RectangleShape backdrop; float fps_array[200]{60};
sf::VertexArray vertex_array; int arr_pos = 0;
sf::Font f;
sf::Text t;
int frame_count = 0; int frame_count = 0;
double fps_average = 0; double fps_average = 0;
bool milliseconds = false;
int vertex_position = 0;
}; };
struct debug_text { struct debug_text {

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();
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); window.clear(sf::Color::Black);
//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 // 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