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

Wrestling with the compiler to pass these shared_ptr's

Browse Source
This commit is contained in:
MitchellHansen
2017-02-04 22:34:09 -08:00
parent a01b089d12
commit fa047f9e3a
10 changed files with 102 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/Hardware_Caster.h
View File

@@ -50,8 +50,7 @@ public:
// Both will create the view matrix, view res buffer
void create_viewport(int width, int height, float v_fov, float h_fov) override;
void assign_lights(std::vector<LightController::PackedData> *data) override;
void assign_lights();
void assign_lights(std::vector<char> *data) override;
void assign_map(Old_Map *map) override;
void assign_camera(Camera *camera) override;
void validate() override;

39
include/LightController.h
View File

@@ -4,6 +4,7 @@
#include "util.hpp"
#include "Pub_Sub.h"
#include "RayCaster.h"
#include "LightHandle.h"
class LightController : public VrEventSubscriber {
public:
@@ -15,29 +16,21 @@ public:
PackedData(sf::Vector3f position, sf::Vector3f direction_cartesian, sf::Vector4f rgbi) :
position(position), direction_cartesian(direction_cartesian), rgbi(rgbi) {
}
PackedData();
PackedData() {};
sf::Vector3f position;
sf::Vector3f direction_cartesian;
sf::Vector4f rgbi;
};
// Data that enables "camera" style movement. I can't really use inheritance easily because
// of the data packing requirements
struct Light {
Light();
int packed_index;
float friction_coefficient = 0.1f;
float default_impulse = 1.0f;
sf::Vector3f movement;
};
LightController(std::shared_ptr<RayCaster> raycaster);
// LightController(std::shared_ptr<RayCaster> raycaster);
LightController();
~LightController();
//void create_light(LightController::PackedData light_data, std::string light_name);
// LightHandle get_light_handle(std::string light_name);
void set_position(sf::Vector3f position);
int add_static_impulse(sf::Vector3f impulse);
int add_relative_impulse(DIRECTION direction, float speed);
int update(double delta_time);
@@ -46,19 +39,19 @@ public:
void recieve_event(VrEventPublisher* p, std::unique_ptr<vr::Event> event) override;
void erase_light();
std::vector<LightController::PackedData>* get_lights();
//std::vector<LightController::PackedData>* get_lights();
private:
// Need to allow N byte light class to be packed into 10 byte packets
int packed_size = sizeof(PackedData);
//// Need to allow N byte light class to be packed into 10 byte packets
//int packed_size = sizeof(PackedData);
// Index that this light is in the packed data
int packed_index;
std::vector<PackedData> packed_data_array;
std::unordered_map<std::string, Light> light_map;
std::shared_ptr<RayCaster> raycaster;
//std::vector<PackedData> packed_data_array;
//
//
//std::unordered_map<std::string, LightHandle> light_map;
//
//std::shared_ptr<RayCaster> raycaster;
};

32
include/LightHandle.h Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include <SFML/Graphics.hpp>
#include <util.hpp>
#include "LightController.h"
// We need to be able to :
// - Allow lights to exist outside the context of a LightController
// - i.e we can have a prototype light or similar
// - Preserve the existence of lights upon object destruction
// - No need to keep track of an object only used upon special use cases
// - Maintain an X*N byte array, X = size of packed data, N = Light number
// - But still allow classes of size Y bytes
// - Preserve X packed bytes in an array which are pointed to by an array of shared pointers
class LightHandle {
public:
LightHandle();
//LightHandle(LightController light_controller, std::string light_name);
~LightHandle();
private:
float friction_coefficient = 0.1f;
float default_impulse = 1.0f;
sf::Vector3f movement;
std::shared_ptr<sf::Vector3f> position;
std::shared_ptr<sf::Vector3f> direction_cartesian;
std::shared_ptr<sf::Vector4f> rgbi;
};

6
include/RayCaster.h
View File

@@ -6,7 +6,6 @@
#include "Camera.h"
#include "LightController.h"
class RayCaster {
public:
@@ -25,7 +24,7 @@ public:
virtual void assign_map(Old_Map *map) = 0;
virtual void assign_camera(Camera *camera) = 0;
virtual void create_viewport(int width, int height, float v_fov, float h_fov) = 0;
virtual void assign_lights(std::vector<LightController::PackedData> *data) = 0;
virtual void assign_lights(std::vector<char> *data) = 0;
virtual void validate() = 0;
// draw will abstract the gl sharing and software rendering
@@ -40,7 +39,8 @@ protected:
Old_Map * map = nullptr;
Camera *camera = nullptr;
std::vector<LightController::PackedData> *lights;
// std::vector<LightController::PackedData> *lights;
std::vector<char> *lights;
int light_count = 0;
sf::Uint8 *viewport_image = nullptr;
sf::Vector4f *viewport_matrix = nullptr;

2
include/Software_Caster.h
View File

@@ -15,7 +15,7 @@ public:
// Both will create the view matrix, view res buffer
void create_viewport(int width, int height, float v_fov, float h_fov) override;
void assign_lights(std::vector<LightController::PackedData> *data) override;
void assign_lights(std::vector<char> *data) override;
void assign_map(Old_Map *map) override;
void assign_camera(Camera *camera) override;
void validate() override;

6
src/Hardware_Caster.cpp
View File

@@ -210,10 +210,10 @@ void Hardware_Caster::create_viewport(int width, int height, float v_fov, float
//
//}
void Hardware_Caster::assign_lights(std::vector<LightController::PackedData> *data) {
void Hardware_Caster::assign_lights(std::vector<char> *data) {
// Get a pointer to the packed light data
this->lights = data;
// this->lights = data;
light_count = static_cast<int>(lights->size());
@@ -223,8 +223,6 @@ void Hardware_Caster::assign_lights(std::vector<LightController::PackedData> *da
create_buffer("light_count", sizeof(int), &light_count);
}
void Hardware_Caster::draw(sf::RenderWindow* window) {

72
src/LightController.cpp
View File

@@ -1,60 +1,36 @@
#pragma once
#include "LightController.h"
#include "Pub_Sub.h"
LightController::LightController(std::shared_ptr<RayCaster> raycaster) :
raycaster(raycaster) {
//packed_index = packed_data.size() / packed_size;
}
//LightController::LightController(std::shared_ptr<RayCaster> raycaster) {
// //:raycaster(raycaster) {
//
//
//
// //packed_index = packed_data.size() / packed_size;
//}
LightController::~LightController() {
}
//void LightController::create_light(LightController::PackedData light_data, std::string light_name) {
//
// //if (light_map.count(light_name) == 1) {
// // // light already exists, TODO: error out
// // return;
// //}
//
//
//}
//LightHandle LightController::get_light_handle(std::string light_name) {
//}
void LightController::set_position(sf::Vector3f position) {
}
int LightController::add_static_impulse(sf::Vector3f impulse) {
return 1;
}
int LightController::add_relative_impulse(DIRECTION impulse_direction, float speed) {
// No sense in doing fancy dot products, adding Pi's will suffice
// Always add PI/2 to X initially to avoid negative case
sf::Vector2f dir;
switch (impulse_direction) {
case DIRECTION::FORWARD:
dir = sf::Vector2f(packed_data_array.at(packed_index).direction_cartesian.y, packed_data_array.at(packed_index).direction_cartesian.x);
break;
case DIRECTION::REARWARD:
dir = sf::Vector2f(packed_data_array.at(packed_index).direction_cartesian.y, packed_data_array.at(packed_index).direction_cartesian.x + PI_F);
break;
case DIRECTION::LEFT:
dir = sf::Vector2f(packed_data_array.at(packed_index).direction_cartesian.y + PI_F + PI_F / 2, PI_F / 2);
break;
case DIRECTION::RIGHT:
dir = sf::Vector2f(packed_data_array.at(packed_index).direction_cartesian.y + PI_F / 2, PI_F / 2);
break;
case DIRECTION::UP:
dir = sf::Vector2f(packed_data_array.at(packed_index).direction_cartesian.y, packed_data_array.at(packed_index).direction_cartesian.x + PI_F / 2);
break;
case DIRECTION::DOWN:
dir = sf::Vector2f(packed_data_array.at(packed_index).direction_cartesian.y + PI_F, (packed_data_array.at(packed_index).direction_cartesian.x * -1) + PI_F / 2);
break;
}
//movement += SphereToCart(dir);
//movement *= speed;
return 1;
}
int LightController::update(double delta_time) {
@@ -99,9 +75,9 @@ void LightController::erase_light() {
//packed_data.emplace_back(PackedData(position, direction, rgbi));
}
std::vector<LightController::PackedData>* LightController::get_lights() {
return &packed_data;
}
//std::vector<LightController::PackedData>* LightController::get_lights() {
// return &packed_data_array;
//}
void LightController::look_at_center() {

18
src/LightHandle.cpp Normal file
View File

@@ -0,0 +1,18 @@
#include "LightHandle.h"
LightHandle::LightHandle() {
// init an empty light
LightController::PackedData data;
data.direction_cartesian = sf::Vector3f(0, 0, 0);
data.position = sf::Vector3f(0, 0, 0);
data.rgbi = sf::Vector4f(0, 0, 0, 0);
//light_controller.create_light(data, light_name);
}
LightHandle::~LightHandle() {
}

4
src/Software_Caster.cpp
View File

@@ -82,9 +82,9 @@ void Software_Caster::create_viewport(int width, int height, float v_fov, float
}
void Software_Caster::assign_lights(std::vector<LightController::PackedData> *data) {
void Software_Caster::assign_lights(std::vector<char> *data) {
this->lights = data;
// this->lights = data;
int light_count = static_cast<int>(data->size());
}

5
src/main.cpp
View File

@@ -130,10 +130,11 @@ int main() {
*/
// Light for the currently non functional Bling Phong shader
LightController l(raycaster);
std::shared_ptr<RayCaster> asdf;
//LightController l(asdf);
// *links* the lights to the GPU
raycaster->assign_lights();
//raycaster->assign_lights();
// Load in the spritesheet texture