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

Commit might have been messed up

Browse Source
master
MitchellHansen 8 years ago
parent 8806777dc9
commit 334a375535
13 changed files with 483 additions and 238 deletions
Show Stats Download Patch File Download Diff File

2
include/Camera.h
Unescape View File

@ -37,7 +37,7 @@ public:
void setSpeed(float speed);
float getSpeed();
void recieve_event(VrEventPublisher* p, std::unique_ptr<vr::Event> event) override;
void recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event> event) override;
private:

161
include/Event.hpp
Unescape View File

@ -4,7 +4,7 @@
#include <SFML/Window/Mouse.hpp>
#include <SFML/Window/Joystick.hpp>
#include <SFML/Window/Sensor.hpp>
#include <memory>
namespace vr {
@ -14,11 +14,11 @@ namespace vr {
// the ability to easily extend the class to contain
// even more event types.
// A result of getting rid of the union and extracting
// An annoying result of getting rid of the union and extracting
// event types into individual classes is the fact that
// there is going to be a lot of repeat code i.e
// KeyPressed, KeyHeld, and KeyReleased all hold the same
// data, it's just their names that are different
// data, it's just their names that are different.
class Event {
public:
@ -63,20 +63,33 @@ namespace vr {
Event(EventType type) : type(type) {
};
virtual ~Event() {};
virtual std::unique_ptr<Event> clone() = 0;
EventType type;
private:
};
class Closed : public Event {
public:
Closed() : Event(vr::Event::EventType::Closed) {};
~Closed() override {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::Closed>(vr::Closed()));
};
};
class Resized : public Event {
public:
Resized(unsigned int width, unsigned int height) :
width(width), height(height), Event(vr::Event::EventType::Resized) {};
Event(vr::Event::EventType::Resized), width(width), height(height) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::Resized>(vr::Resized(width, height)));
};
unsigned int width;
unsigned int height;
};
@ -84,16 +97,25 @@ namespace vr {
class LostFocus : public Event {
public:
LostFocus() : Event(vr::Event::EventType::LostFocus) { };
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::LostFocus>(vr::LostFocus()));
};
};
class GainedFocus : public Event {
public:
GainedFocus() : Event(vr::Event::EventType::GainedFocus) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::GainedFocus>(vr::GainedFocus()));
};
};
class TextEntered : public Event {
public:
TextEntered(sf::Uint32 unicode) :
unicode(unicode), Event(vr::Event::EventType::TextEntered) {};
Event(vr::Event::EventType::TextEntered), unicode(unicode) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::TextEntered>(vr::TextEntered(unicode)));
};
sf::Uint32 unicode;
};
@ -101,7 +123,10 @@ namespace vr {
class KeyPressed : public Event {
public:
KeyPressed(sf::Keyboard::Key code, bool alt, bool control, bool shift, bool system ) :
code(code), alt(alt), control(control), shift(shift), system(system), Event(vr::Event::EventType::KeyPressed) {};
Event(vr::Event::EventType::KeyPressed), code(code), alt(alt), control(control), shift(shift), system(system) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::KeyPressed>(vr::KeyPressed(code, alt, control, shift, system)));
};
sf::Keyboard::Key code;
bool alt;
@ -113,7 +138,10 @@ namespace vr {
class KeyHeld : public Event {
public:
KeyHeld(sf::Keyboard::Key code, bool alt, bool control, bool shift, bool system) :
code(code), alt(alt), control(control), shift(shift), system(system), Event(vr::Event::EventType::KeyHeld) {};
Event(vr::Event::EventType::KeyHeld), code(code), alt(alt), control(control), shift(shift), system(system) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::KeyHeld>(vr::KeyHeld(code, alt, control, shift, system)));
};
sf::Keyboard::Key code;
bool alt;
@ -125,7 +153,10 @@ namespace vr {
class KeyReleased : public Event {
public:
KeyReleased(sf::Keyboard::Key code, bool alt, bool control, bool shift, bool system) :
code(code), alt(alt), control(control), shift(shift), system(system), Event(vr::Event::EventType::KeyReleased) {};
Event(vr::Event::EventType::KeyReleased), code(code), alt(alt), control(control), shift(shift), system(system) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::KeyReleased>(vr::KeyReleased(code, alt, control, shift, system)));
};
sf::Keyboard::Key code;
bool alt;
@ -138,12 +169,18 @@ namespace vr {
class MouseWheelMoved : public Event {
public:
MouseWheelMoved() : Event(vr::Event::EventType::MouseWheelMoved) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseWheelMoved>(vr::MouseWheelMoved()));
};
};
class MouseWheelScrolled : public Event {
public:
MouseWheelScrolled(sf::Mouse::Wheel wheel, float delta, int x, int y) :
wheel(wheel), delta(delta), x(x), y(y), Event(vr::Event::EventType::MouseWheelScrolled) {};
Event(vr::Event::EventType::MouseWheelScrolled), wheel(wheel), delta(delta), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(wheel, delta, x, y)));
};
sf::Mouse::Wheel wheel;
float delta;
@ -154,7 +191,10 @@ namespace vr {
class MouseButtonPressed : public Event {
public:
MouseButtonPressed(sf::Mouse::Button button, int x, int y) :
button(button), x(x), y(y), Event(vr::Event::EventType::MouseButtonPressed) {};
Event(vr::Event::EventType::MouseButtonPressed), button(button), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseButtonPressed>(vr::MouseButtonPressed(button, x ,y)));
};
sf::Mouse::Button button;
int x;
@ -164,7 +204,10 @@ namespace vr {
class MouseButtonHeld : public Event {
public:
MouseButtonHeld(sf::Mouse::Button button, int x, int y) :
button(button), x(x), y(y), Event(vr::Event::EventType::MouseButtonHeld) {};
Event(vr::Event::EventType::MouseButtonHeld), button(button), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseButtonHeld>(vr::MouseButtonHeld(button, x, y)));
};
sf::Mouse::Button button;
int x;
@ -174,7 +217,10 @@ namespace vr {
class MouseButtonReleased : public Event {
public:
MouseButtonReleased(sf::Mouse::Button button, int x, int y) :
button(button), x(x), y(y), Event(vr::Event::EventType::MouseButtonReleased) {};
Event(vr::Event::EventType::MouseButtonReleased), button(button), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseButtonReleased>(vr::MouseButtonReleased(button, x, y)));
};
sf::Mouse::Button button;
int x;
@ -184,7 +230,10 @@ namespace vr {
class MouseMoved : public Event {
public:
MouseMoved(int x, int y) :
x(x), y(y), Event(vr::Event::EventType::MouseMoved) {};
Event(vr::Event::EventType::MouseMoved), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseMoved>(vr::MouseMoved(x, y)));
};
int x;
int y;
@ -193,7 +242,10 @@ namespace vr {
class MouseEntered : public Event {
public:
MouseEntered(int x, int y) :
x(x), y(y), Event(vr::Event::EventType::MouseEntered) {};
Event(vr::Event::EventType::MouseEntered), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseEntered>(vr::MouseEntered(x, y)));
};
int x;
int y;
@ -202,7 +254,10 @@ namespace vr {
class MouseLeft : public Event {
public:
MouseLeft(int x, int y) :
x(x), y(y), Event(vr::Event::EventType::MouseLeft) {};
Event(vr::Event::EventType::MouseLeft), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::MouseLeft>(vr::MouseLeft(x, y)));
};
int x;
int y;
@ -211,7 +266,10 @@ namespace vr {
class JoystickButtonPressed : public Event {
public:
JoystickButtonPressed(unsigned int joystickId, unsigned int button) :
joystickId(joystickId), button(button), Event(vr::Event::EventType::JoystickButtonPressed) {};
Event(vr::Event::EventType::JoystickButtonPressed), joystickId(joystickId), button(button) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickButtonPressed>(vr::JoystickButtonPressed(joystickId, button)));
};
unsigned int joystickId;
unsigned int button;
@ -220,7 +278,10 @@ namespace vr {
class JoystickButtonHeld : public Event {
public:
JoystickButtonHeld(unsigned int joystickId, unsigned int button) :
joystickId(joystickId), button(button), Event(vr::Event::EventType::JoystickButtonHeld) {};
Event(vr::Event::EventType::JoystickButtonHeld), joystickId(joystickId), button(button) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickButtonHeld>(vr::JoystickButtonHeld(joystickId, button)));
};
unsigned int joystickId;
unsigned int button;
@ -230,6 +291,9 @@ namespace vr {
public:
JoystickButtonReleased(unsigned int joystickId, unsigned int button) :
joystickId(joystickId), button(button), Event(vr::Event::EventType::JoystickButtonReleased) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickButtonReleased>(vr::JoystickButtonReleased(joystickId, button)));
};
unsigned int joystickId;
unsigned int button;
@ -239,6 +303,9 @@ namespace vr {
public:
JoystickMoved(sf::Joystick::Axis axis, unsigned int joystickId, float position) :
axis(axis), joystickId(joystickId), position(position), Event(vr::Event::EventType::JoystickMoved) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickMoved>(vr::JoystickMoved(axis, joystickId, position)));
};
sf::Joystick::Axis axis;
unsigned int joystickId;
@ -248,7 +315,10 @@ namespace vr {
class JoystickConnected : public Event {
public:
JoystickConnected(unsigned int joystickId) :
joystickId(joystickId), Event(vr::Event::EventType::JoystickConnected) {};
Event(vr::Event::EventType::JoystickConnected), joystickId(joystickId) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickConnected>(vr::JoystickConnected(joystickId)));
};
unsigned int joystickId;
};
@ -256,7 +326,10 @@ namespace vr {
class JoystickDisconnected : public Event {
public:
JoystickDisconnected(unsigned int joystickId) :
joystickId(joystickId), Event(vr::Event::EventType::JoystickDisconnected) {};
Event(vr::Event::EventType::JoystickDisconnected), joystickId(joystickId) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::JoystickDisconnected>(vr::JoystickDisconnected(joystickId)));
};
unsigned int joystickId;
};
@ -264,7 +337,10 @@ namespace vr {
class TouchBegan : public Event {
public:
TouchBegan(unsigned int finger, int x, int y) :
finger(finger), x(x), y(y), Event(vr::Event::EventType::TouchBegan) {};
Event(vr::Event::EventType::TouchBegan), finger(finger), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::TouchBegan>(vr::TouchBegan(finger, x, y)));
};
unsigned int finger;
int x;
@ -274,7 +350,10 @@ namespace vr {
class TouchMoved : public Event {
public:
TouchMoved(unsigned int finger, int x, int y) :
finger(finger), x(x), y(y), Event(vr::Event::EventType::TouchMoved) {};
Event(vr::Event::EventType::TouchMoved), finger(finger), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::TouchMoved>(vr::TouchMoved(finger, x, y)));
};
unsigned int finger;
int x;
@ -284,7 +363,10 @@ namespace vr {
class TouchEnded : public Event {
public:
TouchEnded(unsigned int finger, int x, int y) :
finger(finger), x(x), y(y), Event(vr::Event::EventType::TouchEnded) {};
Event(vr::Event::EventType::TouchEnded), finger(finger), x(x), y(y) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::TouchEnded>(vr::TouchEnded(finger, x, y)));
};
unsigned int finger;
int x;
@ -294,7 +376,10 @@ namespace vr {
class SensorChanged : public Event {
public:
SensorChanged(sf::Sensor::Type type, float x, float y, float z) :
type(type), x(x), y(y), z(z), Event(vr::Event::EventType::SensorChanged) {};
Event(vr::Event::EventType::SensorChanged), type(type), x(x), y(y), z(z){};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::SensorChanged>(vr::SensorChanged(type, x, y, z)));
};
sf::Sensor::Type type;
float x;
@ -310,7 +395,10 @@ namespace vr {
class NetworkJoystickButtonPressed : public Event {
public:
NetworkJoystickButtonPressed(unsigned int joystickId, unsigned int button) :
joystickId(joystickId), button(button), Event(vr::Event::EventType::NetworkJoystickButtonPressed) {};
Event(vr::Event::EventType::NetworkJoystickButtonPressed), joystickId(joystickId), button(button) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickButtonPressed>(vr::NetworkJoystickButtonPressed(joystickId, button)));
};
unsigned int joystickId;
unsigned int button;
@ -319,7 +407,10 @@ namespace vr {
class NetworkJoystickButtonHeld : public Event {
public:
NetworkJoystickButtonHeld(unsigned int joystickId, unsigned int button) :
joystickId(joystickId), button(button), Event(vr::Event::EventType::NetworkJoystickButtonHeld) {};
Event(vr::Event::EventType::NetworkJoystickButtonHeld), joystickId(joystickId), button(button) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickButtonHeld>(vr::NetworkJoystickButtonHeld(joystickId, button)));
};
unsigned int joystickId;
unsigned int button;
@ -328,7 +419,10 @@ namespace vr {
class NetworkJoystickButtonReleased : public Event {
public:
NetworkJoystickButtonReleased(unsigned int joystickId, unsigned int button) :
joystickId(joystickId), button(button), Event(vr::Event::EventType::NetworkJoystickButtonReleased) {};
Event(vr::Event::EventType::NetworkJoystickButtonReleased), joystickId(joystickId), button(button) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickButtonReleased>(vr::NetworkJoystickButtonReleased(joystickId, button)));
};
unsigned int joystickId;
unsigned int button;
@ -337,7 +431,10 @@ namespace vr {
class NetworkJoystickMoved : public Event {
public:
NetworkJoystickMoved(sf::Joystick::Axis axis, unsigned int joystickId, float position) :
axis(axis), joystickId(joystickId), position(position), Event(vr::Event::EventType::NetworkJoystickMoved) {};
Event(vr::Event::EventType::NetworkJoystickMoved), axis(axis), joystickId(joystickId), position(position){};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickMoved>(vr::NetworkJoystickMoved(axis, joystickId, position)));
};
sf::Joystick::Axis axis;
unsigned int joystickId;
@ -347,7 +444,10 @@ namespace vr {
class NetworkJoystickConnected : public Event {
public:
NetworkJoystickConnected(unsigned int joystickId) :
joystickId(joystickId), Event(vr::Event::EventType::NetworkJoystickConnected) {};
Event(vr::Event::EventType::NetworkJoystickConnected), joystickId(joystickId){};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickConnected>(vr::NetworkJoystickConnected(joystickId)));
};
unsigned int joystickId;
};
@ -355,7 +455,10 @@ namespace vr {
class NetworkJoystickDisconnected : public Event {
public:
NetworkJoystickDisconnected(unsigned int joystickId) :
joystickId(joystickId), Event(vr::Event::EventType::NetworkJoystickDisconnected) {};
Event(vr::Event::EventType::NetworkJoystickDisconnected), joystickId(joystickId) {};
std::unique_ptr<Event> clone() override {
return std::unique_ptr<vr::Event>(std::make_unique<vr::NetworkJoystickDisconnected>(vr::NetworkJoystickDisconnected(joystickId)));
};
unsigned int joystickId;
};

2
include/Input.h
Unescape View File

@ -41,7 +41,7 @@ class WindowHandler : public VrEventSubscriber {
public:
WindowHandler(sf::RenderWindow *window) : window_ref(window) { };
virtual void recieve_event(VrEventPublisher* p, std::unique_ptr<vr::Event> event) override {
virtual void recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event>(event)) override {
if (event.get()->type == vr::Event::Closed) {
window_ref->close();
}

2
include/LightController.h
Unescape View File

@ -60,7 +60,7 @@ public:
std::shared_ptr<LightHandle> create_light(LightPrototype light_prototype);
void remove_light(unsigned int light_index);
void recieve_event(VrEventPublisher* p, std::unique_ptr<vr::Event> event) override;
void recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event> event) override;
private:

118
include/raycaster/Hardware_Caster.h
Unescape View File

@ -9,6 +9,7 @@
#include "map/Old_Map.h"
#include "Camera.h"
#include <GL/glew.h>
#include <unordered_map>
#ifdef linux
#include <CL/cl.h>
@ -31,18 +32,18 @@
#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;
char extensions[1024];
char name[256];
cl_bool is_little_endian = false;
bool cl_gl_sharing = false;
};
//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;
// char extensions[1024];
// char name[256];
// cl_bool is_little_endian = false;
// bool cl_gl_sharing = false;
//};
struct device_info {
cl_uint cl_device_address_bits;
@ -99,30 +100,77 @@ struct raycaster_settings {
struct PackedData;
class Hardware_Caster : public RayCaster
class Hardware_Caster
{
public:
Hardware_Caster();
enum ERROR_CODES {
SHARING_NOT_SUPPORTED = 800,
OPENCL_NOT_SUPPORTED = 801,
OPENCL_ERROR = 802,
ERR = 803
};
class device {
public:
#pragma pack(push, 1)
struct packed_data {
cl_device_type device_type;
cl_uint clock_frequency;
char opencl_version[64];
cl_uint compute_units;
char device_extensions[1024];
char device_name[256];
char platform_name[128];
};
#pragma pack(pop)
device(cl_device_id device_id, cl_platform_id platform_id);
device(const device& d);
void print(std::ostream& stream) const;
void print_packed_data(std::ostream& stream);
cl_device_id getDeviceId() const { return device_id; };
cl_platform_id getPlatformId() const { return platform_id; };
private:
packed_data data;
cl_device_id device_id;
cl_platform_id platform_id;
cl_bool is_little_endian = false;
bool cl_gl_sharing = false;
};
Hardware_Caster();
virtual ~Hardware_Caster();
// Queries hardware, creates the command queue and context, and compiles kernel
int init() override;
int init();
// Creates a texture to send to the GPU via height and width
// Creates a viewport vector array via vertical and horizontal fov
void create_viewport(int width, int height, float v_fov, float h_fov) override;
void create_viewport(int width, int height, float v_fov, float h_fov) ;
// Light controllers own the copy of the PackedData array.
// We receive a pointer to the array and USE_HOST_POINTER to map the memory to the GPU
void assign_lights(std::vector<PackedData> *data) override;
void assign_lights(std::vector<PackedData> *data) ;
// We take a ptr to the map and create the map, and map_dimensions buffer for the GPU
void assign_map(Old_Map *map) override;
void assign_map(Old_Map *map) ;
// We take a ptr to the camera and create a camera direction and position buffer
void assign_camera(Camera *camera) override;
void assign_camera(Camera *camera) ;
// TODO: Hoist this to the base class
// Creates 3 buffers relating to the texture atlas: texture_atlas, atlas_dim, and tile_dim
@ -130,15 +178,16 @@ public:
void create_texture_atlas(sf::Texture *t, sf::Vector2i tile_dim);
// Check to make sure that the buffers have been initiated and set them as kernel args
void validate() override;
void validate() ;
// Aquires the GL objects, runs the kernel, releases back the GL objects
void compute() override;
void compute() ;
// Take the viewport sprite and draw it to the screen
void draw(sf::RenderWindow* window) override;
void draw(sf::RenderWindow* window) ;
bool load_config();
void save_config();
// ================================== DEBUG =======================================
// Re compile the kernel and revalidate the args
@ -147,7 +196,6 @@ public:
// Modify the viewport matrix
void test_edit_viewport(int width, int height, float v_fov, float h_fov);
void gui();
private:
@ -155,6 +203,8 @@ private:
// Also checks for the sharing extension
int acquire_platform_and_device();
bool aquire_hardware();
int query_hardware();
// With respect to the individual platforms implementation of sharing
@ -189,14 +239,13 @@ private:
int set_kernel_arg(std::string kernel_name, int index, std::string buffer_name);
// Run the kernel using a 1d work size
// TODO: Test 2d worksize
int run_kernel(std::string kernel_name, const int work_dim_x, const int work_dim_y);
// Run a test kernel that prints out the kernel args
void print_kernel_arguments();
// CL error code handler. ImGui overlaps the assert() function annoyingly so I had to rename it
bool vr_assert(int error_code, std::string function_name);
static bool vr_assert(int error_code, std::string function_name);
cl_device_id getDeviceID();
cl_platform_id getPlatformID();
@ -215,6 +264,23 @@ private:
// Containers holding the kernels and buffers
std::map<std::string, cl_kernel> kernel_map;
std::map<std::string, cl_mem> buffer_map;
std::unordered_map<std::string, std::pair<sf::Sprite, std::unique_ptr<sf::Texture>>> image_map;
sf::Sprite viewport_sprite;
sf::Texture viewport_texture;
Old_Map * map = nullptr;
Camera *camera = nullptr;
// std::vector<LightController::PackedData> *lights;
std::vector<PackedData> *lights;
int light_count = 0;
sf::Uint8 *viewport_image = nullptr;
sf::Vector4f *viewport_matrix = nullptr;
sf::Vector2i viewport_resolution;
int error = 0;
std::vector<device> device_list;
};

2
kernels/ray_caster_kernel.cl
Unescape View File

@ -369,7 +369,7 @@ __kernel void raycaster(
// intersection_t = (1, 1, 1) - intersection_t;
//intersection_t += delta_t * -convert_float3(isless(intersection_t, 0));
float3 ray_pos = (convert_float3(voxel) + face_position);
ray_dir *= sign;
//ray_dir *= sign;
delta_t = fabs(1.0f / ray_dir);
float3 offset = ((ray_pos)-floor(ray_pos)) * convert_float3(voxel_step);
intersection_t = delta_t * offset;

18
src/Camera.cpp
Unescape View File

@ -54,8 +54,8 @@ int Camera::add_relative_impulse(DIRECTION impulse_direction, float speed) {
}
movement += SphereToCart(dir);
movement *= speed;
std::cout << movement.x << " : " << movement.y << " : " << movement.z << std::endl;
movement += SphereToCart(dir) * speed;
return 1;
}
@ -88,9 +88,9 @@ int Camera::update(double delta_time) {
void Camera::recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event> event) {
if (event.get()->type == vr::Event::KeyHeld) {
if (event->type == vr::Event::KeyHeld) {
vr::KeyHeld *held_event = static_cast<vr::KeyHeld*>(event.get());
auto held_event = static_cast<vr::KeyHeld*>(event.get());
if (held_event->code == sf::Keyboard::LShift) {
default_impulse = 0.01f;
@ -154,6 +154,16 @@ void Camera::recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Even
}
}
}
else if (event->type == vr::Event::MouseButtonPressed) {
vr::MouseButtonPressed *mouse_event = static_cast<vr::MouseButtonPressed*>(event.get());
if (mouse_event->button == sf::Mouse::Middle) {
mouse_enabled = !mouse_enabled;
sf::Mouse::setPosition(fixed, *window);
}
}
else if (event->type == vr::Event::JoystickMoved) {
vr::JoystickMoved *joystick_event = static_cast<vr::JoystickMoved*>(event.get());

53
src/Input.cpp
Unescape View File

@ -61,7 +61,7 @@ void Input::handle_held_keys() {
}
else if (event->type == vr::Event::MouseButtonReleased) {
vr::MouseButtonReleased *e = static_cast<vr::MouseButtonReleased*>(event.get());
held_keys.erase(std::remove(held_keys.begin(), held_keys.end(), e->button), held_keys.end());
held_mouse_buttons.erase(std::remove(held_mouse_buttons.begin(), held_mouse_buttons.end(), e->button), held_mouse_buttons.end());
}
}
@ -92,7 +92,7 @@ void Input::handle_held_keys() {
system = true;
}
event_queue.push_back(std::make_unique<vr::KeyHeld>(vr::KeyHeld(key, alt, control, shift, system)));
event_queue.emplace_back(std::make_unique<vr::KeyHeld>(vr::KeyHeld(key, alt, control, shift, system)));
}
@ -105,13 +105,14 @@ void Input::handle_held_keys() {
sf::Vector2i mouse_pos = sf::Mouse::getPosition();
event_queue.push_back(std::make_unique<vr::MouseButtonHeld>(vr::MouseButtonHeld(mouse_button, mouse_pos.x, mouse_pos.y)));
event_queue.emplace_back(std::make_unique<vr::MouseButtonHeld>(vr::MouseButtonHeld(mouse_button, mouse_pos.x, mouse_pos.y)));
}
}
void Input::dispatch_events() {
std::cout << event_queue.size() << std::endl;
while (event_queue.size() != 0) {
notify_subscribers(std::move(event_queue.front()));
event_queue.pop_front();
@ -126,97 +127,97 @@ void Input::transpose_sf_events(std::list<sf::Event> sf_event_queue) {
switch(sf_event.type) {
case sf::Event::Closed : {
event_queue.push_back(std::make_unique<vr::Closed>(vr::Closed()));
event_queue.emplace_back(std::make_unique<vr::Closed>(vr::Closed()));
break;
};
case sf::Event::Resized: {
event_queue.push_back(std::make_unique<vr::Resized>(vr::Resized(sf_event.size.width, sf_event.size.height)));
event_queue.emplace_back(std::make_unique<vr::Resized>(vr::Resized(sf_event.size.width, sf_event.size.height)));
break;
};
case sf::Event::LostFocus: {
event_queue.push_back(std::make_unique<vr::LostFocus>(vr::LostFocus()));
event_queue.emplace_back(std::make_unique<vr::LostFocus>(vr::LostFocus()));
break;
};
case sf::Event::GainedFocus: {
event_queue.push_back(std::make_unique<vr::GainedFocus>(vr::GainedFocus()));
event_queue.emplace_back(std::make_unique<vr::GainedFocus>(vr::GainedFocus()));
break;
};
case sf::Event::TextEntered: {
event_queue.push_back(std::make_unique<vr::TextEntered>(vr::TextEntered(sf_event.text.unicode)));
event_queue.emplace_back(std::make_unique<vr::TextEntered>(vr::TextEntered(sf_event.text.unicode)));
break;
};
case sf::Event::KeyPressed: {
event_queue.push_back(std::make_unique<vr::KeyPressed>(vr::KeyPressed(sf_event.key.code, sf_event.key.alt, sf_event.key.control, sf_event.key.shift, sf_event.key.system)));
event_queue.emplace_back(std::make_unique<vr::KeyPressed>(vr::KeyPressed(sf_event.key.code, sf_event.key.alt, sf_event.key.control, sf_event.key.shift, sf_event.key.system)));
break;
};
case sf::Event::KeyReleased: {
event_queue.push_back(std::make_unique<vr::KeyReleased>(vr::KeyReleased(sf_event.key.code, sf_event.key.alt, sf_event.key.control, sf_event.key.shift, sf_event.key.system)));
event_queue.emplace_back(std::make_unique<vr::KeyReleased>(vr::KeyReleased(sf_event.key.code, sf_event.key.alt, sf_event.key.control, sf_event.key.shift, sf_event.key.system)));
break;
};
// Mouse wheel moved will generate a MouseWheelScrolled event with the defaul vertical wheel
case sf::Event::MouseWheelMoved: {
event_queue.push_back(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(sf::Mouse::VerticalWheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y)));
event_queue.emplace_back(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(sf::Mouse::VerticalWheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y)));
break;
};
case sf::Event::MouseWheelScrolled: {
event_queue.push_back(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(sf_event.mouseWheelScroll.wheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y)));
event_queue.emplace_back(std::make_unique<vr::MouseWheelScrolled>(vr::MouseWheelScrolled(sf_event.mouseWheelScroll.wheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y)));
break;
};
case sf::Event::MouseButtonPressed: {
event_queue.push_back(std::make_unique<vr::MouseButtonPressed>(vr::MouseButtonPressed(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y)));
event_queue.emplace_back(std::make_unique<vr::MouseButtonPressed>(vr::MouseButtonPressed(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y)));
break;
};
case sf::Event::MouseButtonReleased: {
event_queue.push_back(std::make_unique<vr::MouseButtonReleased>(vr::MouseButtonReleased(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y)));
event_queue.emplace_back(std::make_unique<vr::MouseButtonReleased>(vr::MouseButtonReleased(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y)));
break;
};
case sf::Event::MouseMoved: {
event_queue.push_back(std::make_unique<vr::MouseMoved>(vr::MouseMoved(sf_event.mouseMove.x, sf_event.mouseMove.y)));
event_queue.emplace_back(std::make_unique<vr::MouseMoved>(vr::MouseMoved(sf_event.mouseMove.x, sf_event.mouseMove.y)));
break;
};
case sf::Event::MouseEntered: {
event_queue.push_back(std::make_unique<vr::MouseEntered>(vr::MouseEntered(sf_event.mouseMove.x, sf_event.mouseMove.y)));
event_queue.emplace_back(std::make_unique<vr::MouseEntered>(vr::MouseEntered(sf_event.mouseMove.x, sf_event.mouseMove.y)));
break;
};
case sf::Event::MouseLeft: {
event_queue.push_back(std::make_unique<vr::MouseLeft>(vr::MouseLeft(sf_event.mouseMove.x, sf_event.mouseMove.x)));
event_queue.emplace_back(std::make_unique<vr::MouseLeft>(vr::MouseLeft(sf_event.mouseMove.x, sf_event.mouseMove.x)));
break;
};
case sf::Event::JoystickButtonPressed: {
event_queue.push_back(std::make_unique<vr::JoystickButtonPressed>(vr::JoystickButtonPressed(sf_event.joystickButton.joystickId, sf_event.joystickButton.button)));
event_queue.emplace_back(std::make_unique<vr::JoystickButtonPressed>(vr::JoystickButtonPressed(sf_event.joystickButton.joystickId, sf_event.joystickButton.button)));
break;
};
case sf::Event::JoystickButtonReleased: {
event_queue.push_back(std::make_unique<vr::JoystickButtonReleased>(vr::JoystickButtonReleased(sf_event.joystickButton.joystickId, sf_event.joystickButton.button)));
event_queue.emplace_back(std::make_unique<vr::JoystickButtonReleased>(vr::JoystickButtonReleased(sf_event.joystickButton.joystickId, sf_event.joystickButton.button)));
break;
};
case sf::Event::JoystickMoved: {
event_queue.push_back(std::make_unique<vr::JoystickMoved>(vr::JoystickMoved(sf_event.joystickMove.axis, sf_event.joystickMove.joystickId, sf_event.joystickMove.position)));
event_queue.emplace_back(std::make_unique<vr::JoystickMoved>(vr::JoystickMoved(sf_event.joystickMove.axis, sf_event.joystickMove.joystickId, sf_event.joystickMove.position)));
break;
};
case sf::Event::JoystickConnected: {
event_queue.push_back(std::make_unique<vr::JoystickConnected>(vr::JoystickConnected(sf_event.joystickConnect.joystickId)));
event_queue.emplace_back(std::make_unique<vr::JoystickConnected>(vr::JoystickConnected(sf_event.joystickConnect.joystickId)));
break;
};
case sf::Event::JoystickDisconnected: {
event_queue.push_back(std::make_unique<vr::JoystickDisconnected>(vr::JoystickDisconnected(sf_event.joystickConnect.joystickId)));
event_queue.emplace_back(std::make_unique<vr::JoystickDisconnected>(vr::JoystickDisconnected(sf_event.joystickConnect.joystickId)));
break;
};
case sf::Event::TouchBegan: {
event_queue.push_back(std::make_unique<vr::TouchBegan>(vr::TouchBegan(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
event_queue.emplace_back(std::make_unique<vr::TouchBegan>(vr::TouchBegan(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
break;
};
case sf::Event::TouchMoved: {
event_queue.push_back(std::make_unique<vr::TouchMoved>(vr::TouchMoved(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
event_queue.emplace_back(std::make_unique<vr::TouchMoved>(vr::TouchMoved(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
break;
};
case sf::Event::TouchEnded: {
event_queue.push_back(std::make_unique<vr::TouchEnded>(vr::TouchEnded(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
event_queue.emplace_back(std::make_unique<vr::TouchEnded>(vr::TouchEnded(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y)));
break;
};
case sf::Event::SensorChanged: {
event_queue.push_back(std::make_unique<vr::SensorChanged>(vr::SensorChanged(sf_event.sensor.type, sf_event.sensor.x, sf_event.sensor.y, sf_event.sensor.z)));
event_queue.emplace_back(std::make_unique<vr::SensorChanged>(vr::SensorChanged(sf_event.sensor.type, sf_event.sensor.x, sf_event.sensor.y, sf_event.sensor.z)));
break;
};
default: {

21
src/LightController.cpp
Unescape View File

@ -36,22 +36,23 @@ void LightController::remove_light(unsigned int light_index) {
void LightController::recieve_event(VrEventPublisher* publisher, std::unique_ptr<vr::Event> event) {
if (event.get()->type == vr::Event::KeyHeld) {}
if (event->type == vr::Event::KeyHeld) {}
else if (event->type == vr::Event::KeyPressed) {}
else if (event->type == vr::Event::MouseMoved) {}
else if (event->type == vr::Event::JoystickMoved) {
vr::JoystickMoved *joystick_event = static_cast<vr::JoystickMoved*>(event.get());
if (joystick_event->axis == sf::Joystick::Axis::X) {
//movement.x -= joystick_event->position / 5;
//add_relative_impulse(Camera::DIRECTION::FORWARD, joystick_event->position);
}
else if (joystick_event->axis == sf::Joystick::Axis::Y) {
//movement.y += joystick_event->position / 5;
//add_relative_impulse(Camera::DIRECTION::RIGHT, joystick_event->position);
}
//vr::JoystickMoved *joystick_event = static_cast<vr::JoystickMoved*>(event.get());
//if (joystick_event->axis == sf::Joystick::Axis::X) {
// //movement.x -= joystick_event->position / 5;
// //add_relative_impulse(Camera::DIRECTION::FORWARD, joystick_event->position);
//}
//else if (joystick_event->axis == sf::Joystick::Axis::Y) {
// //movement.y += joystick_event->position / 5;
// //add_relative_impulse(Camera::DIRECTION::RIGHT, joystick_event->position);
//}
//else if (joystick_event->axis == sf::Joystick::Axis::Z) {
// add_relative_impulse(Camera::DIRECTION::DOWN, joystick_event->position);
//}

9
src/Pub_Sub.cpp
Unescape View File

@ -32,10 +32,13 @@ void VrEventPublisher::unsubscribe(VrEventSubscriber *s, vr::Event::EventType ty
void VrEventPublisher::notify_subscribers(std::unique_ptr<vr::Event> event) {
// get the bucket containing subscribers to that Event_Class
std::vector<VrEventSubscriber*> *event_type_bucket = &subscribers[event.get()->type];
//std::vector<VrEventSubscriber*> *event_type_bucket = &subscribers[event->type];
// Send them the event
for (auto s : *event_type_bucket) {
s->recieve_event(this, std::move(event));
// Each and every event that is received in the recieve_event function
// will be a unique ptr solely owned by that function
for (auto s : subscribers[event->type]) {
s->recieve_event(this, event->clone());
}
}

8
src/main.cpp
Unescape View File

@ -84,7 +84,7 @@ int main() {
#ifdef linux
glewInit();
#elif defined _WIN32
glewInit();
//glewInit();
#elif defined TARGET_OS_MAC
// Do nothing, extension wrangling handled by macOS
#endif
@ -99,8 +99,8 @@ int main() {
//return 0;
// =============================
sf::RenderWindow window(sf::VideoMode(WINDOW_X, WINDOW_Y), "SFML");
window.setMouseCursorVisible(false);
sf::RenderWindow window(sf::VideoMode(WINDOW_X, WINDOW_Y), "SFML");
window.setMouseCursorVisible(false);
window.setKeyRepeatEnabled(false);
window.setFramerateLimit(120);
window.setVerticalSyncEnabled(false);
@ -115,6 +115,7 @@ int main() {
abort();
}
// Create and generate the old 3d array style map
Old_Map* map = new Old_Map(sf::Vector3i(MAP_X, MAP_Y, MAP_Z));
map->generate_terrain();
@ -161,6 +162,7 @@ int main() {
camera->subscribe_to_publisher(&input_handler, vr::Event::EventType::KeyHeld);
camera->subscribe_to_publisher(&input_handler, vr::Event::EventType::KeyPressed);
camera->subscribe_to_publisher(&input_handler, vr::Event::EventType::MouseMoved);
camera->subscribe_to_publisher(&input_handler, vr::Event::EventType::MouseButtonPressed);
WindowHandler win_hand(&window);
win_hand.subscribe_to_publisher(&input_handler, vr::Event::EventType::Closed);

317
src/raycaster/Hardware_Caster.cpp
Unescape View File

@ -10,12 +10,42 @@ Hardware_Caster::~Hardware_Caster() {
int Hardware_Caster::init() {
query_hardware();
// query_hardware();
// Initialize opencl up to the point where we start assigning buffers
error = acquire_platform_and_device();
if(vr_assert(error, "aquire_platform_and_device"))
return error;
//// Initialize opencl up to the point where we start assigning buffers
//error = acquire_platform_and_device();
//if(vr_assert(error, "aquire_platform_and_device"))
// return error;
if (!aquire_hardware())
return false;
if (!load_config()) {
std::cout << "Select a device number which you wish to use" << std::endl;
for (int i = 0; i < device_list.size(); i++) {
std::cout << "\n-----------------------------------------------------------------" << std::endl;
std::cout << "\tDevice Number : " << i << std::endl;
std::cout << "-----------------------------------------------------------------" << std::endl;
device_list.at(i).print(std::cout);
}
int selection = -1;
while (selection < 0 && selection >= device_list.size()) {
std::cout << "Device which you wish to use : ";
std::cin >> selection;
}
device_id = device_list.at(selection).getDeviceId();
platform_id = device_list.at(selection).getPlatformId();
save_config();
}
error = create_shared_context();
if (vr_assert(error, "create_shared_context"))
@ -268,165 +298,102 @@ void Hardware_Caster::test_edit_viewport(int width, int height, float v_fov, flo
}
void Hardware_Caster::gui() {
}
int Hardware_Caster::acquire_platform_and_device() {
bool Hardware_Caster::aquire_hardware()
{
// Get the number of platforms
cl_uint plt_cnt = 0;
clGetPlatformIDs(0, nullptr, &plt_cnt);
cl_uint platform_count = 0;
clGetPlatformIDs(0, nullptr, &platform_count);
// Fetch the platforms
std::map<cl_platform_id, std::vector<device>> plt_ids;
if (platform_count == 0) {
std::cout << "There appears to be no OpenCL platforms on this machine" << std::endl;
return false;
}
// buffer before map init
std::vector<cl_platform_id> plt_buf(plt_cnt);
clGetPlatformIDs(plt_cnt, plt_buf.data(), nullptr);
// Get the ID's for those platforms
std::vector<cl_platform_id> plt_buf(platform_count);
// Map init
for (auto id : plt_buf) {
plt_ids.emplace(std::make_pair(id, std::vector<device>()));
}
clGetPlatformIDs(platform_count, plt_buf.data(), nullptr);
if (vr_assert(error, "clGetPlatformIDs"))
return false;
// For each platform, populate its devices
for (unsigned int i = 0; i < plt_cnt; i++) {
// Cycle through the platform ID's
for (unsigned int i = 0; i < platform_count; i++) {
// And get their device count
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) {
std::cout << "There appears to be no devices, or none at least supporting OpenCL" << std::endl;
return OPENCL_NOT_SUPPORTED;
}
// Get the device ids
std::vector<cl_device_id> deviceIds(deviceIdCount);
error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL);
if (vr_assert(error, "clGetDeviceIDs"))
return OPENCL_ERROR;
for (unsigned 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);
clGetDeviceInfo(d.id, CL_DEVICE_EXTENSIONS, 1024, &d.extensions, NULL);
clGetDeviceInfo(d.id, CL_DEVICE_NAME, 256, &d.name, NULL);
clGetDeviceInfo(d.id, CL_DEVICE_ENDIAN_LITTLE, sizeof(cl_bool), &d.is_little_endian, NULL);
std::cout << "Device: " << q << std::endl;
std::cout << "Device Name : " << d.name << std::endl;
std::cout << "Platform ID : " << d.platform << std::endl;
std::cout << "Device Version : " << d.version << std::endl;
return false;
std::cout << "Device Type : ";
if (d.type == CL_DEVICE_TYPE_CPU)
std::cout << "CPU" << std::endl;
if (deviceIdCount == 0) {
std::cout << "There appears to be no devices associated with this platform" << std::endl;
else if (d.type == CL_DEVICE_TYPE_GPU)
std::cout << "GPU" << std::endl;
}
else {
else if (d.type == CL_DEVICE_TYPE_ACCELERATOR)
std::cout << "Accelerator" << std::endl;
// Get the device ids and place them in the device list
std::vector<cl_device_id> deviceIds(deviceIdCount);
std::cout << "Max clock frequency : " << d.clock_frequency << std::endl;
std::cout << "Max compute units : " << d.comp_units << std::endl;
std::cout << "Is little endian : " << std::boolalpha << static_cast<bool>(d.is_little_endian) << std::endl;
error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL);
if (vr_assert(error, "clGetDeviceIDs"))
return false;
std::cout << "cl_khr_gl_sharing supported: ";
if (std::string(d.extensions).find("cl_khr_gl_sharing") == std::string::npos &&
std::string(d.extensions).find("cl_APPLE_gl_sharing") == std::string::npos) {
std::cout << "False" << std::endl;
for (int d = 0; d < deviceIds.size(); d++) {
device_list.emplace_back(device(deviceIds[d], plt_buf.at(i)));
}
std::cout << "True" << std::endl;
d.cl_gl_sharing = true;
std::cout << "Extensions supported: " << std::endl;
std::cout << std::string(d.extensions) << std::endl;
std::cout << " ===================================================================================== " << std::endl;
plt_ids.at(d.platform).push_back(d);
}
}
return true;
}
// 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;
void Hardware_Caster::save_config() {
std::ofstream output_file;
output_file.open("device_config.bin", std::ofstream::binary | std::ofstream::out | std::ofstream::trunc);
for (auto kvp : plt_ids) {
device d(device_id, platform_id);
d.print_packed_data(output_file);
for (auto device : kvp.second) {
output_file.close();
}
// 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
bool Hardware_Caster::load_config() {
// Upon success of a condition, set the current best device values
std::cout << "Loading hardware config...";
//if (strcmp(device.version, "OpenCL 1.2 ") == 0 && strcmp(device.version, current_best_device.version) != 0) {
// current_best_device = device;
//}
std::ifstream input_file("device_config.bin", std::ios::binary | std::ios::in);
// If the current device is not a GPU and we are comparing it to a GPU
if (device.type == CL_DEVICE_TYPE_GPU && current_best_device.type != CL_DEVICE_TYPE_GPU) {
current_best_device = device;
}
if (!input_file.is_open()) {
std::cout << "No config file found" << std::endl;
return false;
}
//if (device.type == CL_DEVICE_TYPE_CPU &&
// current_best_device.type != CL_DEVICE_TYPE_CPU) {
// current_best_device = device;
//}
device::packed_data data;
input_file.read(reinterpret_cast<char*>(&data), sizeof(data));
input_file.close();
// Get the unit with the higher compute units
if (device.comp_units > current_best_device.comp_units) {
current_best_device = device;
}
bool found = false;
// If we are comparing CPU to CPU get the one with the best clock
if (current_best_device.type != CL_DEVICE_TYPE_GPU && device.clock_frequency > current_best_device.clock_frequency) {
current_best_device = device;
}
if (current_best_device.cl_gl_sharing == false && device.cl_gl_sharing == true) {
current_best_device = device;
}
for (auto d : device_list) {
if (memcmp(&d, &data, sizeof(device::packed_data)) == 0) {
std::cout << "Found saved config" << std::endl;
found = true;
device_id = d.getDeviceId();
platform_id = d.getPlatformId();
break;
}
}
platform_id = current_best_device.platform;
device_id = current_best_device.id;
std::cout << std::endl;
std::cout << "Selected Platform : " << platform_id << std::endl;
std::cout << "Selected Device : " << device_id << std::endl;
std::cout << "Selected Name : " << current_best_device.name << std::endl;
std::cout << "Selected Version : " << current_best_device.version << std::endl;
if (current_best_device.cl_gl_sharing == false) {
std::cout << "This device does not support the cl_khr_gl_sharing extension" << std::endl;
return RayCaster::SHARING_NOT_SUPPORTED;
if (!found) {
std::cout << "No hardware matching config found" << std::endl;
return false;
}
return 1;
};
return true;
}
int Hardware_Caster::query_hardware() {
@ -526,6 +493,22 @@ int Hardware_Caster::query_hardware() {
int Hardware_Caster::create_shared_context() {
//std::vector<DISPLAY_DEVICEA> display_devices;
//DISPLAY_DEVICEA dev;
//int k = 0;
//dev.cb = sizeof(dev);
//HDC hDC;
//while(EnumDisplayDevicesA(NULL, k, &dev, 0)) {
//
// display_devices.push_back(dev);
// hDC = CreateDC(dev.DeviceName, dev.DeviceName, 0, 0);
// k++;
//}
//
//hDC = CreateDC(display_devices.at(1).DeviceName, display_devices.at(1).DeviceName, 0, 0);
//std::cout << GetLastError();
//HGLRC hGLRC = wglCreateContext(hDC);
// Hurray for standards!
// Setup the context properties to grab the current GL context
@ -540,8 +523,8 @@ int Hardware_Caster::create_shared_context() {
#elif defined _WIN32
HGLRC hGLRC = wglGetCurrentContext();
HDC hDC = wglGetCurrentDC();
HGLRC hGLRC = wglGetCurrentContext();
cl_context_properties context_properties[] = {
CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id,
CL_GL_CONTEXT_KHR, (cl_context_properties)hGLRC,
@ -1036,3 +1019,79 @@ bool Hardware_Caster::vr_assert(int error_code, std::string function_name) {
std::cout << err_msg << " =at= " << function_name << std::endl;
return true;
}
Hardware_Caster::device::device(cl_device_id device_id, cl_platform_id platform_id) {
this->device_id = device_id;
this->platform_id = platform_id;
int error = 0;
error = clGetPlatformInfo(platform_id, CL_PLATFORM_NAME, 128, (void*)&data.platform_name, nullptr);
if (vr_assert(error, "clGetPlatformInfo"))
return;
error = clGetDeviceInfo(device_id, CL_DEVICE_VERSION, sizeof(char) * 128, &data.opencl_version, NULL);
error = clGetDeviceInfo(device_id, CL_DEVICE_TYPE, sizeof(cl_device_type), &data.device_type, NULL);
error = clGetDeviceInfo(device_id, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(cl_uint), &data.clock_frequency, NULL);
error = clGetDeviceInfo(device_id, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(cl_uint), &data.compute_units, NULL);
error = clGetDeviceInfo(device_id, CL_DEVICE_EXTENSIONS, 1024, &data.device_extensions, NULL);
error = clGetDeviceInfo(device_id, CL_DEVICE_NAME, 256, &data.device_name, NULL);
error = clGetDeviceInfo(device_id, CL_DEVICE_ENDIAN_LITTLE, sizeof(cl_bool), &is_little_endian, NULL);
// Check for the sharing extension
if (std::string(data.device_extensions).find("cl_khr_gl_sharing") != std::string::npos ||
std::string(data.device_extensions).find("cl_APPLE_gl_sharing") != std::string::npos) {
cl_gl_sharing = true;
}
}
Hardware_Caster::device::device(const device& d) {
// member values, copy individually
device_id = d.device_id;
platform_id = d.platform_id;
is_little_endian = d.is_little_endian;
cl_gl_sharing = d.cl_gl_sharing;
// struct so it copies by value
data = d.data;
}
void Hardware_Caster::device::print(std::ostream& stream) const {
stream << "\n\tDevice ID : " << device_id << std::endl;
stream << "\tDevice Name : " << data.device_name << std::endl;
stream << "\tPlatform ID : " << platform_id << std::endl;
stream << "\tPlatform Name : " << data.platform_name << std::endl;
stream << "\tOpenCL Version : " << data.opencl_version << std::endl;
stream << "\tSupports sharing : " << std::boolalpha << cl_gl_sharing << std::endl;
stream << "\tDevice Type : ";
if (data.device_type == CL_DEVICE_TYPE_CPU)
stream << "CPU" << std::endl;
else if (data.device_type == CL_DEVICE_TYPE_GPU)
stream << "GPU" << std::endl;
else if (data.device_type == CL_DEVICE_TYPE_ACCELERATOR)
stream << "Accelerator" << std::endl;
stream << "\tIs Little Endian : " << std::boolalpha << is_little_endian << std::endl;
stream << "\tClock Frequency : " << data.clock_frequency << std::endl;
stream << "\tCompute Units : " << data.compute_units << std::endl;
stream << "\n*Extensions*" << std::endl;
stream << data.device_extensions << std::endl;
stream << "\n";
}
void Hardware_Caster::device::print_packed_data(std::ostream& stream) {
stream.write(reinterpret_cast<char*>(&data), sizeof(data));
}
Write Preview
Loading…
Cancel
Save