Added some documentation on the lights. Got most everything tidied up. Having some issues with std::moving unique ptrs. Going to change them to shared_ptr

include/LightController.h

@@ -9,6 +9,16 @@
 
 struct LightPrototype {
 	
+	LightPrototype(
+		sf::Vector3f position,
+		sf::Vector3f direction_cartesian,
+		sf::Vector4f rgbi
+		) : 
+		position(position), 
+		direction_cartesian(direction_cartesian),
+		rgbi(rgbi) {	};
+
+
 	sf::Vector3f position;
 	sf::Vector3f direction_cartesian;
 	sf::Vector4f rgbi;
@@ -25,9 +35,10 @@ struct PackedData {
 		position(position), direction_cartesian(direction_cartesian), rgbi(rgbi) {
 	}
 	PackedData() {};
+	sf::Vector4f rgbi;
 	sf::Vector3f position;
 	sf::Vector3f direction_cartesian;
-	sf::Vector4f rgbi;
+	
 };
 
 class LightHandle;

include/LightHandle.h

@@ -4,14 +4,28 @@
 #include <memory>
 
 
-// We need to be able to :
+// Light Handle :
-//		- Allow lights to exist outside the context of a LightController
+//	- Contains data relating to movement, and a reference to the rbgi, direction, and position
-//			- i.e we can have a prototype light or similar
+//		elements in the LightController.
-//		- Preserve the existence of lights upon object destruction
+//	- Resultant of the use of LightController.create_light(LightPrototype). Cannot be self instantiated.
-//			- No need to keep track of an object only used upon special use cases
+//	- On deconstruction, light data is removed from the LightController and the light disappears 
-//		- Maintain an X*N byte array, X = size of packed data, N = Light number
+
-//			- But still allow classes of size Y bytes
+// LightPrototype :
-//			- Preserve X packed bytes in an array which are pointed to by an array of shared pointers
+//	- Contains the desired starting values for the light. The LightHandler object will then be
+//		instantiated using this data
+
+// PackedData :
+//	- We need to single out the data that the GPU needs into a single contiguous
+//		array. PackedData holds the values for position, direction, and rgbi
+
+// LightController :
+//	- Contains the PackedData array in a static sized array.
+//		Empty light slots are set to 0 and still sent over the line
+//		TODO: This introduces light limits and inefficiencies
+//	- Contains a factory that takes LightPrototypes and generates unique ptr LightHandles.
+//		Each light handle is given a light index enabling light removal.
+
+
 
 struct LightPrototype;
 class LightController;
@@ -21,29 +35,37 @@ class LightHandle {
 
 public:
 
+	// Allow LightController to access this objects constructor for a factory style pattern
 	friend class LightController;
 
 	~LightHandle();
 
+	// Functions for movement
 	void set_friction(float friction);
 	void set_impulse(float impulse);
 	void set_movement(sf::Vector3f movement);
 	void add_movement(sf::Vector3f movement);
 
+	// Functions modifying the pointed to data
 	void set_position(sf::Vector3f position);
 	void set_direction(sf::Vector3f direction);
 	void set_rgbi(sf::Vector4f rgbi);
 
+	// void update(double delta_time);
+
 private:
 
 	LightHandle(LightController *const light_controller, unsigned int light_id, LightPrototype light_prototype, std::unique_ptr<PackedData> data_reference);
 
+	// Reference to the LightController to handle deconstruction and removal using the light_id
 	LightController *const light_controller_ref;
-	unsigned int light_id;
+	const unsigned int light_id;
 
+	// Movement values provided by the prototype
 	float friction_coefficient = 0.1f;
 	float default_impulse = 1.0f;
 	sf::Vector3f movement;
 
+	// Reference to the packed data in the LightController
 	std::unique_ptr<PackedData> data_reference;
 };

include/raycaster/RayCaster.h

@@ -41,7 +41,7 @@ protected:
 	Old_Map * map = nullptr;
 	Camera *camera = nullptr;
 //	std::vector<LightController::PackedData> *lights;
-	std::vector<char> *lights;
+	std::vector<PackedData> *lights;
 	int light_count = 0;
 	sf::Uint8 *viewport_image = nullptr;
 	sf::Vector4f *viewport_matrix = nullptr;

src/LightController.cpp

@@ -20,7 +20,7 @@ std::unique_ptr<LightHandle> LightController::create_light(LightPrototype light_
 	unsigned int index = open_list.front();
 	open_list.pop_front();
 	
-	std::unique_ptr<PackedData> data(&packed_data_array.at(index));
+	std::unique_ptr<PackedData> data(&packed_data_array.data()[index]);
 
 	std::unique_ptr<LightHandle> handle(new LightHandle(this, index, light_prototype, std::move(data)));
 	

src/LightHandle.cpp

@@ -3,12 +3,18 @@
 
 
 LightHandle::LightHandle(LightController *const light_controller, unsigned int light_id, LightPrototype light_prototype, std::unique_ptr<PackedData> data_reference) :
-	light_controller_ref(light_controller), data_reference(std::move(data_reference)) {
+	light_controller_ref(light_controller), light_id(light_id) {
+
+	data_reference = std::move(data_reference);
 
 	friction_coefficient = light_prototype.friction;
 	default_impulse = light_prototype.impulse;
 	movement = light_prototype.movement;
 
+	data_reference->direction_cartesian = light_prototype.direction_cartesian;
+	data_reference->position = light_prototype.position;
+	data_reference->rgbi = light_prototype.rgbi;
+
 }
 
 

src/main.cpp

@@ -22,6 +22,7 @@
 #include <OpenCL/cl_ext.h>
 #endif
 
+#pragma once
 #include <iostream>
 #include <chrono>
 #include <SFML/Graphics.hpp>
@@ -36,6 +37,7 @@
 #include "Pub_Sub.h"
 #include "NetworkInput.h"
 #include "LightController.h"
+#include "LightHandle.h"
 
 const int WINDOW_X = 1000;
 const int WINDOW_Y = 1000;
@@ -91,8 +93,8 @@ int main() {
 
 	// Start up the raycaster
 	//Hardware_Caster *raycaster = new Hardware_Caster();
-	Hardware_Caster *raycaster = new Hardware_Caster();
+	//Hardware_Caster *raycaster = new Hardware_Caster();
-	//std::shared_ptr<Hardware_Caster> raycaster(new Hardware_Caster());
+	std::shared_ptr<Hardware_Caster> raycaster(new Hardware_Caster());
 	
 	if (raycaster->init() != 1) {
 		abort();
@@ -123,10 +125,17 @@ int main() {
 	float w = 60.0;
 	float h = 90.0;
 
-	/*sf::Vector3f(256.0f, 256.0f, 256.0f),
+
+	LightController light_controller(raycaster);
+	LightPrototype prototype(
+		sf::Vector3f(256.0f, 256.0f, 256.0f),
 		sf::Vector3f(-1.0f, -1.0f, -1.5f),
 		sf::Vector4f(1.0f, 1.0f, 1.0f, 1.0f)
-*/
+	);
+
+	std::unique_ptr<LightHandle> handle = light_controller.create_light(prototype);
+
+	
 
 	// Light for the currently non functional Bling Phong shader
 	//std::unique_ptr<RayCaster> asdf(raycaster);

src/raycaster/Hardware_Caster.cpp

@@ -213,15 +213,15 @@ void Hardware_Caster::create_viewport(int width, int height, float v_fov, float
 void Hardware_Caster::assign_lights(std::vector<PackedData> *data) {
 
 	// Get a pointer to the packed light data
-//	this->lights = data;
+	this->lights = data;
 
 	light_count = static_cast<int>(lights->size());
 
-	cl_uint packed_size = 0;// sizeof(PackedData);
+	cl_uint packed_size = sizeof(PackedData);
 
 	create_buffer("lights", packed_size * light_count, lights->data(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR);
 
-	create_buffer("light_count", sizeof(int), &light_count);
+	create_buffer("light_count", 8, &light_count);
 
 }