From 334a375535dac5a1c52cd27141de175cbc66b8f5 Mon Sep 17 00:00:00 2001 From: MitchellHansen Date: Sat, 15 Apr 2017 01:45:09 -0700 Subject: [PATCH] Commit might have been messed up --- include/Camera.h | 2 +- include/Event.hpp | 165 ++++++++++++--- include/Input.h | 2 +- include/LightController.h | 2 +- include/raycaster/Hardware_Caster.h | 118 ++++++++--- kernels/ray_caster_kernel.cl | 2 +- src/Camera.cpp | 18 +- src/Input.cpp | 53 ++--- src/LightController.cpp | 21 +- src/LightHandle.cpp | 2 +- src/Pub_Sub.cpp | 9 +- src/main.cpp | 10 +- src/raycaster/Hardware_Caster.cpp | 317 +++++++++++++++++----------- 13 files changed, 483 insertions(+), 238 deletions(-) diff --git a/include/Camera.h b/include/Camera.h index 2d8d3d7..a360172 100644 --- a/include/Camera.h +++ b/include/Camera.h @@ -37,7 +37,7 @@ public: void setSpeed(float speed); float getSpeed(); - void recieve_event(VrEventPublisher* p, std::unique_ptr event) override; + void recieve_event(VrEventPublisher* publisher, std::unique_ptr event) override; private: diff --git a/include/Event.hpp b/include/Event.hpp index a21ff53..4d5b6e5 100644 --- a/include/Event.hpp +++ b/include/Event.hpp @@ -4,7 +4,7 @@ #include #include #include - +#include 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() {}; - EventType type; + virtual std::unique_ptr clone() = 0; + EventType type; + private: + }; + + class Closed : public Event { public: Closed() : Event(vr::Event::EventType::Closed) {}; + ~Closed() override {}; + std::unique_ptr clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(vr::LostFocus())); + }; }; class GainedFocus : public Event { public: GainedFocus() : Event(vr::Event::EventType::GainedFocus) {}; + std::unique_ptr clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(vr::JoystickDisconnected(joystickId))); + }; unsigned int joystickId; }; @@ -264,8 +337,11 @@ 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 clone() override { + return std::unique_ptr(std::make_unique(vr::TouchBegan(finger, x, y))); + }; + unsigned int finger; int x; int y; @@ -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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(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 clone() override { + return std::unique_ptr(std::make_unique(vr::NetworkJoystickDisconnected(joystickId))); + }; unsigned int joystickId; }; diff --git a/include/Input.h b/include/Input.h index f8301a0..e7d4de3 100644 --- a/include/Input.h +++ b/include/Input.h @@ -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 event) override { + virtual void recieve_event(VrEventPublisher* publisher, std::unique_ptr(event)) override { if (event.get()->type == vr::Event::Closed) { window_ref->close(); } diff --git a/include/LightController.h b/include/LightController.h index 7e14f0f..2251081 100644 --- a/include/LightController.h +++ b/include/LightController.h @@ -60,7 +60,7 @@ public: std::shared_ptr create_light(LightPrototype light_prototype); void remove_light(unsigned int light_index); - void recieve_event(VrEventPublisher* p, std::unique_ptr event) override; + void recieve_event(VrEventPublisher* publisher, std::unique_ptr event) override; private: diff --git a/include/raycaster/Hardware_Caster.h b/include/raycaster/Hardware_Caster.h index 5934426..de7873f 100644 --- a/include/raycaster/Hardware_Caster.h +++ b/include/raycaster/Hardware_Caster.h @@ -9,6 +9,7 @@ #include "map/Old_Map.h" #include "Camera.h" #include +#include #ifdef linux #include @@ -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 *data) override; + void assign_lights(std::vector *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 kernel_map; std::map buffer_map; + std::unordered_map>> image_map; + + sf::Sprite viewport_sprite; + sf::Texture viewport_texture; + + Old_Map * map = nullptr; + Camera *camera = nullptr; + // std::vector *lights; + std::vector *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_list; }; diff --git a/kernels/ray_caster_kernel.cl b/kernels/ray_caster_kernel.cl index a21ae57..814095e 100644 --- a/kernels/ray_caster_kernel.cl +++ b/kernels/ray_caster_kernel.cl @@ -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; diff --git a/src/Camera.cpp b/src/Camera.cpp index 20e08aa..89fa6a6 100644 --- a/src/Camera.cpp +++ b/src/Camera.cpp @@ -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 event) { - if (event.get()->type == vr::Event::KeyHeld) { + if (event->type == vr::Event::KeyHeld) { - vr::KeyHeld *held_event = static_cast(event.get()); + auto held_event = static_cast(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_ptrtype == vr::Event::MouseButtonPressed) { + + vr::MouseButtonPressed *mouse_event = static_cast(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(event.get()); diff --git a/src/Input.cpp b/src/Input.cpp index 466b973..a425b38 100644 --- a/src/Input.cpp +++ b/src/Input.cpp @@ -61,7 +61,7 @@ void Input::handle_held_keys() { } else if (event->type == vr::Event::MouseButtonReleased) { vr::MouseButtonReleased *e = static_cast(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(key, alt, control, shift, system))); + event_queue.emplace_back(std::make_unique(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(mouse_button, mouse_pos.x, mouse_pos.y))); + event_queue.emplace_back(std::make_unique(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_queue) { switch(sf_event.type) { case sf::Event::Closed : { - event_queue.push_back(std::make_unique(vr::Closed())); + event_queue.emplace_back(std::make_unique(vr::Closed())); break; }; case sf::Event::Resized: { - event_queue.push_back(std::make_unique(vr::Resized(sf_event.size.width, sf_event.size.height))); + event_queue.emplace_back(std::make_unique(vr::Resized(sf_event.size.width, sf_event.size.height))); break; }; case sf::Event::LostFocus: { - event_queue.push_back(std::make_unique(vr::LostFocus())); + event_queue.emplace_back(std::make_unique(vr::LostFocus())); break; }; case sf::Event::GainedFocus: { - event_queue.push_back(std::make_unique(vr::GainedFocus())); + event_queue.emplace_back(std::make_unique(vr::GainedFocus())); break; }; case sf::Event::TextEntered: { - event_queue.push_back(std::make_unique(vr::TextEntered(sf_event.text.unicode))); + event_queue.emplace_back(std::make_unique(vr::TextEntered(sf_event.text.unicode))); break; }; case sf::Event::KeyPressed: { - event_queue.push_back(std::make_unique(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(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(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(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(sf::Mouse::VerticalWheel, sf_event.mouseWheelScroll.delta, sf_event.mouseWheelScroll.x, sf_event.mouseWheelScroll.y))); + event_queue.emplace_back(std::make_unique(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(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(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(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y))); + event_queue.emplace_back(std::make_unique(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(sf_event.mouseButton.button, sf_event.mouseButton.x, sf_event.mouseButton.y))); + event_queue.emplace_back(std::make_unique(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(sf_event.mouseMove.x, sf_event.mouseMove.y))); + event_queue.emplace_back(std::make_unique(vr::MouseMoved(sf_event.mouseMove.x, sf_event.mouseMove.y))); break; }; case sf::Event::MouseEntered: { - event_queue.push_back(std::make_unique(vr::MouseEntered(sf_event.mouseMove.x, sf_event.mouseMove.y))); + event_queue.emplace_back(std::make_unique(vr::MouseEntered(sf_event.mouseMove.x, sf_event.mouseMove.y))); break; }; case sf::Event::MouseLeft: { - event_queue.push_back(std::make_unique(vr::MouseLeft(sf_event.mouseMove.x, sf_event.mouseMove.x))); + event_queue.emplace_back(std::make_unique(vr::MouseLeft(sf_event.mouseMove.x, sf_event.mouseMove.x))); break; }; case sf::Event::JoystickButtonPressed: { - event_queue.push_back(std::make_unique(vr::JoystickButtonPressed(sf_event.joystickButton.joystickId, sf_event.joystickButton.button))); + event_queue.emplace_back(std::make_unique(vr::JoystickButtonPressed(sf_event.joystickButton.joystickId, sf_event.joystickButton.button))); break; }; case sf::Event::JoystickButtonReleased: { - event_queue.push_back(std::make_unique(vr::JoystickButtonReleased(sf_event.joystickButton.joystickId, sf_event.joystickButton.button))); + event_queue.emplace_back(std::make_unique(vr::JoystickButtonReleased(sf_event.joystickButton.joystickId, sf_event.joystickButton.button))); break; }; case sf::Event::JoystickMoved: { - event_queue.push_back(std::make_unique(vr::JoystickMoved(sf_event.joystickMove.axis, sf_event.joystickMove.joystickId, sf_event.joystickMove.position))); + event_queue.emplace_back(std::make_unique(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(sf_event.joystickConnect.joystickId))); + event_queue.emplace_back(std::make_unique(vr::JoystickConnected(sf_event.joystickConnect.joystickId))); break; }; case sf::Event::JoystickDisconnected: { - event_queue.push_back(std::make_unique(vr::JoystickDisconnected(sf_event.joystickConnect.joystickId))); + event_queue.emplace_back(std::make_unique(vr::JoystickDisconnected(sf_event.joystickConnect.joystickId))); break; }; case sf::Event::TouchBegan: { - event_queue.push_back(std::make_unique(vr::TouchBegan(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y))); + event_queue.emplace_back(std::make_unique(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(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y))); + event_queue.emplace_back(std::make_unique(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(sf_event.touch.finger, sf_event.touch.x, sf_event.touch.y))); + event_queue.emplace_back(std::make_unique(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(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(sf_event.sensor.type, sf_event.sensor.x, sf_event.sensor.y, sf_event.sensor.z))); break; }; default: { diff --git a/src/LightController.cpp b/src/LightController.cpp index e4c1223..7ad9dc3 100644 --- a/src/LightController.cpp +++ b/src/LightController.cpp @@ -36,22 +36,23 @@ void LightController::remove_light(unsigned int light_index) { void LightController::recieve_event(VrEventPublisher* publisher, std::unique_ptr 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(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(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); //} diff --git a/src/LightHandle.cpp b/src/LightHandle.cpp index 0fedbdd..2495f66 100644 --- a/src/LightHandle.cpp +++ b/src/LightHandle.cpp @@ -66,7 +66,7 @@ void LightHandle::set_rgbi(sf::Vector4f rgbi) void LightHandle::recieve_event(VrEventPublisher* publisher, std::unique_ptr event) { if (event->type == vr::Event::JoystickMoved) { - + vr::JoystickMoved *joystick_event = static_cast(event.get()); if (joystick_event->axis == sf::Joystick::Axis::X) { diff --git a/src/Pub_Sub.cpp b/src/Pub_Sub.cpp index a44c05c..2a9f376 100644 --- a/src/Pub_Sub.cpp +++ b/src/Pub_Sub.cpp @@ -32,10 +32,13 @@ void VrEventPublisher::unsubscribe(VrEventSubscriber *s, vr::Event::EventType ty void VrEventPublisher::notify_subscribers(std::unique_ptr event) { // get the bucket containing subscribers to that Event_Class - std::vector *event_type_bucket = &subscribers[event.get()->type]; + //std::vector *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()); } + } diff --git a/src/main.cpp b/src/main.cpp index 2ee18b3..40ef67e 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -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,12 +99,12 @@ 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); - + ImGui::SFML::Init(window); window.resetGLStates(); @@ -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); diff --git a/src/raycaster/Hardware_Caster.cpp b/src/raycaster/Hardware_Caster.cpp index ba2a85b..2b62460 100644 --- a/src/raycaster/Hardware_Caster.cpp +++ b/src/raycaster/Hardware_Caster.cpp @@ -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> 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 plt_buf(plt_cnt); - clGetPlatformIDs(plt_cnt, plt_buf.data(), nullptr); + // Get the ID's for those platforms + std::vector plt_buf(platform_count); - // Map init - for (auto id : plt_buf) { - plt_ids.emplace(std::make_pair(id, std::vector())); - } + 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 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 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(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() { - for (auto kvp : plt_ids) { + std::ofstream output_file; + output_file.open("device_config.bin", std::ofstream::binary | std::ofstream::out | std::ofstream::trunc); - for (auto device : kvp.second) { + device d(device_id, platform_id); + d.print_packed_data(output_file); - // 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 + output_file.close(); +} - // Upon success of a condition, set the current best device values +bool Hardware_Caster::load_config() { - //if (strcmp(device.version, "OpenCL 1.2 ") == 0 && strcmp(device.version, current_best_device.version) != 0) { - // current_best_device = device; - //} + std::cout << "Loading hardware config..."; - // 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; - } + std::ifstream input_file("device_config.bin", std::ios::binary | std::ios::in); - //if (device.type == CL_DEVICE_TYPE_CPU && - // current_best_device.type != CL_DEVICE_TYPE_CPU) { - // current_best_device = device; - //} + if (!input_file.is_open()) { + std::cout << "No config file found" << std::endl; + return false; + } - // Get the unit with the higher compute units - if (device.comp_units > current_best_device.comp_units) { - current_best_device = device; - } + device::packed_data data; + input_file.read(reinterpret_cast(&data), sizeof(data)); + input_file.close(); - // 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; - } + bool found = false; - 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_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(&data), sizeof(data)); +} \ No newline at end of file