reformat of directory structure

David Mayerich
1 parent 0174d823
Showing 26 changed files with 2254 additions and 350 deletions Show diff stats
rts/biology/fibernet.h
rts/cuda/glbind.h
rts/cuda/memory.h
rts/cuda/threads.h
rts/envi/envi.h
rts/envi/envi_header.h
rts/gl/error.h
rts/gl/rtsSourceCode.h
rts/gl/rts_glShaderObject.h
rts/gl/rts_glShaderProgram.h
rts/gl/rts_glShaderUniform.h
rts/gl/rts_glUtilities.h
rts/gl/texture.h
rts/math/complex.h
rts/math/function.h
rts/math/matrix.h
rts/math/point.h
rts/math/quad.h
rts/math/quaternion.h
rts/math/spherical_bessel.h
+#ifndef RTS_GL_BIND_H
+#define RTS_GL_BIND_H
+
+#include <GL/glew.h>
+#include <GL/gl.h>
+
+#include <stdio.h>
+#include <cstring>
+
+#include <cudaHandleError.h>
+#include "cuda_gl_interop.h"
+#include "rts/gl/error.h"
+
+
+static void rtsInitGLEW()
+{
+	//Initialize the GLEW toolkit
+
+	GLenum err = glewInit();
+	if(GLEW_OK != err)
+	{
+		printf("Error starting GLEW.");
+	}
+	fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
+}
+
+static void rts_cudaSetDevice(int major = 1, int minor = 3)
+{
+	cudaDeviceProp prop;
+	int dev;
+
+	//find a CUDA device that can handle an offscreen buffer
+	int num_gpu;
+	HANDLE_ERROR(cudaGetDeviceCount(&num_gpu));
+	printf("Number of CUDA devices detected: %d\n", num_gpu);
+	memset(&prop, 0, sizeof(cudaDeviceProp));
+	prop.major=major;
+	prop.minor=minor;
+	HANDLE_ERROR(cudaChooseDevice(&dev, &prop));
+	HANDLE_ERROR(cudaGetDeviceProperties(&prop, dev));
+	HANDLE_ERROR(cudaGLSetGLDevice(dev));
+}
+
+static void* rts_cudaMapResource(cudaGraphicsResource* cudaBufferResource)
+{
+	//this function takes a predefined CUDA resource and maps it to a pointer
+	void* buffer;
+	HANDLE_ERROR(cudaGraphicsMapResources(1, &cudaBufferResource, NULL));
+	size_t size;
+	HANDLE_ERROR(cudaGraphicsResourceGetMappedPointer( (void**)&buffer, &size, cudaBufferResource));
+	return buffer;
+}
+static void rts_cudaUnmapResource(cudaGraphicsResource* resource)
+{
+	//this function unmaps the CUDA resource so it can be used by OpenGL
+	HANDLE_ERROR(cudaGraphicsUnmapResources(1, &resource, NULL));
+}
+
+static void rts_cudaCreateRenderBuffer(GLuint &glBufferName, cudaGraphicsResource* &cudaBufferResource, int resX, int resY)
+{
+	//delete the previous buffer name and resource
+	if(cudaBufferResource != 0)
+		HANDLE_ERROR(cudaGraphicsUnregisterResource(cudaBufferResource));
+	if(glBufferName != 0)
+		glDeleteBuffers(1, &glBufferName);
+
+	//generate an OpenGL offscreen buffer
+	glGenBuffers(1, &glBufferName);
+
+	//bind the buffer - directs all calls to this buffer
+	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, glBufferName);
+	glBufferData(GL_PIXEL_UNPACK_BUFFER, resX * resY * sizeof(uchar3), NULL, GL_DYNAMIC_DRAW_ARB);
+	CHECK_OPENGL_ERROR
+	HANDLE_ERROR(cudaGraphicsGLRegisterBuffer(&cudaBufferResource, glBufferName, cudaGraphicsMapFlagsNone));
+}
+
+#endif
+#include <cuda.h>
+
+#include "cuda_runtime.h"
+#include "device_launch_parameters.h"
+#include "rts/cuda/callable.h"
+
+#ifndef CUDA_THREADS_H
+#define CUDA_THREADS_H
+
+#define MAX_GRID        65535
+
+__device__ unsigned int ThreadIndex1D()
+{
+    return blockIdx.y * gridDim.x * blockDim.x + blockIdx.x * blockDim.x + threadIdx.x;
+}
+
+dim3 GenGrid1D(unsigned int N, unsigned int blocksize = 128)
+{
+    dim3 dimgrid;
+
+    dimgrid.x = (N + blocksize - 1)/blocksize;
+    dimgrid.y = 1;
+    dimgrid.z = 1;
+
+    if(dimgrid.x > MAX_GRID)
+    {
+        dimgrid.y = (dimgrid.x + MAX_GRID - 1) / MAX_GRID;
+        dimgrid.x = MAX_GRID;
+    }
+
+    return dimgrid;
+
+}
+
+
+#endif
@@ -173,7 +173,7 @@ class EnviFile
             exit(1);
         }
-		float r, v0, v1;
+		float v0, v1;
         for(int n=0; n<N; n++)
         {
 			v0 = ((float*)A)[n];
@@ -72,7 +72,7 @@ struct EnviHeader
 	std::string trim(std::string line)
 	{
 		//trims whitespace from the beginning and end of line
-		int start_i, end_i;
+		unsigned int start_i, end_i;
 		for(start_i=0; start_i < line.length(); start_i++)
 			if(line[start_i] != 32)
 			{
@@ -188,16 +188,12 @@ struct EnviHeader
 	{
 		//this function returns a sequence of comma-delimited strings
 		std::vector<double> result;
-
-		double fentry;
-
 		std::string entry;
 		size_t i;
 		do
 		{
 			i = sequence.find_first_of(',');
 			entry = sequence.substr(0, i);
-			fentry = atof(entry.c_str());
 			sequence = sequence.substr(i+1);
 			result.push_back(atof(entry.c_str()));
 			//std::cout<<entry<<"   ";
@@ -356,7 +352,7 @@ struct EnviHeader
 		if(band_names.size() > 0)
 		{
 			outfile<<"band names = {"<<std::endl;
-			for(int i=0; i<band_names.size(); i++)
+			for(unsigned int i=0; i<band_names.size(); i++)
 			{
 				outfile<<band_names[i];
 				if(i < band_names.size() - 1)
@@ -365,7 +361,7 @@ struct EnviHeader
 			outfile<<"}"<<std::endl;
 		}
 		outfile<<"wavelength = {"<<std::endl;
-			for(int i=0; i<wavelength.size()-1; i++)
+			for(unsigned int i=0; i<wavelength.size()-1; i++)
 				outfile<<wavelength[i]<<", ";
 			outfile<<wavelength.back()<<"}"<<std::endl;
+#ifndef RTS_OPENGL_ERROR
+#define RTS_OPENGL_ERROR
+
+#include <stdio.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#define CHECK_OPENGL_ERROR \
+{ GLenum error; \
+   while ( (error = glGetError()) != GL_NO_ERROR) { \
+   printf( "OpenGL ERROR: %s\nCHECK POINT: %s (line %d)\n", gluErrorString(error), __FILE__, __LINE__ ); \
+   } \
+}
+
+#endif
 \ No newline at end of file
+#ifndef RTSSOURCECODE_H
+#define RTSSOURCECODE_H
+
+#include <string>
+#include <fstream>
+#include <vector>
+#include <iostream>
+
+using namespace std;
+
+///This class defines generic source code that can be loaded from text files.  It is primarily used by the rts_glShaderProgram class for GLSL programming.
+
+class rtsSourceCode
+{
+public:
+	vector<string> source;			//the actual source code
+	void clear()					///<Clears any current source code from the class.
+	{
+		source.clear();
+	}
+	void LoadSource(const char* filename)	///<Loads source code from a specified file.
+	{
+		ifstream infile;		//create an input file
+		infile.open(filename);	//load the specified file
+	
+		if(!infile.is_open())	//if the file is not open, exit
+		{
+			return;
+		}
+		source.clear();			//remove any previous code
+
+		while(!infile.eof())
+		{
+			string current_line;		
+			getline(infile, current_line);
+			current_line += '\n';
+			source.push_back(current_line);
+		}
+	}
+	rtsSourceCode(const char* filename)	///<Constructor creates the class and loads source code from the specified file.
+	{
+		LoadSource(filename);
+	}
+	rtsSourceCode(){}						///<Constructor creates a blank class.
+	rtsSourceCode& operator+=(const rtsSourceCode& rhs)
+	{
+		int lines = rhs.source.size();
+		for(int l=0; l<lines; l++)
+			source.push_back(rhs.source[l]);
+		return *this;
+	}
+	rtsSourceCode& operator+=(const string& rhs)
+	{
+		source.push_back(rhs);
+		return *this;
+	}
+	void ConsoleOut()						///<Sends the source code to the standard output.
+	{
+		unsigned int lines = source.size();
+		for(unsigned int l = 0; l<lines; l++)
+			cout<<l<<":  "<<source[l];
+	}
+};
+
+#endif
 \ No newline at end of file
+#ifndef RTS_GLSHADERS
+#define RTS_GLSHADERS
+
+#include <GL/glew.h>
+//#include "windows.h"
+#include <GL/gl.h>
+#include "rtsSourceCode.h"
+
+class rts_glShaderObject
+{
+private:
+	void init()
+	{
+		id = 0;
+		compiled = false;
+		type = GL_FRAGMENT_SHADER;
+	}
+public:
+	bool compiled;
+	GLenum type;
+	rtsSourceCode source;
+	GLuint id;
+	string log;
+
+	rts_glShaderObject(GLenum type, const char* filename)
+	{
+		init();					//initialize the shader
+		SetType(type);	//set the shader type
+		LoadSource(filename);	//load the source code
+	}
+	rts_glShaderObject(GLenum type, rtsSourceCode sourceCode)
+	{
+		init();					//initialize the shader
+		SetType(type);	//set the shader type
+		source = sourceCode;
+	}
+	rts_glShaderObject()
+	{
+		init();
+	}
+	rts_glShaderObject(GLenum type)
+	{
+		init();
+		SetType(type);
+	}
+	void LoadSource(const char* filename)
+	{
+		source = rtsSourceCode(filename);	//get the shader source code
+
+	}
+	void SetType(GLenum type)
+	{
+		if(id != 0)					//if a shader currently exists, delete it
+		{
+			glDeleteShader(id);
+			id = 0;
+		}
+		type = type;
+		id = glCreateShader(type);		//create a shader object
+		if(id == 0)						//if a shader was not created, log an error
+		{
+			log = "Error getting shader ID from OpenGL";
+			return;
+		}
+	}
+	void UploadSource()
+	{
+		//create the structure for the shader source code
+		GLsizei count = source.source.size();
+		GLchar** code_string = new GLchar*[count];
+		GLint* length = new GLint[count];
+		for(int l = 0; l<count; l++)	//for each line of code
+		{
+			length[l] = source.source[l].size();
+			code_string[l] = new GLchar[length[l]];	//copy the string into a new structure
+			source.source[l].copy(code_string[l], (unsigned int)length[l]);
+
+		}
+		glShaderSource(id, count, (const GLchar**)code_string, length);		//attach the shader source
+	}
+	void Compile()
+	{
+		/*
+		This function compiles the shader source code, records any errors to a log, and sets the compiled flag.
+		*/
+		//send the source code to the GPU
+		UploadSource();
+
+		//compile the shader
+		glCompileShader(id);												//compile the shader
+		GLint compile_status;
+		glGetShaderiv(id, GL_COMPILE_STATUS, &compile_status);				//get the compile status
+		if(compile_status != GL_TRUE)	//if there was an error
+		{
+			GLchar buffer[1000];		//create a log buffer
+			GLsizei length;
+			glGetShaderInfoLog(id, 1000, &length, buffer);	//get the log
+			log = buffer;
+			compiled = false;
+		}
+		else
+			compiled = true;
+
+	}
+	void PrintLog()
+	{
+		cout<<log;
+		if(log.size() != 0) cout<<endl;
+	}
+	void Clean(){if(id != 0) glDeleteShader(id);}
+};
+
+
+
+#endif
+#ifndef RTS_GLSHADERPROGRAM_H
+#define RTS_GLSHADERPROGRAM_H
+
+/*********************************************************
+//create a shader program
+	rts_glShaderProgram myProgram;
+//initialize
+	myProgram.Init();
+//Attach shaders
+	myProgram.AttachShader(GL_FRAGMENT_SHADER, "filename.glsl");
+//Compile and link
+	myProgram.Compile();
+	myProgram.Link();
+	myProgram.PrintLog();
+//attach uniform variables
+	myProgram.AttachTextureMap("texture", texture);
+	myProgram.AttachGlobalUniform("light_intensity", &intensity);
+
+//use the program
+	myProgram.BeginProgram();
+	//render
+	myProgram.EndProgram();
+**********************************************************/
+
+
+#include "rts_glShaderObject.h"
+#include "rts_glShaderUniform.h"
+#include "rts_glTextureMap.h"
+#include <algorithm>
+
+using namespace std;
+
+class rts_glShaderProgram
+{
+private:
+	void get_uniforms()
+	{
+		GLint num_uniforms;
+		glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &num_uniforms);		//get the number of uniform variables
+		GLint max_name_length;
+		glGetProgramiv(id, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_name_length);	//get the maximum uniform name length
+		GLchar* name_buffer = new GLchar[max_name_length];			//create a buffer to store the name
+		GLsizei length;						//I'm not using these yet
+		GLint size;
+		GLenum type;						//variable's data type
+		GLint location;						//GPU location of the variable
+		for(int i=0; i<num_uniforms; i++)		//create an rts_glShaderUniform structure for each variable
+		{
+			glGetActiveUniform(id, i, max_name_length, &length, &size, &type, name_buffer);	//get the uniform information
+			location = glGetUniformLocation(id, name_buffer);		//get the GPU location of the variable
+			//create the rts_glShaderUniform structure
+			rts_glShaderUniform current;
+			current.location = location;
+			current.name = name_buffer;
+			current.type = type;
+			current.p_value = NULL;
+
+
+			uniform_list.push_back(current);
+		}
+
+	}
+	int get_index(const char* name)
+	{
+		unsigned int size = uniform_list.size();
+		for(unsigned int i=0; i<size; i++)
+		{
+			if(uniform_list[i].name == name)
+				return i;
+		}
+		return -1;
+	}
+	string log;
+public:
+	GLuint id;
+	bool linked;
+	vector<rts_glShaderObject> shader_list;	//list of opengl shaders
+	vector<rts_glShaderUniform> uniform_list;	//list of active uniform variables
+	vector<rts_glTextureMap> texture_list;		//list of texture maps
+
+	rts_glShaderProgram()
+	{
+		linked = false;
+		id = 0;
+	}
+	void AttachShader(rts_glShaderObject shader)
+	{
+		if(id == 0)
+		{
+			Init();
+		}
+		if(shader.id == 0)	//if the shader is invalid
+		{
+			log = "Shader is invalid";
+			return;
+		}
+
+		//attach the shader to the program
+		glAttachShader(id, shader.id);			//attach the shader to the program in OpenGL
+		CHECK_OPENGL_ERROR
+		shader_list.push_back(shader);			//push the shader onto our list for later access
+	}
+	//type = GL_FRAGMENT_SHADER or GL_VERTEX_SHADER
+	void AttachShader(GLenum type, const char* filename)
+	{
+		rts_glShaderObject shader(type, filename);
+		AttachShader(shader);
+	}
+	void AttachShader(GLenum type, rtsSourceCode source)
+	{
+		rts_glShaderObject shader(type, source);
+		AttachShader(shader);
+	}
+	void PrintLog()
+	{
+		cout<<log;
+
+		if(log.size() != 0) cout<<endl;
+	}
+	void Compile()
+	{
+		if(shader_list.size() == 0)
+		{
+			log = "No shaders to compile";
+			return;
+		}
+
+		vector<rts_glShaderObject>::iterator iter;
+		for(iter = shader_list.begin(); iter != shader_list.end(); iter++)
+		{
+			(*iter).Compile();
+			//(*iter).PrintLog();
+		}
+	}
+	void Link()
+	{
+		glLinkProgram(id);				//link the current shader program
+		GLint link_status;				//test to see if the link went alright
+		glGetProgramiv(id, GL_LINK_STATUS, &link_status);
+		if(link_status != GL_TRUE)
+		{
+			linked = false;
+		}
+		else
+			linked = true;
+
+		GLsizei length;
+		GLchar buffer[1000];
+		glGetProgramInfoLog(id, 1000, &length, buffer);
+		log = buffer;
+
+		get_uniforms();			//create the list of active uniform variables
+	}
+	void BeginProgram()
+	{
+		CHECK_OPENGL_ERROR
+		if(id == 0)				//if the program is invalid, return
+		{
+			log = "Invalid program, cannot use.";
+			return;
+		}
+		if(!linked)
+		{
+			cout<<"Shader Program used without being linked."<<endl;
+			//exit(1);
+		}
+
+		//set up all of the texture maps
+		int num_textures = texture_list.size();
+
+		for(int t=0; t<num_textures; t++)
+		{
+			glActiveTexture(GL_TEXTURE0 + t);
+			CHECK_OPENGL_ERROR
+			//glEnable(texture_list[t].texture_type);
+			//CHECK_OPENGL_ERROR
+			glBindTexture(texture_list[t].texture_type, texture_list[t].name);
+			CHECK_OPENGL_ERROR
+		}
+
+		glUseProgram(id);
+		CHECK_OPENGL_ERROR
+	}
+	void EndProgram()
+	{
+		CHECK_OPENGL_ERROR
+		//return standard functionality
+		int num_textures = texture_list.size();
+
+		//disable all texture units
+		for(int t=0; t<num_textures; t++)
+		{
+			glActiveTexture(GL_TEXTURE0 + t);
+			glDisable(texture_list[t].texture_type);
+			CHECK_OPENGL_ERROR
+		}
+		//make sure that the single default texture unit is active
+		if(num_textures > 0)
+			glActiveTexture(GL_TEXTURE0);
+		CHECK_OPENGL_ERROR
+
+		//return to OpenGL default shading
+		glUseProgram(0);
+		CHECK_OPENGL_ERROR
+	}
+	void PrintUniforms()
+	{
+		cout<<"Shader Uniforms: "<<endl;
+		unsigned int i;
+		for(i=0; i<uniform_list.size(); i++)
+		{
+			cout<<i<<":  "<<uniform_list[i].name<<"          "<<uniform_list[i].location<<endl;
+		}
+	}
+	void AttachGlobalUniform(unsigned int index, void* param)		//attaches a global variable to the indexed uniform parameter
+	{
+		uniform_list[index].p_value = param;
+	}
+	void AttachGlobalUniform(const char* name, void* param)
+	{
+		//find the index of the shader
+		int index = get_index(name);
+		if(index != -1)
+			AttachGlobalUniform(index, param);
+		else
+		{
+			string strError = "Error finding uniform variable: ";
+			strError += name;
+			cout<<strError<<endl;
+		}
+	}
+	void AttachTextureMap(unsigned int index, rts_glTextureMap texture)	//attaches a texture map to the program
+	{
+		//if there is not a texture map assigned to the variable
+		if(uniform_list[index].p_value == NULL)
+		{
+			uniform_list[index].p_value = new unsigned int[1];
+			((unsigned int*)uniform_list[index].p_value)[0] = texture_list.size();		//set the parameter value to the index of the texture
+			texture_list.push_back(texture);						//add the texture to the texture list
+		}
+		//if there is a texture map assigned, replace it
+		else
+		{
+			texture_list[((unsigned int*)(uniform_list[index].p_value))[0]] = texture;
+		}
+
+	}
+	void AttachTextureMap(const char* name, rts_glTextureMap texture)
+	{
+		int index = get_index(name);
+		if(index != -1)		//make sure that the uniform index is valid
+			AttachTextureMap(index, texture);
+		else
+			cout<<"Error finding texture index.  Try linking."<<endl;
+	}
+	void UpdateGlobalUniforms()									//sends updated uniform information to the GPU
+	{
+		CHECK_OPENGL_ERROR
+		BeginProgram();
+		CHECK_OPENGL_ERROR
+		unsigned int num = uniform_list.size();
+		for(unsigned int i=0; i<num; i++)
+			uniform_list[i].submit_to_gpu();
+		EndProgram();
+	}
+	void Init()	//Initialize the shader program
+	{
+		CHECK_OPENGL_ERROR
+		if(id != 0)
+			Clean();
+		id = glCreateProgram();
+		if(id == 0)
+			log = "Error getting program ID from OpenGL";
+		CHECK_OPENGL_ERROR
+	}
+	void Clean()
+	{
+		if(id != 0)
+			glDeleteProgram(id);
+		id = 0;
+
+		//these are allocated outside the object and can just be cleared
+		uniform_list.clear();
+		texture_list.clear();
+
+		//delete each shader from OpenGL
+		int num_shad = shader_list.size();
+		for(int i=0; i<num_shad; i++)
+			shader_list[i].Clean();
+		//clear the list
+		shader_list.clear();
+	}
+};
+
+#endif
+#ifndef RTS_GLSHADERUNIFORM_H
+#define RTS_GLSHADERUNIFORM_H
+
+#include "CHECK_OPENGL_ERROR.h"
+#include <GL/glew.h>
+#include <string>
+
+using namespace std;
+
+enum rtsUniformEnum {RTS_FLOAT, RTS_INT, RTS_BOOL, RTS_FLOAT_MATRIX};
+
+///This class stores a single uniform variable for GLSL and is designed to be used by the rts_glShaderProgram class.
+struct rts_glShaderUniform
+{
+public:
+	string name;		//the name of the variable
+	GLint location;		//the location in the program
+	void* p_value;		//pointer to the global data representing the value in main memory
+	GLenum type;		//variable type (float, int, vec2, etc.)
+	//rtsUniformEnum rts_type;	//type of variable in rts format
+	//unsigned int num;		//the number of values required by the variable (1 for float, 2 for vec2, etc.)
+	string log;
+
+	//void convert_type(GLenum gl_type);		//converts the OpenGL data type to something useful for rts
+	void submit_to_gpu()
+	{
+		if(location < 0)
+			return;
+		if(p_value == NULL)
+		{
+			cout<<"Error in uniform address: "<<name<<endl;
+			return;
+		}
+	
+
+		CHECK_OPENGL_ERROR
+		switch(type)
+		{
+		case GL_FLOAT:
+			glUniform1fv(location, 1, (float*)p_value);
+			break;
+		case GL_FLOAT_VEC2:
+			glUniform2fv(location, 1, (float*)p_value);
+			break;
+		case GL_FLOAT_VEC3:
+			glUniform3fv(location, 1, (float*)p_value);
+			break;
+		case GL_FLOAT_VEC4:
+			glUniform4fv(location, 1, (float*)p_value);
+			break;
+		case GL_INT:
+			glUniform1iv(location, 1, (int*)p_value);
+			break;
+		case GL_INT_VEC2:
+			glUniform2iv(location, 1, (int*)p_value);
+			break;
+		case GL_INT_VEC3:
+			glUniform3iv(location, 1, (int*)p_value);
+			break;
+		case GL_INT_VEC4:
+			glUniform4iv(location, 1, (int*)p_value);
+			break;
+		case GL_BOOL:
+			glUniform1iv(location, 1, (int*)p_value);
+			break;
+		case GL_BOOL_VEC2:
+			glUniform2iv(location, 1, (int*)p_value);
+			break;
+		case GL_BOOL_VEC3:
+			glUniform3iv(location, 1, (int*)p_value);
+			break;
+		case GL_BOOL_VEC4:
+			glUniform4iv(location, 1, (int*)p_value);
+			break;
+		case GL_FLOAT_MAT2:
+			glUniformMatrix2fv(location, 1, GL_FALSE, (float*)p_value);
+			break;
+		case GL_FLOAT_MAT3:
+			glUniformMatrix3fv(location, 1, GL_FALSE, (float*)p_value);
+			break;
+		case GL_FLOAT_MAT4:
+			glUniformMatrix4fv(location, 1, GL_FALSE, (float*)p_value);
+			break;
+		case GL_SAMPLER_1D:
+		case GL_SAMPLER_2D:
+		case GL_SAMPLER_3D:
+		case GL_SAMPLER_CUBE:
+		case GL_SAMPLER_1D_SHADOW:
+		case GL_SAMPLER_2D_SHADOW:
+		default:
+			glUniform1iv(location, 1, (int*)p_value);
+			break;
+		}
+		CHECK_OPENGL_ERROR
+	}
+	rts_glShaderUniform()
+	{
+		location = -1;
+		p_value = NULL;
+	}
+};
+
+
+
+#endif
 \ No newline at end of file
+#ifndef RTS_GLUTILITIES_H
+#define RTS_GLUTILITIES_H
+
+
+#define CHECK_OPENGL_ERROR \
+{ GLenum error; \
+   while ( (error = glGetError()) != GL_NO_ERROR) { \
+   printf( "OpenGL ERROR: %s\nCHECK POINT: %s (line %d)\n", gluErrorString(error), __FILE__, __LINE__ ); \
+   } \
+} 
+
+#endif
 \ No newline at end of file
+#ifndef RTS_GLTEXTUREMAP_H
+#define RTS_GLTEXTUREMAP_H
+
+//#include <GL/glew.h>
+#include "rts/math/vector.h"
+#include "rts/gl/error.h"
+#include <stdlib.h>
+
+namespace rts{
+
+///This class stores an OpenGL texture map and is used by rts_glShaderProgram.
+class glTexture
+{
+private:
+	void get_type()			//guesses the texture type based on the size
+	{
+		if(size[1] == 0)
+			texture_type = GL_TEXTURE_1D;
+		else if(size[2] == 0)
+			texture_type = GL_TEXTURE_2D;
+		else
+			texture_type = GL_TEXTURE_3D;
+	}
+	void set_wrapping()		//set the texture wrapping based on the dimensions
+	{
+		CHECK_OPENGL_ERROR
+		switch(texture_type)
+		{
+		case GL_TEXTURE_3D:
+			glTexParameteri(texture_type, GL_TEXTURE_WRAP_R_EXT, GL_REPEAT);
+		case GL_TEXTURE_2D:
+			glTexParameteri(texture_type, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
+		case GL_TEXTURE_1D:
+			glTexParameteri(texture_type, GL_TEXTURE_WRAP_S, GL_REPEAT);
+			break;
+		case GL_TEXTURE_RECTANGLE_ARB:
+			glTexParameteri(texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+			glTexParameteri(texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			break;
+
+		default:
+			break;
+		}
+		CHECK_OPENGL_ERROR
+	}
+	//void set_bits(GLvoid* bits);
+public:
+	vector<GLsizei, 3> size;		//vector representing the size of the texture
+	GLuint name;				//texture name assigned by OpenGL
+	GLenum texture_type;				//1D, 2D, 3D
+	GLint internal_format;	//number of components (ex. 4 for RGBA)
+	GLenum pixel_format;		//type of data (RGBA, LUMINANCE)
+	GLenum data_type;			//data type of the bits (float, int, etc.)
+
+	//constructor
+	glTexture()
+	{
+		name = 0;
+	}
+	glTexture(GLvoid *bits,
+			   GLenum type = GL_TEXTURE_2D,
+			   GLsizei width = 256,
+			   GLsizei height = 256,
+			   GLsizei depth = 0,
+			   GLint internalformat = 1,
+			   GLenum format = GL_LUMINANCE,
+			   GLenum datatype = GL_UNSIGNED_BYTE,
+			   GLint interpolation = GL_LINEAR)
+    {
+        init(bits, type, width, height, depth, internalformat, format, datatype, interpolation);
+    }
+
+	void begin()
+	{
+		glEnable(texture_type);
+		CHECK_OPENGL_ERROR
+		glBindTexture(texture_type, name);
+		CHECK_OPENGL_ERROR
+	}
+	void end()
+	{
+		glDisable(texture_type);
+		CHECK_OPENGL_ERROR
+	}
+
+	///Creates an OpenGL texture map. This function requires basic information about the texture map as well as a pointer to the bit data describing the texture.
+	void init(GLvoid *bits,
+			   GLenum type = GL_TEXTURE_2D,
+			   GLsizei width = 256,
+			   GLsizei height = 256,
+			   GLsizei depth = 0,
+			   GLint internalformat = 1,
+			   GLenum format = GL_LUMINANCE,
+			   GLenum datatype = GL_UNSIGNED_BYTE,
+			   GLint interpolation = GL_LINEAR)
+	{
+		CHECK_OPENGL_ERROR
+		if(name != 0)
+			glDeleteTextures(1, &name);
+
+
+		CHECK_OPENGL_ERROR
+		if(datatype == GL_FLOAT)
+		{
+			glPixelStorei(GL_PACK_ALIGNMENT, 4);
+			glPixelStorei(GL_UNPACK_ALIGNMENT, 4);				//I honestly don't know what this does but it fixes problems
+		}
+		else if(datatype == GL_UNSIGNED_BYTE)
+		{
+			//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+			//glPixelStorei(GL_PACK_ALIGNMENT, 1);
+		}
+		else if(datatype == GL_UNSIGNED_SHORT)
+		{
+			//glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
+			//glPixelStorei(GL_PACK_ALIGNMENT, 2);
+		}
+		CHECK_OPENGL_ERROR
+		glGenTextures(1, &name);							//get the texture name from OpenGL
+		//cout<<"OpenGL Name: "<<name<<endl;
+		CHECK_OPENGL_ERROR
+		size = vector<GLsizei, 3>(width, height, depth);		//assign the texture size
+		//get_type();											//guess the type based on the size
+		texture_type = type;						//set the type of texture
+		glEnable(texture_type);						//enable the texture map
+		CHECK_OPENGL_ERROR
+		glBindTexture(texture_type, name);							//bind the texture for editing
+		CHECK_OPENGL_ERROR
+		set_wrapping();										//set the texture wrapping parameters
+		CHECK_OPENGL_ERROR
+		glTexParameteri(texture_type, GL_TEXTURE_MAG_FILTER, interpolation);		//set filtering
+		CHECK_OPENGL_ERROR
+		glTexParameteri(texture_type, GL_TEXTURE_MIN_FILTER, interpolation);
+		CHECK_OPENGL_ERROR
+		internal_format = internalformat;					//set the number of components per pixel
+		pixel_format = format;								//set the pixel format
+		data_type = datatype;									//set the data type
+		SetBits(bits);										//send the bits to the OpenGL driver
+		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);	//replace the specified vertex color
+		CHECK_OPENGL_ERROR
+		glDisable(texture_type);
+
+		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+	}
+	void Clean()
+	{
+		if(name != 0)
+		{
+			glDeleteTextures(1, &name);
+			CHECK_OPENGL_ERROR
+			name = 0;
+		}
+	}
+	void SetBits(GLvoid *bits)
+	{
+		glEnable(texture_type);						//enable the texture map
+		CHECK_OPENGL_ERROR
+		glBindTexture(texture_type, name);
+		CHECK_OPENGL_ERROR
+
+		switch(texture_type)
+		{
+		case GL_TEXTURE_3D:
+			glTexImage3D(texture_type, 0, internal_format, size[0], size[1], size[2], 0, pixel_format, data_type, bits);
+			CHECK_OPENGL_ERROR
+			break;
+		case GL_TEXTURE_2D:
+		case GL_TEXTURE_RECTANGLE_ARB:
+			glTexImage2D(texture_type, 0, internal_format, size[0], size[1], 0, pixel_format, data_type, bits);
+			CHECK_OPENGL_ERROR
+			break;
+		case GL_TEXTURE_1D:
+			glTexImage1D(texture_type, 0, internal_format, size[0], 0, pixel_format, data_type, bits);
+			CHECK_OPENGL_ERROR
+			break;
+		default:
+			//glTexImage2D(texture_type, 0, internal_format, size.x, size.y, 0, pixel_format, data_type, bits);
+			break;
+		}
+		CHECK_OPENGL_ERROR
+	}
+	void ResetBits(GLvoid *bits)
+	{
+		glEnable(texture_type);						//enable the texture map
+		CHECK_OPENGL_ERROR
+		glBindTexture(texture_type, name);
+		CHECK_OPENGL_ERROR
+
+		switch(texture_type)
+		{
+		case GL_TEXTURE_3D:
+			//glTexImage3D(texture_type, 0, internal_format, size.x, size.y, size.z, 0, pixel_format, data_type, bits);
+			break;
+		case GL_TEXTURE_2D:
+		case GL_TEXTURE_RECTANGLE_ARB:
+			glTexSubImage2D(texture_type, 0, 0, 0, size[0], size[1], pixel_format, data_type, bits);
+			CHECK_OPENGL_ERROR
+			break;
+		case GL_TEXTURE_1D:
+			//glTexImage1D(texture_type, 0, internal_format, size.x, 0, pixel_format, data_type, bits);
+			break;
+		default:
+			//glTexImage2D(texture_type, 0, internal_format, size.x, size.y, 0, pixel_format, data_type, bits);
+			break;
+		}
+		glDisable(texture_type);
+		CHECK_OPENGL_ERROR
+	}
+	void* GetBits(GLenum format, GLenum type)
+	{
+		//returns the texture data
+
+		int components;
+		switch(format)
+		{
+		case GL_RED:
+		case GL_GREEN:
+		case GL_BLUE:
+		case GL_ALPHA:
+		case GL_LUMINANCE:
+			components = 1;
+			break;
+		case GL_LUMINANCE_ALPHA:
+			components = 2;
+			break;
+		case GL_RGB:
+		case GL_BGR:
+			components = 3;
+			break;
+		case GL_RGBA:
+		case GL_BGRA:
+			components = 4;
+			break;
+		}
+
+		int type_size;
+		switch(type)
+		{
+		case GL_UNSIGNED_BYTE:
+		case GL_BYTE:
+			type_size = sizeof(char);
+			break;
+		case GL_UNSIGNED_SHORT:
+		case GL_SHORT:
+			type_size = sizeof(short);
+			break;
+		case GL_UNSIGNED_INT:
+		case GL_INT:
+			type_size = sizeof(int);
+			break;
+		case GL_FLOAT:
+			type_size = sizeof(float);
+			break;
+		}
+
+		//allocate memory for the texture
+		void* result = malloc(components*type_size * size[0] * size[1]);
+
+		begin();
+		glGetTexImage(texture_type, 0, format, type, result);
+
+		CHECK_OPENGL_ERROR
+		end();
+
+
+		return result;
+
+	}
+};
+
+}
+
+#define RTS_UNKNOWN				0
+
+#endif
@@ -15,12 +15,12 @@ namespace rts
 {
 template <class T>
-struct rtsComplex
+struct complex
 {
     T r, i;
     //default constructor
-    CUDA_CALLABLE rtsComplex()
+    CUDA_CALLABLE complex()
     {
         r = 0.0;
 		i = 0.0;
@@ -49,16 +49,16 @@ struct rtsComplex
 	}
     //constructor when given real and imaginary values
-    CUDA_CALLABLE rtsComplex(T r, T i)
+    CUDA_CALLABLE complex(T r, T i)
     {
         this->r = r;
         this->i = i;
     }
     //return the current value multiplied by i
-    CUDA_CALLABLE rtsComplex<T> imul()
+    CUDA_CALLABLE complex<T> imul()
     {
-        rtsComplex<T> result;
+        complex<T> result;
         result.r = -i;
         result.i = r;
@@ -68,70 +68,70 @@ struct rtsComplex
 	//ARITHMETIC OPERATORS--------------------
     //binary + operator (returns the result of adding two complex values)
-    CUDA_CALLABLE rtsComplex<T> operator+ (const rtsComplex<T> rhs)
+    CUDA_CALLABLE complex<T> operator+ (const complex<T> rhs)
     {
-        rtsComplex<T> result;
+        complex<T> result;
         result.r = r + rhs.r;
         result.i = i + rhs.i;
         return result;
     }
-	CUDA_CALLABLE rtsComplex<T> operator+ (const T rhs)
+	CUDA_CALLABLE complex<T> operator+ (const T rhs)
     {
-        rtsComplex<T> result;
+        complex<T> result;
         result.r = r + rhs;
         result.i = i;
         return result;
     }
     //binary - operator (returns the result of adding two complex values)
-    CUDA_CALLABLE rtsComplex<T> operator- (const rtsComplex<T> rhs)
+    CUDA_CALLABLE complex<T> operator- (const complex<T> rhs)
     {
-        rtsComplex<T> result;
+        complex<T> result;
         result.r = r - rhs.r;
         result.i = i - rhs.i;
         return result;
     }
     //binary - operator (returns the result of adding two complex values)
-    CUDA_CALLABLE rtsComplex<T> operator- (const T rhs)
+    CUDA_CALLABLE complex<T> operator- (const T rhs)
     {
-        rtsComplex<T> result;
+        complex<T> result;
         result.r = r - rhs;
         result.i = i;
         return result;
     }
     //binary MULTIPLICATION operators (returns the result of multiplying complex values)
-    CUDA_CALLABLE rtsComplex<T> operator* (const rtsComplex<T> rhs)
+    CUDA_CALLABLE complex<T> operator* (const complex<T> rhs)
     {
-        rtsComplex<T> result;
+        complex<T> result;
         result.r = r * rhs.r - i * rhs.i;
         result.i = r * rhs.i + i * rhs.r;
         return result;
     }
-    CUDA_CALLABLE rtsComplex<T> operator* (const T rhs)
+    CUDA_CALLABLE complex<T> operator* (const T rhs)
     {
-        return rtsComplex<T>(r * rhs, i * rhs);
+        return complex<T>(r * rhs, i * rhs);
     }
     //binary DIVISION operators (returns the result of dividing complex values)
-    CUDA_CALLABLE rtsComplex<T> operator/ (const rtsComplex<T> rhs)
+    CUDA_CALLABLE complex<T> operator/ (const complex<T> rhs)
     {
-        rtsComplex<T> result;
+        complex<T> result;
         T denom = rhs.r * rhs.r + rhs.i * rhs.i;
         result.r = (r * rhs.r + i * rhs.i) / denom;
         result.i = (- r * rhs.i + i * rhs.r) / denom;
         return result;
     }
-    CUDA_CALLABLE rtsComplex<T> operator/ (const T rhs)
+    CUDA_CALLABLE complex<T> operator/ (const T rhs)
     {
-        return rtsComplex<T>(r / rhs, i / rhs);
+        return complex<T>(r / rhs, i / rhs);
     }
     //ASSIGNMENT operators-----------------------------------
-    CUDA_CALLABLE rtsComplex<T> & operator=(const rtsComplex<T> &rhs)
+    CUDA_CALLABLE complex<T> & operator=(const complex<T> &rhs)
     {
         //check for self-assignment
         if(this != &rhs)
@@ -141,7 +141,7 @@ struct rtsComplex
         }
         return *this;
     }
-    CUDA_CALLABLE rtsComplex<T> & operator=(const T &rhs)
+    CUDA_CALLABLE complex<T> & operator=(const T &rhs)
     {
         this->r = rhs;
         this->i = 0;
@@ -150,34 +150,34 @@ struct rtsComplex
     }
     //arithmetic assignment operators
-    CUDA_CALLABLE rtsComplex<T> operator+=(const rtsComplex<T> &rhs)
+    CUDA_CALLABLE complex<T> operator+=(const complex<T> &rhs)
     {
 		*this = *this + rhs;
         return *this;
     }
-    CUDA_CALLABLE rtsComplex<T> operator+=(const T &rhs)
+    CUDA_CALLABLE complex<T> operator+=(const T &rhs)
     {
 		*this = *this + rhs;
         return *this;
     }
-    CUDA_CALLABLE rtsComplex<T> operator*=(const rtsComplex<T> &rhs)
+    CUDA_CALLABLE complex<T> operator*=(const complex<T> &rhs)
     {
 		*this = *this * rhs;
         return *this;
     }
-	CUDA_CALLABLE rtsComplex<T> operator*=(const T &rhs)
+	CUDA_CALLABLE complex<T> operator*=(const T &rhs)
     {
 		*this = *this * rhs;
         return *this;
     }
 	//divide and assign
-	CUDA_CALLABLE rtsComplex<T> operator/=(const rtsComplex<T> &rhs)
+	CUDA_CALLABLE complex<T> operator/=(const complex<T> &rhs)
     {
 		*this = *this / rhs;
         return *this;
     }
-    CUDA_CALLABLE rtsComplex<T> operator/=(const T &rhs)
+    CUDA_CALLABLE complex<T> operator/=(const T &rhs)
     {
 		*this = *this / rhs;
         return *this;
@@ -189,9 +189,9 @@ struct rtsComplex
 		return std::sqrt(r * r + i * i);
 	}
-	CUDA_CALLABLE rtsComplex<T> log()
+	CUDA_CALLABLE complex<T> log()
 	{
-        rtsComplex<T> result;
+        complex<T> result;
         result.r = std::log(std::sqrt(r * r + i * i));
         result.i = std::atan2(i, r);
@@ -199,9 +199,9 @@ struct rtsComplex
         return result;
 	}
-	CUDA_CALLABLE rtsComplex<T> exp()
+	CUDA_CALLABLE complex<T> exp()
 	{
-        rtsComplex<T> result;
+        complex<T> result;
         T e_r = std::exp(r);
         result.r = e_r * std::cos(i);
@@ -216,18 +216,18 @@ struct rtsComplex
         return pow((double)y);
 	}*/
-	CUDA_CALLABLE rtsComplex<T> pow(T y)
+	CUDA_CALLABLE complex<T> pow(T y)
 	{
-        rtsComplex<T> result;
+        complex<T> result;
         result = log() * y;
         return result.exp();
 	}
-	CUDA_CALLABLE rtsComplex<T> sqrt()
+	CUDA_CALLABLE complex<T> sqrt()
 	{
-		rtsComplex<T> result;
+		complex<T> result;
 		//convert to polar coordinates
 		T a = std::sqrt(r*r + i*i);
@@ -253,7 +253,7 @@ struct rtsComplex
 	}
 	//COMPARISON operators
-	CUDA_CALLABLE bool operator==(rtsComplex<T> rhs)
+	CUDA_CALLABLE bool operator==(complex<T> rhs)
 	{
         if(r == rhs.r && i == rhs.i)
             return true;
@@ -267,72 +267,44 @@ struct rtsComplex
         return false;
     }
-	/*//FRIEND functions
-    //unary minus operator (for negating the complex number)
-	template<class A> CUDA_CALLABLE friend complex<A> operator-(const complex<A> &rhs);
-
-	//multiplication by T values when the complex number isn't on the left hand side
-	template<class A> CUDA_CALLABLE friend complex<A> operator*(const A a, const complex<A> b);
-
-	//division by T values when the complex number isn't on the left hand side
-	template<class A> CUDA_CALLABLE friend complex<A> operator/(const A a, const complex<A> b);
-
-	//POW function
-	//template<class A> CUDA_CALLABLE friend complex<A> pow(const complex<A> x, T y);
-	template<class A> CUDA_CALLABLE friend complex<A> pow(const complex<A> x, int y);
-
-	//log function
-	template<class A> CUDA_CALLABLE friend complex<A> log(complex<A> x);
-
-	//exp function
-	template<class A> CUDA_CALLABLE friend complex<A> exp(complex<A> x);
-
-	//sqrt function
-	template<class A> CUDA_CALLABLE friend complex<A> sqrt(complex<A> x);
-