implemented quad

CMakeLists.txt

@@ -6,6 +6,10 @@ include_directories(/usr/include/glm)
 include_directories(/usr/include/glad)
 
 set(CMAKE_BUILD_TYPE Debug)
+set(math quaternion.cpp vector.cpp)
+set(render root.cpp mesh.cpp node.cpp material.cpp texture.cpp camera.cpp light.cpp quad.cpp shader.cpp)
 link_directories(/usr/lib)
 
-add_executable(vb01 main.cpp)
+add_executable(vb01 main.cpp ${math} ${render})
+target_link_libraries(vb01 glfw)
+target_link_libraries(vb01 glad)

box.cpp

@@ -0,0 +1,73 @@
+#include"box.h"
+
+namespace vb01{
+	Box::Box(){
+		float size=.1;
+		float vertData[]={
+			0,1,0,1,1,
+			0,1,0,0,1,
+			0,1,0,0,0,
+			
+			0,1,0,0,0,
+			0,1,0,1,0,
+			0,1,0,1,1,
+
+			0,-1,0,1,1,
+			0,-1,0,0,1,
+			0,-1,0,0,0,
+			
+			0,-1,0,0,0,
+			0,-1,0,1,0,
+			0,-1,0,1,1,
+
+			0,0,1,1,1,
+			0,0,1,0,1,
+			0,0,1,0,0,
+			
+			0,0,1,0,0,
+			0,0,1,1,0,
+			0,0,1,1,1,
+
+			0,0,-1,1,1,
+			0,0,-1,0,1,
+			0,0,-1,0,0,
+			
+			0,0,-1,0,0,
+			0,0,-1,1,0,
+			0,0,-1,1,1,
+
+			1,0,0,1,1,
+			1,0,0,0,1,
+			1,0,0,0,0,
+			
+			1,0,0,0,0,
+			1,0,0,1,0,
+			1,0,0,1,1,
+
+			-1,0,0,1,1,
+			-1,0,0,0,1,
+			-1,0,0,0,0,
+			
+			-1,0,0,0,0,
+			-1,0,0,1,0,
+			-1,0,0,1,1
+		};	
+		Vector3 p[]={
+			Vector3(size.x/2,size.y/2,size.z/2), 
+			Vector3(-size.x/2,size.y/2,size.z/2), 
+			Vector3(-size.x/2,size.y/2,-size.z/2),
+			Vector3(-size.x/2,size.y/2,-size.z/2),
+
+			Vector3(size.x/2,-size.y/2,size.z/2),
+			Vector3(-size.x/2,-size.y/2,size.z/2),
+			Vector3(-size.x/2,-size.y/2,-size.z/2),
+			Vector3(-size.x/2,-size.y/2,-size.z/2)
+		};
+		int indices[]={
+			
+		};
+	}
+	void Box::update(){
+		
+	}
+}

box.h

@@ -0,0 +1,15 @@
+#ifndef BOX_H
+#define BOX_H
+
+#include"mesh.h"
+
+namespace vb01{
+	class Box : public Mesh{
+		public:
+			Box();
+			void update();
+		private:
+	};
+}
+
+#endif

camera.cpp

@@ -0,0 +1,19 @@
+#include"camera.h"
+
+namespace vb01{
+	Camera::Camera(){
+	
+	}
+
+	Camera::~Camera(){}
+
+	void Camera::update(){
+	
+	}
+
+	void Camera::lookAt(Vector3 direction, Vector3 up){
+		this->direction=direction;
+		this->up=up;
+		left=direction.cross(up);
+	}
+}

camera.h

@@ -0,0 +1,27 @@
+#ifndef CAMERA_H
+#define CAMERA_H
+
+#include"vector.h"
+
+namespace vb01{
+	class Camera{
+		public:
+			Camera();
+			~Camera();
+			void update();
+			void setPosition(Vector3 position){this->position=position;}
+			void lookAt(Vector3, Vector3);
+			inline Vector3 getPosition(){return position;}
+			inline Vector3 getDirection(){return direction;}
+			inline Vector3 getLeft(){return left;}
+			inline Vector3 getUp(){return up;}
+			inline float getFov(){return fov;}
+			inline float getNearPlane(){return nearPlane;}
+			inline float getFarPlane(){return farPlane;}
+		private:
+			Vector3 position=Vector3(0,0,0),direction=Vector3::VEC_K,left=Vector3::VEC_I,up=Vector3::VEC_J;
+			float fov=45,nearPlane=.1,farPlane=100;
+	};
+}
+
+#endif

light.h

@@ -0,0 +1,17 @@
+#ifndef LIGHT_H
+#define LIGHT_H
+
+namespace vb01{
+	class Light{
+		public:
+			enum Type{POINT,DIRECTIONAL,SPOT,AMBIENT};
+
+			Light();
+			~Light();
+			void update();
+		private:
+			Type type;
+	};
+}
+
+#endif

main.cpp

@@ -1,6 +1,25 @@
-#include"quaternion.h"
-#include"vec3.h"
+#include<iostream>
+#include"root.h"
+#include"node.h"
+#include"quad.h"
+#include"material.h"
+
+using namespace vb01;
+using namespace std;
 
 int main(){
+	Root *root=Root::getSingleton();
+	root->start(800,600);
+
+	Quad *q=new Quad(Vector3(.5,.5,.5));
+	Node *node=new Node(Vector3(0,0,2));
+	node->setObject(q);
+	Material *mat=new Material();
+	mat->setDiffuseMap("/home/dominykas/c++/FSim/woodChips.jpg");	
+	mat->setLightingEnabled(true);
+	q->setMaterial(mat);
+	root->getRootNode()->attachChild(node);
+	while(true)
+		root->update();
 	return 0;
 }

material.cpp

@@ -0,0 +1,21 @@
+#include"material.h"
+#include"shader.h"
+
+using namespace std;
+
+namespace vb01{
+	Material::Material(){
+		string basePath="/home/dominykas/c++/FSim/";
+		shader=new Shader(basePath+"texture.vert",basePath+"texture.frag");
+	}
+
+	Material::~Material(){}
+
+	void Material::update(){
+		shader->use();
+		shader->setBool(lightingEnabled,"lightingEnabled");
+		if(diffuseMap)diffuseMap->select();
+		if(normalMap)normalMap->select();
+		if(specularMap)specularMap->select();
+	}
+}

material.h

@@ -0,0 +1,26 @@
+#ifndef MATERIAL_H
+#define MATERIAL_H
+
+#include"texture.h"
+#include"shader.h"
+
+namespace vb01{
+	class Material{
+		public:
+			Material();
+			~Material();
+			void update();
+			void setDiffuseMap(std::string diffuseMap){this->diffuseMap=new Texture(diffuseMap);}
+			void setNormalMap(std::string normalMap){this->normalMap=new Texture(normalMap);}
+			void setSpecularMap(std::string specularMap){this->specularMap=new Texture(specularMap);}
+			inline void setLightingEnabled(bool lighting){this->lightingEnabled=lighting;}
+			inline Shader* getShader(){return shader;}
+			inline bool isLighting(){return lightingEnabled;}
+		private:
+			bool lightingEnabled=false;
+			Texture *diffuseMap=nullptr,*normalMap=nullptr,*specularMap=nullptr;
+			Shader *shader;
+	};
+}
+
+#endif

mesh.cpp

@@ -0,0 +1,64 @@
+#include"root.h"
+#include"mesh.h"
+#include<glad.h>
+#include<glfw3.h>
+#include<glm.hpp>
+#include<ext.hpp>
+
+using namespace std;
+using namespace glm;
+
+namespace vb01{
+	Mesh::Mesh(string path){
+		construct();
+	}
+
+	Mesh::Mesh(){
+		
+	}
+
+	Mesh::~Mesh(){}
+
+	void Mesh::construct(){
+		glGenVertexArrays(1,&VAO);
+		glGenBuffers(1,&VBO);
+		glGenBuffers(1,&EBO);	
+		
+		glBindVertexArray(VAO);
+		glBindBuffer(GL_ARRAY_BUFFER,VBO);
+		glBufferData(GL_ARRAY_BUFFER, 3*numTris*sizeof(Vertex), vertices, GL_STATIC_DRAW);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER,3*numTris*sizeof(unsigned int),indices,GL_STATIC_DRAW);
+
+		glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(Vertex),(void*)0);
+		glEnableVertexAttribArray(0);
+		glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(Vertex),(void*)(offsetof(Vertex,norm)));
+		glEnableVertexAttribArray(1);
+		glVertexAttribPointer(2,2,GL_FLOAT,GL_FALSE,sizeof(Vertex),(void*)(offsetof(Vertex,texCoords)));
+		glEnableVertexAttribArray(2);
+
+	}
+
+	void Mesh::update(){
+		Root *root=Root::getSingleton();
+		Camera *cam=root->getCamera();
+		float fov=cam->getFov(),width=root->getWidth(),height=root->getHeight();
+		float nearPlane=cam->getNearPlane(),farPlane=cam->getFarPlane();
+		Vector3 pos=node->getPosition();
+		Vector3 dir=cam->getDirection(),up=cam->getUp(),camPos=cam->getPosition();
+
+		mat4 model=translate(mat4(1.),vec3(pos.x,pos.y,pos.z));
+		model=rotate(model,45.f,vec3(1,0,0));
+		mat4 view=lookAt(vec3(camPos.x,camPos.y,camPos.z),vec3(camPos.x+dir.x,camPos.y+dir.y,camPos.z+dir.z),vec3(up.x,up.y,up.z));
+		mat4 proj=perspective(radians(fov),width/height,nearPlane,farPlane);
+		//proj=ortho(0.f,800.f,0.f,-600.f,nearPlane,farPlane);
+
+		material->update();
+		material->getShader()->setMat4(model,"model");
+		material->getShader()->setMat4(view,"view");
+		material->getShader()->setMat4(proj,"proj");
+
+		glBindVertexArray(VAO);
+		glDrawElements(GL_TRIANGLES,3*numTris,GL_UNSIGNED_INT,0);	
+	}
+}

mesh.h

@@ -0,0 +1,36 @@
+#ifndef MESH_H
+#define MESH_H
+
+#include"vector.h"
+#include<vector>
+#include<string>
+#include"material.h"
+
+namespace vb01{
+	class Node;
+
+	class Mesh{
+		protected:
+			struct Vertex{
+				Vector3 pos,norm;
+				Vector2 texCoords;	
+			};
+			void construct();
+			Vertex *vertices;
+			unsigned int *indices,VAO,VBO,EBO;
+			int numTris;
+			Node *node=nullptr;
+		public:
+			Mesh(std::string);
+			Mesh();
+			~Mesh();
+			virtual void update();
+			void setMaterial(Material *mat){this->material=mat;}
+			inline void setNode(Node *node){this->node=node;}
+			inline Node* getNode(){return node;}
+		private:
+			Material *material=nullptr;
+	};
+}
+
+#endif

node.cpp

@@ -0,0 +1,26 @@
+#include"node.h"
+#include"mesh.h"
+
+namespace vb01{
+	Node::Node(Vector3 pos){
+		this->pos=pos;
+	}
+
+	Node::~Node(){}
+
+	void Node::update(){
+		if(mesh)
+			mesh->update();			
+		for(Node *c : children)
+			c->update();
+	}
+
+	void Node::attachChild(Node *child){
+		children.push_back(child);
+	}
+
+	void Node::setObject(Mesh *mesh){
+		this->mesh=mesh;	
+		mesh->setNode(this);
+	}
+}

node.h

@@ -0,0 +1,28 @@
+#ifndef NODE_H
+#define NODE_H
+
+#include"quaternion.h"
+#include"vector.h"
+#include<vector>
+
+namespace vb01{
+	class Mesh;
+
+	class Node{
+		public:
+			Node(Vector3);
+			~Node();
+			void setObject(Mesh*);
+			void update();
+			void attachChild(Node*);
+			inline Node* getParent(){return parent;}
+			inline Vector3 getPosition(){return pos;}
+		private:
+			Vector3 pos;
+			Mesh *mesh=nullptr;
+			std::vector<Node*> children;
+			Node *parent=nullptr;
+	};
+}
+
+#endif

quad.cpp

@@ -0,0 +1,48 @@
+#include"quad.h"
+
+namespace vb01{
+	Quad::Quad(Vector3 size) : Mesh(){
+		Vertex v1,v2,v3,v4,v5,v6;
+		v1.pos=Vector3(size.x/2,size.y/2,0);
+		v1.norm=Vector3(0,0,1);
+		v1.texCoords=Vector2(1,1);
+
+		v2.pos=Vector3(-size.x/2,size.y/2,0);
+		v2.norm=Vector3(0,0,1);
+		v2.texCoords=Vector2(0,1);
+
+		v3.pos=Vector3(-size.x/2,-size.y/2,0);
+		v3.norm=Vector3(0,0,1);
+		v3.texCoords=Vector2(0,0);
+
+		v4.pos=Vector3(-size.x/2,-size.y/2,0);
+		v4.norm=Vector3(0,0,1);
+		v4.texCoords=Vector2(0,0);
+
+		v5.pos=Vector3(size.x/2,-size.y/2,0);
+		v5.norm=Vector3(0,0,1);
+		v5.texCoords=Vector2(1,0);
+
+		v6.pos=Vector3(size.x/2,size.y/2,0);
+		v6.norm=Vector3(0,0,1);
+		v6.texCoords=Vector2(1,1);
+		
+		numTris=2;
+		indices=new unsigned int[numTris*3];
+		indices[0]=0;
+		indices[1]=1;
+		indices[2]=2;
+		indices[3]=3;
+		indices[4]=4;
+		indices[5]=5;
+
+		vertices=new Vertex[numTris*3];
+		vertices[0]=v1;
+		vertices[1]=v2;
+		vertices[2]=v3;
+		vertices[3]=v4;
+		vertices[4]=v5;
+		vertices[5]=v6;
+		Mesh::construct();
+	}
+}

quad.h

@@ -0,0 +1,15 @@
+#ifndef QUAD_H
+#define QUAD_H
+
+#include"vector.h"
+#include"mesh.h"
+
+namespace vb01{
+	class Quad : public Mesh{
+		public:
+			Quad(Vector3);
+		private:
+	};
+}
+
+#endif

quaternion.cpp

@@ -0,0 +1,7 @@
+#include"quaternion.h"
+
+namespace vb01{
+	const quaternion quaternion::QUAT_I(0,1,0,0);
+	const quaternion quaternion::QUAT_J(0,0,1,0);
+	const quaternion quaternion::QUAT_K(0,0,0,1);
+}

quaternion.h

@@ -1,3 +1,6 @@
+#ifndef QUATERNION_H
+#define QUATERNION_H
+
 #include<cmath>
 
 namespace vb01{
@@ -20,15 +23,21 @@ namespace vb01{
 				float z=a1*d2+b1*c2-c1*b2+d1*a2;
 				return quaternion(w,x,y,z);
 			}
-			//inline vb01::quaternion conj(){return -.5*(*this+vb01::QUAT_I*(*this)*vb01::QUAT_I+vb01::QUAT_J*(*this)*vb01::QUAT_J+vb01::QUAT_K*(*this)*vb01::QUAT_K);}
+			inline vb01::quaternion operator+(quaternion q){return quaternion(w+q.w,x+q.x,y+q.y,z+q.z);}
+			inline vb01::quaternion operator-(quaternion q){return quaternion(w-q.w,x-q.x,y-q.y,z-q.z);}
+			template<typename T> inline vb01::quaternion operator*(T s){return quaternion(w*s,x*s,y*s,z*s);}
+			inline vb01::quaternion conj(){return (*this+vb01::quaternion(0,1,0,0)*(*this)*vb01::quaternion(0,1,0,0)+vb01::quaternion(0,0,1,0)*(*this)*vb01::quaternion(0,0,1,0)+vb01::quaternion(0,0,0,1)*(*this)*vb01::quaternion(0,0,0,1))*-.5;}
 			inline vb01::quaternion operator/ (float f){return quaternion(w/f,x/f,y/f,z/f);}
 			inline vb01::quaternion norm(){return *this/getLength();}
-			//inline vb01::quaternion recip(){return conj()/getLengthSq();}
+			inline vb01::quaternion recip(){return conj()/getLengthSq();}
 			inline float getLengthSq(){return w*w+x*x+y*y+z*z;}
 			inline float getLength(){return std::sqrt(getLengthSq());}
 
-	//static vb01::quaternion QUAT_I=quaternion(0,1,0,0),QUAT_J=quaternion(0,0,1,0),QUAT_K=quaternion(0,0,0,1);
 			float w,x,y,z;
+			const static quaternion QUAT_I,QUAT_J,QUAT_K;
 		private:
 	};
+
 }
+
+#endif

root.cpp

@@ -0,0 +1,55 @@
+#include"root.h"
+#include<glad.h>
+#include<glfw3.h>
+#include<cstdlib>
+#include<iostream>
+
+namespace vb01{
+	static Root *root=new Root();
+
+	Root* Root::getSingleton(){return root;}
+
+	void foo(GLFWwindow *window, int width, int height){
+		glViewport(0,0,width,height);
+	}
+
+	Root::Root(){
+		rootNode=new Node(Vector3::VEC_ZERO);
+		camera=new Camera();
+	}
+
+	void Root::start(int width,int height){
+		running=true;
+		this->width=width;
+		this->height=height;
+
+		glfwInit();
+		glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,3);
+		glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,3);
+		glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);
+		window=glfwCreateWindow(width,height,"KEK",NULL,NULL);
+		if(window==NULL){
+			std::cout<<"KEK\n";
+			exit(-1);
+		}
+		glfwMakeContextCurrent(window);
+		glfwSetFramebufferSizeCallback(window,foo);
+		if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)){
+			std::cout<<"KEK2\n";
+			exit(-1);
+		}
+		glEnable(GL_DEPTH_TEST);
+		glEnable(GL_STENCIL_TEST);
+	}
+
+	void Root::update(){
+		if(running){
+			glClearColor(0,0,0,1);
+			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+			rootNode->update();
+
+			glfwSwapBuffers(window);
+		}
+	}
+}

root.h

@@ -0,0 +1,32 @@
+#ifndef ROOT_H
+#define ROOT_H
+
+#include"node.h"
+#include"camera.h"
+
+class GLFWwindow;
+
+namespace vb01{
+	void foo();
+
+	class Root{
+		public:
+			Root();
+			void update();
+			void start(int,int);
+			inline Camera* getCamera(){return camera;}
+			inline Node* getRootNode(){return rootNode;}
+			inline int getWidth(){return width;}
+			inline int getHeight(){return height;}
+			static Root* getSingleton();
+		private:
+			bool running=false;
+			int width,height;
+			GLFWwindow *window;
+			Node *rootNode;
+			Camera *camera;
+			void framebuffer_size_callback(GLFWwindow*,int,int);
+	};
+}
+
+#endif

shader.cpp

@@ -0,0 +1,86 @@
+#include<glad.h>
+#include<glfw3.h>
+#include<iostream>
+#include<sstream>
+#include<fstream>
+#include"shader.h"
+#include<glm/gtc/matrix_transform.hpp>
+#include<glm/gtc/type_ptr.hpp>
+
+using namespace std;
+using namespace glm;
+
+namespace vb01{
+	Shader::Shader(string vertShaderPath, string fragShaderPath){
+		ifstream vertShaderFile,fragShaderFile;
+		vertShaderFile.open(vertShaderPath);
+		fragShaderFile.open(fragShaderPath);
+		
+		stringstream vertShaderStream,fragShaderStream;
+		vertShaderStream<<vertShaderFile.rdbuf();
+		fragShaderStream<<fragShaderFile.rdbuf();
+		
+		vertShaderFile.close();
+		fragShaderFile.close();
+		
+		string v=vertShaderStream.str();
+		string f=fragShaderStream.str();
+
+		const char *vertShaderSource=v.c_str();
+		const char *fragShaderSource=f.c_str();
+
+		unsigned int vert,frag;
+		vert=glCreateShader(GL_VERTEX_SHADER);
+		glShaderSource(vert,1,&vertShaderSource,NULL);
+		glCompileShader(vert);
+		checkCompileErrors(vert,VERTEX);
+
+		frag=glCreateShader(GL_FRAGMENT_SHADER);
+		glShaderSource(frag,1,&fragShaderSource,NULL);
+		glCompileShader(frag);
+		checkCompileErrors(frag,FRAGMENT);
+
+		id=glCreateProgram();
+		glAttachShader(id,vert);
+		glAttachShader(id,frag);
+		glLinkProgram(id);
+		checkCompileErrors(id,PROGRAM);
+
+		glDeleteShader(vert);
+		glDeleteShader(frag);
+	}
+	
+	void Shader::checkCompileErrors(unsigned int shader, ErrorType type){
+		int success;
+		char infoLog[1024];
+		switch(type){
+			case PROGRAM:
+				glGetProgramiv(shader,GL_LINK_STATUS,&success);
+				if(!success){
+					glGetProgramInfoLog(shader,1024,NULL,infoLog);
+					cout<<"ERROR::PROGRAM_LINK_ERROR: "<<type<<endl<<infoLog<<endl;
+				}
+				break;
+			default:
+				glGetShaderiv(shader,GL_COMPILE_STATUS,&success);
+				if(!success){
+					const char *sh=(type==VERTEX?"VERTEX":"FRAGMENT");
+					glGetShaderInfoLog(shader,1024,NULL,infoLog);
+					cout<<"ERROS::SHADER_COMPILE_ERROR::"<<sh<<endl<<infoLog<<endl;
+				}
+				break;
+		}
+	}
+
+	void Shader::use(){glUseProgram(id);}
+
+	void Shader::setMat4(mat4 mat, string var){
+		int uniformLoc=glGetUniformLocation(id,var.c_str());
+		glUniformMatrix4fv(uniformLoc,1,GL_FALSE,value_ptr(mat));
+	}
+
+	void Shader::setBool(bool b, string var){
+		int uniformLoc=glGetUniformLocation(id,var.c_str());	
+		glUniform1i(uniformLoc,(int)b);
+	}
+}

shader.h

@@ -0,0 +1,21 @@
+#ifndef SHADER_H
+#define SHADER_H
+
+#include<string>
+#include<glm/mat4x4.hpp>
+
+namespace vb01{
+	class Shader{
+		public:
+			Shader(std::string,std::string);
+			void use();
+			void setMat4(glm::mat4,std::string);
+			void setBool(bool,std::string);
+		private:
+			enum ErrorType{VERTEX,FRAGMENT,PROGRAM};
+			void checkCompileErrors(unsigned int,ErrorType);
+			unsigned int id;
+	};
+}
+
+#endif

tags

@@ -0,0 +1,731 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_OUTPUT_MODE	u-ctags	/u-ctags or e-ctags/
+!_TAG_PROGRAM_AUTHOR	Universal Ctags Team	//
+!_TAG_PROGRAM_NAME	Universal Ctags	/Derived from Exuberant Ctags/
+!_TAG_PROGRAM_URL	https://ctags.io/	/official site/
+!_TAG_PROGRAM_VERSION	0.0.0	/3fdf28bc/
+BOX_H	box.h	/^#define BOX_H$/;"	d
+Box	box.cpp	/^	Box::Box(){$/;"	f	class:vb01::Box
+Box	box.h	/^	class Box : public Mesh{$/;"	c	namespace:vb01
+CAMERA_H	camera.h	/^#define CAMERA_H$/;"	d
+Camera	camera.cpp	/^	Camera::Camera(){$/;"	f	class:vb01::Camera
+Camera	camera.h	/^	class Camera{$/;"	c	namespace:vb01
+EBO	mesh.h	/^			unsigned int *indices,VAO,VBO,EBO;$/;"	m	class:vb01::Mesh	typeref:typename:unsigned int *
+ErrorType	shader.h	/^			enum ErrorType{VERTEX,FRAGMENT,PROGRAM};$/;"	g	class:vb01::Shader
+FAST_BITS	stb_image.h	/^#define FAST_BITS /;"	d
+FRAGMENT	shader.h	/^			enum ErrorType{VERTEX,FRAGMENT,PROGRAM};$/;"	e	enum:vb01::Shader::ErrorType
+MATERIAL_H	material.h	/^#define MATERIAL_H$/;"	d
+MESH_H	mesh.h	/^#define MESH_H$/;"	d
+Material	material.cpp	/^	Material::Material(){$/;"	f	class:vb01::Material
+Material	material.h	/^	class Material{$/;"	c	namespace:vb01
+Mesh	mesh.cpp	/^	Mesh::Mesh(){$/;"	f	class:vb01::Mesh
+Mesh	mesh.cpp	/^	Mesh::Mesh(string path){$/;"	f	class:vb01::Mesh
+Mesh	mesh.h	/^	class Mesh{$/;"	c	namespace:vb01
+NODE_H	node.h	/^#define NODE_H$/;"	d
+Node	node.cpp	/^	Node::Node(Vector3 pos){$/;"	f	class:vb01::Node
+Node	node.h	/^	class Node{$/;"	c	namespace:vb01
+PROGRAM	shader.h	/^			enum ErrorType{VERTEX,FRAGMENT,PROGRAM};$/;"	e	enum:vb01::Shader::ErrorType
+QUAD_H	quad.h	/^#define QUAD_H$/;"	d
+QUATERNION_H	quaternion.h	/^#define QUATERNION_H$/;"	d
+QUAT_I	quaternion.cpp	/^	const quaternion quaternion::QUAT_I(0,1,0,0);$/;"	m	class:vb01::quaternion	typeref:typename:const quaternion
+QUAT_I	quaternion.h	/^			const static quaternion QUAT_I,QUAT_J,QUAT_K;$/;"	m	class:vb01::quaternion	typeref:typename:const quaternion
+QUAT_J	quaternion.cpp	/^	const quaternion quaternion::QUAT_J(0,0,1,0);$/;"	m	class:vb01::quaternion	typeref:typename:const quaternion
+QUAT_J	quaternion.h	/^			const static quaternion QUAT_I,QUAT_J,QUAT_K;$/;"	m	class:vb01::quaternion	typeref:typename:const quaternion
+QUAT_K	quaternion.cpp	/^	const quaternion quaternion::QUAT_K(0,0,0,1);$/;"	m	class:vb01::quaternion	typeref:typename:const quaternion
+QUAT_K	quaternion.h	/^			const static quaternion QUAT_I,QUAT_J,QUAT_K;$/;"	m	class:vb01::quaternion	typeref:typename:const quaternion
+Quad	quad.cpp	/^	Quad::Quad(Vector3 size) : Mesh(){$/;"	f	class:vb01::Quad
+Quad	quad.h	/^	class Quad : public Mesh{$/;"	c	namespace:vb01
+ROOT_H	root.h	/^#define ROOT_H$/;"	d
+Root	root.cpp	/^	Root::Root(){$/;"	f	class:vb01::Root
+Root	root.h	/^	class Root{$/;"	c	namespace:vb01
+SHADER_H	shader.h	/^#define SHADER_H$/;"	d
+STBIDEF	stb_image.h	/^#define STBIDEF /;"	d
+STBI_ASSERT	stb_image.h	/^#define STBI_ASSERT(/;"	d
+STBI_EXTERN	stb_image.h	/^#define STBI_EXTERN /;"	d
+STBI_FREE	stb_image.h	/^#define STBI_FREE(/;"	d
+STBI_HAS_LROTL	stb_image.h	/^#define STBI_HAS_LROTL$/;"	d
+STBI_INCLUDE_STB_IMAGE_H	stb_image.h	/^#define STBI_INCLUDE_STB_IMAGE_H$/;"	d
+STBI_MALLOC	stb_image.h	/^#define STBI_MALLOC(/;"	d
+STBI_NOTUSED	stb_image.h	/^#define STBI_NOTUSED(/;"	d
+STBI_NO_BMP	stb_image.h	/^   #define STBI_NO_BMP$/;"	d
+STBI_NO_GIF	stb_image.h	/^   #define STBI_NO_GIF$/;"	d
+STBI_NO_HDR	stb_image.h	/^   #define STBI_NO_HDR$/;"	d
+STBI_NO_JPEG	stb_image.h	/^   #define STBI_NO_JPEG$/;"	d
+STBI_NO_PIC	stb_image.h	/^   #define STBI_NO_PIC$/;"	d
+STBI_NO_PNG	stb_image.h	/^   #define STBI_NO_PNG$/;"	d
+STBI_NO_PNM	stb_image.h	/^   #define STBI_NO_PNM$/;"	d
+STBI_NO_PSD	stb_image.h	/^   #define STBI_NO_PSD$/;"	d
+STBI_NO_SIMD	stb_image.h	/^#define STBI_NO_SIMD$/;"	d
+STBI_NO_TGA	stb_image.h	/^   #define STBI_NO_TGA$/;"	d
+STBI_NO_ZLIB	stb_image.h	/^#define STBI_NO_ZLIB$/;"	d
+STBI_ORDER_BGR	stb_image.h	/^   STBI_ORDER_BGR$/;"	e	enum:__anon84e4e8860403
+STBI_ORDER_RGB	stb_image.h	/^   STBI_ORDER_RGB,$/;"	e	enum:__anon84e4e8860403
+STBI_REALLOC	stb_image.h	/^#define STBI_REALLOC(/;"	d
+STBI_REALLOC_SIZED	stb_image.h	/^#define STBI_REALLOC_SIZED(/;"	d
+STBI_SIMD_ALIGN	stb_image.h	/^#define STBI_SIMD_ALIGN(/;"	d
+STBI_SSE2	stb_image.h	/^#define STBI_SSE2$/;"	d
+STBI_VERSION	stb_image.h	/^#define STBI_VERSION /;"	d
+STBI__BYTECAST	stb_image.h	/^#define STBI__BYTECAST(/;"	d
+STBI__CASE	stb_image.h	/^         #define STBI__CASE(/;"	d
+STBI__CASE	stb_image.h	/^      #define STBI__CASE(/;"	d
+STBI__COMBO	stb_image.h	/^      #define STBI__COMBO(/;"	d
+STBI__F_avg	stb_image.h	/^   STBI__F_avg=3,$/;"	e	enum:__anon84e4e8860f03
+STBI__F_avg_first	stb_image.h	/^   STBI__F_avg_first,$/;"	e	enum:__anon84e4e8860f03
+STBI__F_none	stb_image.h	/^   STBI__F_none=0,$/;"	e	enum:__anon84e4e8860f03
+STBI__F_paeth	stb_image.h	/^   STBI__F_paeth=4,$/;"	e	enum:__anon84e4e8860f03
+STBI__F_paeth_first	stb_image.h	/^   STBI__F_paeth_first$/;"	e	enum:__anon84e4e8860f03
+STBI__F_sub	stb_image.h	/^   STBI__F_sub=1,$/;"	e	enum:__anon84e4e8860f03
+STBI__F_up	stb_image.h	/^   STBI__F_up=2,$/;"	e	enum:__anon84e4e8860f03
+STBI__HDR_BUFLEN	stb_image.h	/^#define STBI__HDR_BUFLEN /;"	d
+STBI__IDCT_1D	stb_image.h	/^#define STBI__IDCT_1D(/;"	d
+STBI__MARKER_none	stb_image.h	/^#define STBI__MARKER_none /;"	d
+STBI__PNG_TYPE	stb_image.h	/^#define STBI__PNG_TYPE(/;"	d
+STBI__RESTART	stb_image.h	/^#define STBI__RESTART(/;"	d
+STBI__SCAN_header	stb_image.h	/^   STBI__SCAN_header$/;"	e	enum:__anon84e4e8860603
+STBI__SCAN_load	stb_image.h	/^   STBI__SCAN_load=0,$/;"	e	enum:__anon84e4e8860603
+STBI__SCAN_type	stb_image.h	/^   STBI__SCAN_type,$/;"	e	enum:__anon84e4e8860603
+STBI__X64_TARGET	stb_image.h	/^#define STBI__X64_TARGET$/;"	d
+STBI__X86_TARGET	stb_image.h	/^#define STBI__X86_TARGET$/;"	d
+STBI__ZFAST_BITS	stb_image.h	/^#define STBI__ZFAST_BITS /;"	d
+STBI__ZFAST_MASK	stb_image.h	/^#define STBI__ZFAST_MASK /;"	d
+STBI_default	stb_image.h	/^   STBI_default = 0, \/\/ only used for desired_channels$/;"	e	enum:__anon84e4e8860103
+STBI_grey	stb_image.h	/^   STBI_grey       = 1,$/;"	e	enum:__anon84e4e8860103
+STBI_grey_alpha	stb_image.h	/^   STBI_grey_alpha = 2,$/;"	e	enum:__anon84e4e8860103
+STBI_rgb	stb_image.h	/^   STBI_rgb        = 3,$/;"	e	enum:__anon84e4e8860103
+STBI_rgb_alpha	stb_image.h	/^   STBI_rgb_alpha  = 4$/;"	e	enum:__anon84e4e8860103
+STB_IMAGE_IMPLEMENTATION	texture.cpp	/^#define STB_IMAGE_IMPLEMENTATION$/;"	d	file:
+Shader	shader.cpp	/^	Shader::Shader(string vertShaderPath, string fragShaderPath){$/;"	f	class:vb01::Shader
+Shader	shader.h	/^	class Shader{$/;"	c	namespace:vb01
+TEXTURE_H	texture.h	/^#define TEXTURE_H$/;"	d
+Texture	texture.cpp	/^	Texture::Texture(string path){$/;"	f	class:vb01::Texture
+Texture	texture.h	/^	class Texture{$/;"	c	namespace:vb01
+VAO	mesh.h	/^			unsigned int *indices,VAO,VBO,EBO;$/;"	m	class:vb01::Mesh	typeref:typename:unsigned int *
+VBO	mesh.h	/^			unsigned int *indices,VAO,VBO,EBO;$/;"	m	class:vb01::Mesh	typeref:typename:unsigned int *
+VECTOR_H	vector.h	/^#define VECTOR_H$/;"	d
+VEC_I	vector.cpp	/^	const Vector2 Vector2::VEC_I(1,0); $/;"	m	class:vb01::Vector2	typeref:typename:const Vector2
+VEC_I	vector.cpp	/^	const Vector3 Vector3::VEC_I(1,0,0); $/;"	m	class:vb01::Vector3	typeref:typename:const Vector3
+VEC_I	vector.h	/^		static const Vector2 VEC_I,VEC_J,VEC_ZERO;$/;"	m	struct:vb01::Vector2	typeref:typename:const Vector2
+VEC_I	vector.h	/^		static const Vector3 VEC_I,VEC_J,VEC_K,VEC_ZERO;$/;"	m	struct:vb01::Vector3	typeref:typename:const Vector3
+VEC_J	vector.cpp	/^	const Vector2 Vector2::VEC_J(0,1); $/;"	m	class:vb01::Vector2	typeref:typename:const Vector2
+VEC_J	vector.cpp	/^	const Vector3 Vector3::VEC_J(0,1,0); $/;"	m	class:vb01::Vector3	typeref:typename:const Vector3
+VEC_J	vector.h	/^		static const Vector2 VEC_I,VEC_J,VEC_ZERO;$/;"	m	struct:vb01::Vector2	typeref:typename:const Vector2
+VEC_J	vector.h	/^		static const Vector3 VEC_I,VEC_J,VEC_K,VEC_ZERO;$/;"	m	struct:vb01::Vector3	typeref:typename:const Vector3
+VEC_K	vector.cpp	/^	const Vector3 Vector3::VEC_K(0,0,1); $/;"	m	class:vb01::Vector3	typeref:typename:const Vector3
+VEC_K	vector.h	/^		static const Vector3 VEC_I,VEC_J,VEC_K,VEC_ZERO;$/;"	m	struct:vb01::Vector3	typeref:typename:const Vector3
+VEC_ZERO	vector.cpp	/^	const Vector2 Vector2::VEC_ZERO(0,0); $/;"	m	class:vb01::Vector2	typeref:typename:const Vector2
+VEC_ZERO	vector.cpp	/^	const Vector3 Vector3::VEC_ZERO(0,0,0); $/;"	m	class:vb01::Vector3	typeref:typename:const Vector3
+VEC_ZERO	vector.h	/^		static const Vector2 VEC_I,VEC_J,VEC_ZERO;$/;"	m	struct:vb01::Vector2	typeref:typename:const Vector2
+VEC_ZERO	vector.h	/^		static const Vector3 VEC_I,VEC_J,VEC_K,VEC_ZERO;$/;"	m	struct:vb01::Vector3	typeref:typename:const Vector3
+VERTEX	shader.h	/^			enum ErrorType{VERTEX,FRAGMENT,PROGRAM};$/;"	e	enum:vb01::Shader::ErrorType
+Vector2	vector.h	/^		Vector2(){};$/;"	f	struct:vb01::Vector2
+Vector2	vector.h	/^		Vector2(float x,float y){$/;"	f	struct:vb01::Vector2
+Vector2	vector.h	/^	struct Vector2{$/;"	s	namespace:vb01
+Vector3	vector.h	/^		Vector3(){};$/;"	f	struct:vb01::Vector3
+Vector3	vector.h	/^		Vector3(float x,float y,float z){$/;"	f	struct:vb01::Vector3
+Vector3	vector.h	/^	struct Vector3{$/;"	s	namespace:vb01
+Vertex	mesh.h	/^			struct Vertex{$/;"	s	class:vb01::Mesh
+YCbCr_to_RGB_kernel	stb_image.h	/^   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc/;"	m	struct:__anon84e4e8860808	typeref:typename:void (*)(stbi_uc * out,const stbi_uc * y,const stbi_uc * pcb,const stbi_uc * pcr,int count,int step)
+__anon84e4e8860103	stb_image.h	/^{$/;"	g
+__anon84e4e8860208	stb_image.h	/^{$/;"	s
+__anon84e4e8860308	stb_image.h	/^{$/;"	s
+__anon84e4e8860403	stb_image.h	/^{$/;"	g
+__anon84e4e8860508	stb_image.h	/^{$/;"	s
+__anon84e4e8860603	stb_image.h	/^{$/;"	g
+__anon84e4e8860708	stb_image.h	/^{$/;"	s
+__anon84e4e8860808	stb_image.h	/^{$/;"	s
+__anon84e4e8860908	stb_image.h	/^   {$/;"	s	struct:__anon84e4e8860808
+__anon84e4e8860a08	stb_image.h	/^{$/;"	s
+__anon84e4e8860b08	stb_image.h	/^{$/;"	s
+__anon84e4e8860c08	stb_image.h	/^{$/;"	s
+__anon84e4e8860d08	stb_image.h	/^{$/;"	s
+__anon84e4e8860e08	stb_image.h	/^{$/;"	s
+__anon84e4e8860f03	stb_image.h	/^enum {$/;"	g
+__anon84e4e8861008	stb_image.h	/^{$/;"	s
+__anon84e4e8861108	stb_image.h	/^{$/;"	s
+__anon84e4e8861208	stb_image.h	/^{$/;"	s
+__anon84e4e8861308	stb_image.h	/^{$/;"	s
+all_a	stb_image.h	/^   unsigned int mr,mg,mb,ma, all_a;$/;"	m	struct:__anon84e4e8861008	typeref:typename:unsigned int
+app14_color_transform	stb_image.h	/^   int            app14_color_transform; \/\/ Adobe APP14 tag$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+attachChild	node.cpp	/^	void Node::attachChild(Node *child){$/;"	f	class:vb01::Node	typeref:typename:void
+background	stb_image.h	/^   stbi_uc *background;          \/\/ The current "background" as far as a gif is concerned$/;"	m	struct:__anon84e4e8861308	typeref:typename:stbi_uc *
+bgindex	stb_image.h	/^   int flags, bgindex, ratio, transparent, eflags;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+bits_per_channel	stb_image.h	/^   int bits_per_channel;$/;"	m	struct:__anon84e4e8860508	typeref:typename:int
+bpp	stb_image.h	/^   int bpp, offset, hsz;$/;"	m	struct:__anon84e4e8861008	typeref:typename:int
+buffer_start	stb_image.h	/^   stbi_uc buffer_start[128];$/;"	m	struct:__anon84e4e8860308	typeref:typename:stbi_uc[128]
+buflen	stb_image.h	/^   int buflen;$/;"	m	struct:__anon84e4e8860308	typeref:typename:int
+camera	root.h	/^			Camera *camera;$/;"	m	class:vb01::Root	typeref:typename:Camera *
+channel	stb_image.h	/^   stbi_uc size,type,channel;$/;"	m	struct:__anon84e4e8861108	typeref:typename:stbi_uc
+channel_order	stb_image.h	/^   int channel_order;$/;"	m	struct:__anon84e4e8860508	typeref:typename:int
+checkCompileErrors	shader.cpp	/^	void Shader::checkCompileErrors(unsigned int shader, ErrorType type){$/;"	f	class:vb01::Shader	typeref:typename:void
+children	node.h	/^			std::vector<Node*> children;$/;"	m	class:vb01::Node	typeref:typename:std::vector<Node * >
+code	stb_image.h	/^   stbi__uint16 code[256];$/;"	m	struct:__anon84e4e8860708	typeref:typename:stbi__uint16[256]
+code_bits	stb_image.h	/^   int            code_bits;   \/\/ number of valid bits$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+code_buffer	stb_image.h	/^   stbi__uint32   code_buffer; \/\/ jpeg entropy-coded buffer$/;"	m	struct:__anon84e4e8860808	typeref:typename:stbi__uint32
+code_buffer	stb_image.h	/^   stbi__uint32 code_buffer;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:stbi__uint32
+codes	stb_image.h	/^   stbi__gif_lzw codes[8192];$/;"	m	struct:__anon84e4e8861308	typeref:typename:stbi__gif_lzw[8192]
+coeff	stb_image.h	/^      short   *coeff;   \/\/ progressive only$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:short *
+coeff_h	stb_image.h	/^      int      coeff_w, coeff_h; \/\/ number of 8x8 coefficient blocks$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+coeff_w	stb_image.h	/^      int      coeff_w, coeff_h; \/\/ number of 8x8 coefficient blocks$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+color_table	stb_image.h	/^   stbi_uc *color_table;$/;"	m	struct:__anon84e4e8861308	typeref:typename:stbi_uc *
+conj	quaternion.h	/^			inline vb01::quaternion conj(){return (*this+vb01::quaternion(0,1,0,0)*(*this)*vb01::quaterni/;"	f	class:vb01::quaternion	typeref:typename:vb01::quaternion
+construct	mesh.cpp	/^	void Mesh::construct(){$/;"	f	class:vb01::Mesh	typeref:typename:void
+cross	vector.h	/^		Vector3 cross(Vector3 v){return Vector3(y*v.z-v.y*z,x*v.z-v.x*z,x*v.y-v.x*y);}$/;"	f	struct:vb01::Vector3	typeref:typename:Vector3
+cur_x	stb_image.h	/^   int cur_x, cur_y;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+cur_y	stb_image.h	/^   int cur_x, cur_y;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+data	stb_image.h	/^      stbi_uc *data;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:stbi_uc *
+data	texture.h	/^			unsigned char *data;$/;"	m	class:vb01::Texture	typeref:typename:unsigned char *
+dc_pred	stb_image.h	/^      int dc_pred;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+dct_bfly32o	stb_image.h	/^   #define dct_bfly32o(/;"	d
+dct_bfly32o	stb_image.h	/^#define dct_bfly32o(/;"	d
+dct_const	stb_image.h	/^   #define dct_const(/;"	d
+dct_interleave16	stb_image.h	/^   #define dct_interleave16(/;"	d
+dct_interleave8	stb_image.h	/^   #define dct_interleave8(/;"	d
+dct_long_mac	stb_image.h	/^#define dct_long_mac(/;"	d
+dct_long_mul	stb_image.h	/^#define dct_long_mul(/;"	d
+dct_pass	stb_image.h	/^   #define dct_pass(/;"	d
+dct_pass	stb_image.h	/^#define dct_pass(/;"	d
+dct_rot	stb_image.h	/^   #define dct_rot(/;"	d
+dct_trn16	stb_image.h	/^#define dct_trn16(/;"	d
+dct_trn32	stb_image.h	/^#define dct_trn32(/;"	d
+dct_trn64	stb_image.h	/^#define dct_trn64(/;"	d
+dct_trn8_16	stb_image.h	/^#define dct_trn8_16(/;"	d
+dct_trn8_32	stb_image.h	/^#define dct_trn8_32(/;"	d
+dct_trn8_8	stb_image.h	/^#define dct_trn8_8(/;"	d
+dct_wadd	stb_image.h	/^   #define dct_wadd(/;"	d
+dct_wadd	stb_image.h	/^#define dct_wadd(/;"	d
+dct_widen	stb_image.h	/^   #define dct_widen(/;"	d
+dct_widen	stb_image.h	/^#define dct_widen(/;"	d
+dct_wsub	stb_image.h	/^   #define dct_wsub(/;"	d
+dct_wsub	stb_image.h	/^#define dct_wsub(/;"	d
+delay	stb_image.h	/^   int delay;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+delta	stb_image.h	/^   int    delta[17];   \/\/ old 'firstsymbol' - old 'firstcode'$/;"	m	struct:__anon84e4e8860708	typeref:typename:int[17]
+depth	stb_image.h	/^   int depth;$/;"	m	struct:__anon84e4e8860e08	typeref:typename:int
+dequant	stb_image.h	/^   stbi__uint16 dequant[4][64];$/;"	m	struct:__anon84e4e8860808	typeref:typename:stbi__uint16[4][64]
+diffuseMap	material.h	/^			Texture *diffuseMap=nullptr,*normalMap=nullptr,*specularMap=nullptr;$/;"	m	class:vb01::Material	typeref:typename:Texture *
+direction	camera.h	/^			Vector3 position=Vector3(0,0,0),direction=Vector3::VEC_K,left=Vector3::VEC_I,up=Vector3::VEC_/;"	m	class:vb01::Camera	typeref:typename:Vector3
+dot	vector.h	/^		float dot(Vector2 v){return x*v.x+y*v.y;}$/;"	f	struct:vb01::Vector2	typeref:typename:float
+dot	vector.h	/^		float dot(Vector3 v){return x*v.x+y*v.y+z*v.z;}$/;"	f	struct:vb01::Vector3	typeref:typename:float
+eflags	stb_image.h	/^   int flags, bgindex, ratio, transparent, eflags;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+eob_run	stb_image.h	/^   int            eob_run;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+eof	stb_image.h	/^   int      (*eof)   (void *user);                       \/\/ returns nonzero if we are at end o/;"	m	struct:__anon84e4e8860208	typeref:typename:int (*)(void * user)
+expanded	stb_image.h	/^   stbi_uc *idata, *expanded, *out;$/;"	m	struct:__anon84e4e8860e08	typeref:typename:stbi_uc **
+farPlane	camera.h	/^			float fov=45,nearPlane=.1,farPlane=100;$/;"	m	class:vb01::Camera	typeref:typename:float
+fast	stb_image.h	/^   stbi__uint16 fast[1 << STBI__ZFAST_BITS];$/;"	m	struct:__anon84e4e8860b08	typeref:typename:stbi__uint16[]
+fast	stb_image.h	/^   stbi_uc  fast[1 << FAST_BITS];$/;"	m	struct:__anon84e4e8860708	typeref:typename:stbi_uc[]
+fast_ac	stb_image.h	/^   stbi__int16 fast_ac[4][1 << FAST_BITS];$/;"	m	struct:__anon84e4e8860808	typeref:typename:stbi__int16[4][]
+first	stb_image.h	/^   stbi_uc first;$/;"	m	struct:__anon84e4e8861208	typeref:typename:stbi_uc
+first_row_filter	stb_image.h	/^static stbi_uc first_row_filter[5] =$/;"	v	typeref:typename:stbi_uc[5]
+firstcode	stb_image.h	/^   stbi__uint16 firstcode[16];$/;"	m	struct:__anon84e4e8860b08	typeref:typename:stbi__uint16[16]
+firstsymbol	stb_image.h	/^   stbi__uint16 firstsymbol[16];$/;"	m	struct:__anon84e4e8860b08	typeref:typename:stbi__uint16[16]
+flags	stb_image.h	/^   int flags, bgindex, ratio, transparent, eflags;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+foo	root.cpp	/^	void foo(GLFWwindow *window, int width, int height){$/;"	f	namespace:vb01	typeref:typename:void
+fov	camera.h	/^			float fov=45,nearPlane=.1,farPlane=100;$/;"	m	class:vb01::Camera	typeref:typename:float
+getAngleBetween	vector.h	/^		float getAngleBetween(Vector2 v){return std::acos(dot(v));}$/;"	f	struct:vb01::Vector2	typeref:typename:float
+getAngleBetween	vector.h	/^		float getAngleBetween(Vector3 v){return std::acos(dot(v));}$/;"	f	struct:vb01::Vector3	typeref:typename:float
+getCamera	root.h	/^			inline Camera* getCamera(){return camera;}$/;"	f	class:vb01::Root	typeref:typename:Camera *
+getDirection	camera.h	/^			inline Vector3 getDirection(){return direction;}$/;"	f	class:vb01::Camera	typeref:typename:Vector3
+getFarPlane	camera.h	/^			inline float getFarPlane(){return farPlane;}$/;"	f	class:vb01::Camera	typeref:typename:float
+getFov	camera.h	/^			inline float getFov(){return fov;}$/;"	f	class:vb01::Camera	typeref:typename:float
+getHeight	root.h	/^			inline int getHeight(){return height;}$/;"	f	class:vb01::Root	typeref:typename:int
+getLeft	camera.h	/^			inline Vector3 getLeft(){return left;}$/;"	f	class:vb01::Camera	typeref:typename:Vector3
+getLength	quaternion.h	/^			inline float getLength(){return std::sqrt(getLengthSq());}$/;"	f	class:vb01::quaternion	typeref:typename:float
+getLength	vector.h	/^		float getLength(){return std::sqrt(getLengthSq());}$/;"	f	struct:vb01::Vector2	typeref:typename:float
+getLength	vector.h	/^		float getLength(){return std::sqrt(getLengthSq());}$/;"	f	struct:vb01::Vector3	typeref:typename:float
+getLengthSq	quaternion.h	/^			inline float getLengthSq(){return w*w+x*x+y*y+z*z;}$/;"	f	class:vb01::quaternion	typeref:typename:float
+getLengthSq	vector.h	/^		float getLengthSq(){return x*x+y*y+z*z;}$/;"	f	struct:vb01::Vector3	typeref:typename:float
+getLengthSq	vector.h	/^		float getLengthSq(){return x*x+y*y;}$/;"	f	struct:vb01::Vector2	typeref:typename:float
+getNearPlane	camera.h	/^			inline float getNearPlane(){return nearPlane;}$/;"	f	class:vb01::Camera	typeref:typename:float
+getNode	mesh.h	/^			inline Node* getNode(){return node;}$/;"	f	class:vb01::Mesh	typeref:typename:Node *
+getParent	node.h	/^			inline Node* getParent(){return parent;}$/;"	f	class:vb01::Node	typeref:typename:Node *
+getPosition	camera.h	/^			inline Vector3 getPosition(){return position;}$/;"	f	class:vb01::Camera	typeref:typename:Vector3
+getPosition	node.h	/^			inline Vector3 getPosition(){return pos;}$/;"	f	class:vb01::Node	typeref:typename:Vector3
+getRootNode	root.h	/^			inline Node* getRootNode(){return rootNode;}$/;"	f	class:vb01::Root	typeref:typename:Node *
+getShader	material.h	/^			inline Shader* getShader(){return shader;}$/;"	f	class:vb01::Material	typeref:typename:Shader *
+getSingleton	root.cpp	/^	Root* Root::getSingleton(){return root;}$/;"	f	class:vb01::Root	typeref:typename:Root *
+getUp	camera.h	/^			inline Vector3 getUp(){return up;}$/;"	f	class:vb01::Camera	typeref:typename:Vector3
+getWidth	root.h	/^			inline int getWidth(){return width;}$/;"	f	class:vb01::Root	typeref:typename:int
+h	stb_image.h	/^      int h,v;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+h	stb_image.h	/^   int w,h;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+h2	stb_image.h	/^      int x,y,w2,h2;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+ha	stb_image.h	/^      int hd,ha;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+hd	stb_image.h	/^      int hd,ha;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+height	root.h	/^			int width,height;$/;"	m	class:vb01::Root	typeref:typename:int
+height	texture.h	/^			int width,height,numChannels;$/;"	m	class:vb01::Texture	typeref:typename:int
+history	stb_image.h	/^   stbi_uc *history; $/;"	m	struct:__anon84e4e8861308	typeref:typename:stbi_uc *
+hs	stb_image.h	/^   int hs,vs;   \/\/ expansion factor in each axis$/;"	m	struct:__anon84e4e8860a08	typeref:typename:int
+hsz	stb_image.h	/^   int bpp, offset, hsz;$/;"	m	struct:__anon84e4e8861008	typeref:typename:int
+huff_ac	stb_image.h	/^   stbi__huffman huff_ac[4];$/;"	m	struct:__anon84e4e8860808	typeref:typename:stbi__huffman[4]
+huff_dc	stb_image.h	/^   stbi__huffman huff_dc[4];$/;"	m	struct:__anon84e4e8860808	typeref:typename:stbi__huffman[4]
+id	shader.h	/^			unsigned int id;$/;"	m	class:vb01::Shader	typeref:typename:unsigned int
+id	stb_image.h	/^      int id;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+idata	stb_image.h	/^   stbi_uc *idata, *expanded, *out;$/;"	m	struct:__anon84e4e8860e08	typeref:typename:stbi_uc *
+idct_block_kernel	stb_image.h	/^   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);$/;"	m	struct:__anon84e4e8860808	typeref:typename:void (*)(stbi_uc * out,int out_stride,short data[64])
+img_buffer	stb_image.h	/^   stbi_uc *img_buffer, *img_buffer_end;$/;"	m	struct:__anon84e4e8860308	typeref:typename:stbi_uc *
+img_buffer_end	stb_image.h	/^   stbi_uc *img_buffer, *img_buffer_end;$/;"	m	struct:__anon84e4e8860308	typeref:typename:stbi_uc **
+img_buffer_original	stb_image.h	/^   stbi_uc *img_buffer_original, *img_buffer_original_end;$/;"	m	struct:__anon84e4e8860308	typeref:typename:stbi_uc *
+img_buffer_original_end	stb_image.h	/^   stbi_uc *img_buffer_original, *img_buffer_original_end;$/;"	m	struct:__anon84e4e8860308	typeref:typename:stbi_uc **
+img_comp	stb_image.h	/^   } img_comp[4];$/;"	m	struct:__anon84e4e8860808	typeref:struct:__anon84e4e8860808::__anon84e4e8860908[4]
+img_h_max	stb_image.h	/^   int img_h_max, img_v_max;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+img_mcu_h	stb_image.h	/^   int img_mcu_w, img_mcu_h;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+img_mcu_w	stb_image.h	/^   int img_mcu_w, img_mcu_h;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+img_mcu_x	stb_image.h	/^   int img_mcu_x, img_mcu_y;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+img_mcu_y	stb_image.h	/^   int img_mcu_x, img_mcu_y;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+img_n	stb_image.h	/^   int img_n, img_out_n;$/;"	m	struct:__anon84e4e8860308	typeref:typename:int
+img_out_n	stb_image.h	/^   int img_n, img_out_n;$/;"	m	struct:__anon84e4e8860308	typeref:typename:int
+img_v_max	stb_image.h	/^   int img_h_max, img_v_max;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+img_x	stb_image.h	/^   stbi__uint32 img_x, img_y;$/;"	m	struct:__anon84e4e8860308	typeref:typename:stbi__uint32
+img_y	stb_image.h	/^   stbi__uint32 img_x, img_y;$/;"	m	struct:__anon84e4e8860308	typeref:typename:stbi__uint32
+indices	mesh.h	/^			unsigned int *indices,VAO,VBO,EBO;$/;"	m	class:vb01::Mesh	typeref:typename:unsigned int *
+io	stb_image.h	/^   stbi_io_callbacks io;$/;"	m	struct:__anon84e4e8860308	typeref:typename:stbi_io_callbacks
+io_user_data	stb_image.h	/^   void *io_user_data;$/;"	m	struct:__anon84e4e8860308	typeref:typename:void *
+isLighting	material.h	/^			inline bool isLighting(){return lightingEnabled;}$/;"	f	class:vb01::Material	typeref:typename:bool
+jfif	stb_image.h	/^   int            jfif;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+left	camera.h	/^			Vector3 position=Vector3(0,0,0),direction=Vector3::VEC_K,left=Vector3::VEC_I,up=Vector3::VEC_/;"	m	class:vb01::Camera	typeref:typename:Vector3
+length	stb_image.h	/^   stbi__uint32 length;$/;"	m	struct:__anon84e4e8860d08	typeref:typename:stbi__uint32
+lflags	stb_image.h	/^   int lflags;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+lightingEnabled	material.h	/^			bool lightingEnabled=false;$/;"	m	class:vb01::Material	typeref:typename:bool
+line0	stb_image.h	/^   stbi_uc *line0,*line1;$/;"	m	struct:__anon84e4e8860a08	typeref:typename:stbi_uc *
+line1	stb_image.h	/^   stbi_uc *line0,*line1;$/;"	m	struct:__anon84e4e8860a08	typeref:typename:stbi_uc **
+line_size	stb_image.h	/^   int line_size;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+linebuf	stb_image.h	/^      stbi_uc *linebuf;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:stbi_uc *
+load_jpeg_image	stb_image.h	/^static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)$/;"	f	typeref:typename:stbi_uc *
+lookAt	camera.cpp	/^	void Camera::lookAt(Vector3 direction, Vector3 up){$/;"	f	class:vb01::Camera	typeref:typename:void
+lpal	stb_image.h	/^   stbi_uc lpal[256][4];$/;"	m	struct:__anon84e4e8861308	typeref:typename:stbi_uc[256][4]
+ma	stb_image.h	/^   unsigned int mr,mg,mb,ma, all_a;$/;"	m	struct:__anon84e4e8861008	typeref:typename:unsigned int
+main	main.cpp	/^int main(){$/;"	f	typeref:typename:int
+marker	stb_image.h	/^   unsigned char  marker;      \/\/ marker seen while filling entropy buffer$/;"	m	struct:__anon84e4e8860808	typeref:typename:unsigned char
+material	mesh.h	/^			Material *material=nullptr;$/;"	m	class:vb01::Mesh	typeref:typename:Material *
+max_x	stb_image.h	/^   int max_x, max_y;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+max_y	stb_image.h	/^   int max_x, max_y;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+maxcode	stb_image.h	/^   int maxcode[17];$/;"	m	struct:__anon84e4e8860b08	typeref:typename:int[17]
+maxcode	stb_image.h	/^   unsigned int maxcode[18];$/;"	m	struct:__anon84e4e8860708	typeref:typename:unsigned int[18]
+mb	stb_image.h	/^   unsigned int mr,mg,mb,ma, all_a;$/;"	m	struct:__anon84e4e8861008	typeref:typename:unsigned int
+mesh	node.h	/^			Mesh *mesh=nullptr;$/;"	m	class:vb01::Node	typeref:typename:Mesh *
+mg	stb_image.h	/^   unsigned int mr,mg,mb,ma, all_a;$/;"	m	struct:__anon84e4e8861008	typeref:typename:unsigned int
+mr	stb_image.h	/^   unsigned int mr,mg,mb,ma, all_a;$/;"	m	struct:__anon84e4e8861008	typeref:typename:unsigned int
+nearPlane	camera.h	/^			float fov=45,nearPlane=.1,farPlane=100;$/;"	m	class:vb01::Camera	typeref:typename:float
+node	mesh.h	/^			Node *node=nullptr;$/;"	m	class:vb01::Mesh	typeref:typename:Node *
+nomore	stb_image.h	/^   int            nomore;      \/\/ flag if we saw a marker so must stop$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+norm	mesh.h	/^				Vector3 pos,norm;$/;"	m	struct:vb01::Mesh::Vertex	typeref:typename:Vector3
+norm	quaternion.h	/^			inline vb01::quaternion norm(){return *this\/getLength();}$/;"	f	class:vb01::quaternion	typeref:typename:vb01::quaternion
+norm	vector.h	/^		Vector2 norm(){return *this\/getLength();}$/;"	f	struct:vb01::Vector2	typeref:typename:Vector2
+norm	vector.h	/^		Vector3 norm(){return *this\/getLength();}$/;"	f	struct:vb01::Vector3	typeref:typename:Vector3
+normalMap	material.h	/^			Texture *diffuseMap=nullptr,*normalMap=nullptr,*specularMap=nullptr;$/;"	m	class:vb01::Material	typeref:typename:Texture **
+numChannels	texture.h	/^			int width,height,numChannels;$/;"	m	class:vb01::Texture	typeref:typename:int
+numTris	mesh.h	/^			int numTris;$/;"	m	class:vb01::Mesh	typeref:typename:int
+num_bits	stb_image.h	/^   int num_bits;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:int
+num_channels	stb_image.h	/^   int num_channels;$/;"	m	struct:__anon84e4e8860508	typeref:typename:int
+offset	stb_image.h	/^   int bpp, offset, hsz;$/;"	m	struct:__anon84e4e8861008	typeref:typename:int
+operator *	quaternion.h	/^			inline vb01::quaternion operator* (vb01::quaternion q){$/;"	f	class:vb01::quaternion	typeref:typename:vb01::quaternion
+operator *	quaternion.h	/^			template<typename T> inline vb01::quaternion operator*(T s){return quaternion(w*s,x*s,y*s,z*s/;"	f	class:vb01::quaternion	typeref:typename:vb01::quaternion
+operator *	vector.h	/^		template<typename T>Vector2 operator*(T s){return Vector2(x*s,y*s);}$/;"	f	struct:vb01::Vector2	typeref:typename:Vector2
+operator *	vector.h	/^		template<typename T>Vector3 operator*(T s){return Vector3(x*s,y*s,z*s);}$/;"	f	struct:vb01::Vector3	typeref:typename:Vector3
+operator +	quaternion.h	/^			inline vb01::quaternion operator+(quaternion q){return quaternion(w+q.w,x+q.x,y+q.y,z+q.z);}$/;"	f	class:vb01::quaternion	typeref:typename:vb01::quaternion
+operator +	vector.h	/^		template<typename T>Vector2 operator+(T s){return Vector2(x+s,y+s);}$/;"	f	struct:vb01::Vector2	typeref:typename:Vector2
+operator +	vector.h	/^		template<typename T>Vector3 operator+(T s){return Vector3(x+s,y+s,z+s);}$/;"	f	struct:vb01::Vector3	typeref:typename:Vector3
+operator -	quaternion.h	/^			inline vb01::quaternion operator-(quaternion q){return quaternion(w-q.w,x-q.x,y-q.y,z-q.z);}$/;"	f	class:vb01::quaternion	typeref:typename:vb01::quaternion
+operator -	vector.h	/^		Vector3 operator-(const Vector3 &v){return *this;}$/;"	f	struct:vb01::Vector3	typeref:typename:Vector3
+operator -	vector.h	/^		template<typename T>Vector2 operator-(T s){return Vector2(x-s,y-s);}$/;"	f	struct:vb01::Vector2	typeref:typename:Vector2
+operator -	vector.h	/^		template<typename T>Vector3 operator-(T s){return Vector3(x-s,y-s,z-s);}$/;"	f	struct:vb01::Vector3	typeref:typename:Vector3
+operator /	quaternion.h	/^			inline vb01::quaternion operator\/ (float f){return quaternion(w\/f,x\/f,y\/f,z\/f);}$/;"	f	class:vb01::quaternion	typeref:typename:vb01::quaternion
+operator /	vector.h	/^		template<typename T>Vector2 operator\/(T s){return Vector2(x\/s,y\/s);}$/;"	f	struct:vb01::Vector2	typeref:typename:Vector2
+operator /	vector.h	/^		template<typename T>Vector3 operator\/(T s){return Vector3(x\/s,y\/s,z\/s);}$/;"	f	struct:vb01::Vector3	typeref:typename:Vector3
+order	stb_image.h	/^   int scan_n, order[4];$/;"	m	struct:__anon84e4e8860808	typeref:typename:int[4]
+out	stb_image.h	/^   stbi_uc *idata, *expanded, *out;$/;"	m	struct:__anon84e4e8860e08	typeref:typename:stbi_uc ***
+out	stb_image.h	/^   stbi_uc *out;                 \/\/ output buffer (always 4 components)$/;"	m	struct:__anon84e4e8861308	typeref:typename:stbi_uc *
+pal	stb_image.h	/^   stbi_uc  pal[256][4];$/;"	m	struct:__anon84e4e8861308	typeref:typename:stbi_uc[256][4]
+parent	node.h	/^			Node *parent=nullptr;$/;"	m	class:vb01::Node	typeref:typename:Node *
+parse	stb_image.h	/^   int parse, step;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+pos	mesh.h	/^				Vector3 pos,norm;$/;"	m	struct:vb01::Mesh::Vertex	typeref:typename:Vector3
+pos	node.h	/^			Vector3 pos;$/;"	m	class:vb01::Node	typeref:typename:Vector3
+position	camera.h	/^			Vector3 position=Vector3(0,0,0),direction=Vector3::VEC_K,left=Vector3::VEC_I,up=Vector3::VEC_/;"	m	class:vb01::Camera	typeref:typename:Vector3
+prefix	stb_image.h	/^   stbi__int16 prefix;$/;"	m	struct:__anon84e4e8861208	typeref:typename:stbi__int16
+progressive	stb_image.h	/^   int            progressive;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+quaternion	quaternion.h	/^			quaternion(float w,float x,float y,float z){$/;"	f	class:vb01::quaternion
+quaternion	quaternion.h	/^	class quaternion{$/;"	c	namespace:vb01
+ratio	stb_image.h	/^   int flags, bgindex, ratio, transparent, eflags;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+raw_coeff	stb_image.h	/^      void *raw_data, *raw_coeff;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:void **
+raw_data	stb_image.h	/^      void *raw_data, *raw_coeff;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:void *
+read	stb_image.h	/^   int      (*read)  (void *user,char *data,int size);   \/\/ fill 'data' with 'size' bytes.  re/;"	m	struct:__anon84e4e8860208	typeref:typename:int (*)(void * user,char * data,int size)
+read_from_callbacks	stb_image.h	/^   int read_from_callbacks;$/;"	m	struct:__anon84e4e8860308	typeref:typename:int
+recip	quaternion.h	/^			inline vb01::quaternion recip(){return conj()\/getLengthSq();}$/;"	f	class:vb01::quaternion	typeref:typename:vb01::quaternion
+resample	stb_image.h	/^   resample_row_func resample;$/;"	m	struct:__anon84e4e8860a08	typeref:typename:resample_row_func
+resample_row_1	stb_image.h	/^static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)$/;"	f	typeref:typename:stbi_uc *
+resample_row_func	stb_image.h	/^typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,$/;"	t	typeref:typename:stbi_uc * (*)(stbi_uc * out,stbi_uc * in0,stbi_uc * in1,int w,int hs)
+resample_row_hv_2_kernel	stb_image.h	/^   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, /;"	m	struct:__anon84e4e8860808	typeref:typename:stbi_uc * (*)(stbi_uc * out,stbi_uc * in_near,stbi_uc * in_far,int w,int hs)
+restart_interval	stb_image.h	/^   int restart_interval, todo;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+rgb	stb_image.h	/^   int            rgb;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+root	root.cpp	/^	static Root *root=new Root();$/;"	v	namespace:vb01	typeref:typename:Root *	file:
+rootNode	root.h	/^			Node *rootNode;$/;"	m	class:vb01::Root	typeref:typename:Node *
+running	root.h	/^			bool running=false;$/;"	m	class:vb01::Root	typeref:typename:bool
+s	stb_image.h	/^   stbi__context *s;$/;"	m	struct:__anon84e4e8860808	typeref:typename:stbi__context *
+s	stb_image.h	/^   stbi__context *s;$/;"	m	struct:__anon84e4e8860e08	typeref:typename:stbi__context *
+scan_n	stb_image.h	/^   int scan_n, order[4];$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+select	texture.cpp	/^	void Texture::select(){$/;"	f	class:vb01::Texture	typeref:typename:void
+setBool	shader.cpp	/^	void Shader::setBool(bool b, string var){$/;"	f	class:vb01::Shader	typeref:typename:void
+setDiffuseMap	material.h	/^			void setDiffuseMap(std::string diffuseMap){this->diffuseMap=new Texture(diffuseMap);}$/;"	f	class:vb01::Material	typeref:typename:void
+setLightingEnabled	material.h	/^			inline void setLightingEnabled(bool lighting){this->lightingEnabled=lighting;}$/;"	f	class:vb01::Material	typeref:typename:void
+setMat4	shader.cpp	/^	void Shader::setMat4(mat4 mat, string var){$/;"	f	class:vb01::Shader	typeref:typename:void
+setMaterial	mesh.h	/^			void setMaterial(Material *mat){this->material=mat;}$/;"	f	class:vb01::Mesh	typeref:typename:void
+setNode	mesh.h	/^			inline void setNode(Node *node){this->node=node;}$/;"	f	class:vb01::Mesh	typeref:typename:void
+setNormalMap	material.h	/^			void setNormalMap(std::string normalMap){this->normalMap=new Texture(normalMap);}$/;"	f	class:vb01::Material	typeref:typename:void
+setObject	node.cpp	/^	void Node::setObject(Mesh *mesh){$/;"	f	class:vb01::Node	typeref:typename:void
+setPosition	camera.h	/^			void setPosition(Vector3 position){this->position=position;}$/;"	f	class:vb01::Camera	typeref:typename:void
+setSpecularMap	material.h	/^			void setSpecularMap(std::string specularMap){this->specularMap=new Texture(specularMap);}$/;"	f	class:vb01::Material	typeref:typename:void
+shader	material.h	/^			Shader *shader;$/;"	m	class:vb01::Material	typeref:typename:Shader *
+size	stb_image.h	/^   stbi_uc  size[257];$/;"	m	struct:__anon84e4e8860708	typeref:typename:stbi_uc[257]
+size	stb_image.h	/^   stbi_uc  size[288];$/;"	m	struct:__anon84e4e8860b08	typeref:typename:stbi_uc[288]
+size	stb_image.h	/^   stbi_uc size,type,channel;$/;"	m	struct:__anon84e4e8861108	typeref:typename:stbi_uc
+skip	stb_image.h	/^   void     (*skip)  (void *user,int n);                 \/\/ skip the next 'n' bytes, or 'unget/;"	m	struct:__anon84e4e8860208	typeref:typename:void (*)(void * user,int n)
+spec_end	stb_image.h	/^   int            spec_end;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+spec_start	stb_image.h	/^   int            spec_start;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+specularMap	material.h	/^			Texture *diffuseMap=nullptr,*normalMap=nullptr,*specularMap=nullptr;$/;"	m	class:vb01::Material	typeref:typename:Texture ***
+start	root.cpp	/^	void Root::start(int width,int height){$/;"	f	class:vb01::Root	typeref:typename:void
+start_x	stb_image.h	/^   int start_x, start_y;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+start_y	stb_image.h	/^   int start_x, start_y;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+stbi__DNL	stb_image.h	/^#define stbi__DNL(/;"	d
+stbi__EOI	stb_image.h	/^#define stbi__EOI(/;"	d
+stbi__SOF	stb_image.h	/^#define stbi__SOF(/;"	d
+stbi__SOF_progressive	stb_image.h	/^#define stbi__SOF_progressive(/;"	d
+stbi__SOI	stb_image.h	/^#define stbi__SOI(/;"	d
+stbi__SOS	stb_image.h	/^#define stbi__SOS(/;"	d
+stbi__YCbCr_to_RGB_row	stb_image.h	/^static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stb/;"	f	typeref:typename:void
+stbi__YCbCr_to_RGB_simd	stb_image.h	/^static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc /;"	f	typeref:typename:void
+stbi__addsizes_valid	stb_image.h	/^static int stbi__addsizes_valid(int a, int b)$/;"	f	typeref:typename:int
+stbi__at_eof	stb_image.h	/^stbi_inline static int stbi__at_eof(stbi__context *s)$/;"	f	typeref:typename:stbi_inline int
+stbi__bit_reverse	stb_image.h	/^stbi_inline static int stbi__bit_reverse(int v, int bits)$/;"	f	typeref:typename:stbi_inline int
+stbi__bitcount	stb_image.h	/^static int stbi__bitcount(unsigned int a)$/;"	f	typeref:typename:int
+stbi__bitreverse16	stb_image.h	/^stbi_inline static int stbi__bitreverse16(int n)$/;"	f	typeref:typename:stbi_inline int
+stbi__blinn_8x8	stb_image.h	/^static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)$/;"	f	typeref:typename:stbi_uc
+stbi__bmask	stb_image.h	/^static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,1638/;"	v	typeref:typename:const stbi__uint32[17]
+stbi__bmp_data	stb_image.h	/^} stbi__bmp_data;$/;"	t	typeref:struct:__anon84e4e8861008
+stbi__bmp_info	stb_image.h	/^static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__bmp_load	stb_image.h	/^static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__res/;"	f	typeref:typename:void *
+stbi__bmp_parse_header	stb_image.h	/^static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)$/;"	f	typeref:typename:void *
+stbi__bmp_test	stb_image.h	/^static int stbi__bmp_test(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__bmp_test_raw	stb_image.h	/^static int stbi__bmp_test_raw(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__build_fast_ac	stb_image.h	/^static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)$/;"	f	typeref:typename:void
+stbi__build_huffman	stb_image.h	/^static int stbi__build_huffman(stbi__huffman *h, int *count)$/;"	f	typeref:typename:int
+stbi__check_png_header	stb_image.h	/^static int stbi__check_png_header(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__clamp	stb_image.h	/^stbi_inline static stbi_uc stbi__clamp(int x)$/;"	f	typeref:typename:stbi_inline stbi_uc
+stbi__cleanup_jpeg	stb_image.h	/^static void stbi__cleanup_jpeg(stbi__jpeg *j)$/;"	f	typeref:typename:void
+stbi__compute_huffman_codes	stb_image.h	/^static int stbi__compute_huffman_codes(stbi__zbuf *a)$/;"	f	typeref:typename:int
+stbi__compute_transparency	stb_image.h	/^static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)$/;"	f	typeref:typename:int
+stbi__compute_transparency16	stb_image.h	/^static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)$/;"	f	typeref:typename:int
+stbi__compute_y	stb_image.h	/^static stbi_uc stbi__compute_y(int r, int g, int b)$/;"	f	typeref:typename:stbi_uc
+stbi__compute_y_16	stb_image.h	/^static stbi__uint16 stbi__compute_y_16(int r, int g, int b)$/;"	f	typeref:typename:stbi__uint16
+stbi__context	stb_image.h	/^} stbi__context;$/;"	t	typeref:struct:__anon84e4e8860308
+stbi__convert_16_to_8	stb_image.h	/^static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)$/;"	f	typeref:typename:stbi_uc *
+stbi__convert_8_to_16	stb_image.h	/^static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)$/;"	f	typeref:typename:stbi__uint16 *
+stbi__convert_format	stb_image.h	/^static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigne/;"	f	typeref:typename:unsigned char *
+stbi__convert_format16	stb_image.h	/^static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigne/;"	f	typeref:typename:stbi__uint16 *
+stbi__copyval	stb_image.h	/^static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)$/;"	f	typeref:typename:void
+stbi__cpuid3	stb_image.h	/^static int stbi__cpuid3(void)$/;"	f	typeref:typename:int
+stbi__create_png_image	stb_image.h	/^static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len/;"	f	typeref:typename:int
+stbi__create_png_image_raw	stb_image.h	/^static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_/;"	f	typeref:typename:int
+stbi__de_iphone	stb_image.h	/^static void stbi__de_iphone(stbi__png *z)$/;"	f	typeref:typename:void
+stbi__de_iphone_flag	stb_image.h	/^static int stbi__de_iphone_flag = 0;$/;"	v	typeref:typename:int
+stbi__decode_jpeg_header	stb_image.h	/^static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)$/;"	f	typeref:typename:int
+stbi__decode_jpeg_image	stb_image.h	/^static int stbi__decode_jpeg_image(stbi__jpeg *j)$/;"	f	typeref:typename:int
+stbi__depth_scale_table	stb_image.h	/^static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };$/;"	v	typeref:typename:const stbi_uc[9]
+stbi__div16	stb_image.h	/^#define stbi__div16(/;"	d
+stbi__div4	stb_image.h	/^#define stbi__div4(/;"	d
+stbi__do_png	stb_image.h	/^static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info /;"	f	typeref:typename:void *
+stbi__do_zlib	stb_image.h	/^static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)$/;"	f	typeref:typename:int
+stbi__err	stb_image.h	/^   #define stbi__err(/;"	d
+stbi__err	stb_image.h	/^static int stbi__err(const char *str)$/;"	f	typeref:typename:int
+stbi__errpf	stb_image.h	/^#define stbi__errpf(/;"	d
+stbi__errpuc	stb_image.h	/^#define stbi__errpuc(/;"	d
+stbi__expand_png_palette	stb_image.h	/^static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)$/;"	f	typeref:typename:int
+stbi__extend_receive	stb_image.h	/^stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)$/;"	f	typeref:typename:stbi_inline int
+stbi__f2f	stb_image.h	/^#define stbi__f2f(/;"	d
+stbi__fill_bits	stb_image.h	/^static void stbi__fill_bits(stbi__zbuf *z)$/;"	f	typeref:typename:void
+stbi__float2fixed	stb_image.h	/^#define stbi__float2fixed(/;"	d
+stbi__float2int	stb_image.h	/^#define stbi__float2int(/;"	d
+stbi__float_postprocess	stb_image.h	/^static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)$/;"	f	typeref:typename:void
+stbi__fopen	stb_image.h	/^static FILE *stbi__fopen(char const *filename, char const *mode)$/;"	f	typeref:typename:FILE *
+stbi__free_jpeg_components	stb_image.h	/^static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)$/;"	f	typeref:typename:int
+stbi__fsh	stb_image.h	/^#define stbi__fsh(/;"	d
+stbi__g_failure_reason	stb_image.h	/^static const char *stbi__g_failure_reason;$/;"	v	typeref:typename:const char *
+stbi__get16be	stb_image.h	/^static int stbi__get16be(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__get16le	stb_image.h	/^static int stbi__get16le(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__get32be	stb_image.h	/^static stbi__uint32 stbi__get32be(stbi__context *s)$/;"	f	typeref:typename:stbi__uint32
+stbi__get32le	stb_image.h	/^static stbi__uint32 stbi__get32le(stbi__context *s)$/;"	f	typeref:typename:stbi__uint32
+stbi__get8	stb_image.h	/^stbi_inline static stbi_uc stbi__get8(stbi__context *s)$/;"	f	typeref:typename:stbi_inline stbi_uc
+stbi__get_chunk_header	stb_image.h	/^static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)$/;"	f	typeref:typename:stbi__pngchunk
+stbi__get_marker	stb_image.h	/^static stbi_uc stbi__get_marker(stbi__jpeg *j)$/;"	f	typeref:typename:stbi_uc
+stbi__getn	stb_image.h	/^static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)$/;"	f	typeref:typename:int
+stbi__gif	stb_image.h	/^} stbi__gif;$/;"	t	typeref:struct:__anon84e4e8861308
+stbi__gif_header	stb_image.h	/^static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)$/;"	f	typeref:typename:int
+stbi__gif_info	stb_image.h	/^static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__gif_info_raw	stb_image.h	/^static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__gif_load	stb_image.h	/^static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__res/;"	f	typeref:typename:void *
+stbi__gif_load_next	stb_image.h	/^static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stb/;"	f	typeref:typename:stbi_uc *
+stbi__gif_lzw	stb_image.h	/^} stbi__gif_lzw;$/;"	t	typeref:struct:__anon84e4e8861208
+stbi__gif_parse_colortable	stb_image.h	/^static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, i/;"	f	typeref:typename:void
+stbi__gif_test	stb_image.h	/^static int stbi__gif_test(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__gif_test_raw	stb_image.h	/^static int stbi__gif_test_raw(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__grow_buffer_unsafe	stb_image.h	/^static void stbi__grow_buffer_unsafe(stbi__jpeg *j)$/;"	f	typeref:typename:void
+stbi__h2l_gamma_i	stb_image.h	/^static float stbi__h2l_gamma_i=1.0f\/2.2f, stbi__h2l_scale_i=1.0f;$/;"	v	typeref:typename:float
+stbi__h2l_scale_i	stb_image.h	/^static float stbi__h2l_gamma_i=1.0f\/2.2f, stbi__h2l_scale_i=1.0f;$/;"	v	typeref:typename:float
+stbi__hdr_convert	stb_image.h	/^static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)$/;"	f	typeref:typename:void
+stbi__hdr_gettoken	stb_image.h	/^static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)$/;"	f	typeref:typename:char *
+stbi__hdr_info	stb_image.h	/^static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__hdr_load	stb_image.h	/^static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__re/;"	f	typeref:typename:float *
+stbi__hdr_test	stb_image.h	/^static int stbi__hdr_test(stbi__context* s)$/;"	f	typeref:typename:int
+stbi__hdr_test_core	stb_image.h	/^static int stbi__hdr_test_core(stbi__context *s, const char *signature)$/;"	f	typeref:typename:int
+stbi__hdr_to_ldr	stb_image.h	/^static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)$/;"	f	typeref:typename:stbi_uc *
+stbi__high_bit	stb_image.h	/^static int stbi__high_bit(unsigned int z)$/;"	f	typeref:typename:int
+stbi__huffman	stb_image.h	/^} stbi__huffman;$/;"	t	typeref:struct:__anon84e4e8860708
+stbi__idct_block	stb_image.h	/^static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])$/;"	f	typeref:typename:void
+stbi__idct_simd	stb_image.h	/^static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])$/;"	f	typeref:typename:void
+stbi__info_main	stb_image.h	/^static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__int16	stb_image.h	/^typedef   signed short stbi__int16;$/;"	t	typeref:typename:signed short
+stbi__int16	stb_image.h	/^typedef int16_t  stbi__int16;$/;"	t	typeref:typename:int16_t
+stbi__int32	stb_image.h	/^typedef   signed int   stbi__int32;$/;"	t	typeref:typename:signed int
+stbi__int32	stb_image.h	/^typedef int32_t  stbi__int32;$/;"	t	typeref:typename:int32_t
+stbi__is_16_main	stb_image.h	/^static int stbi__is_16_main(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__jbias	stb_image.h	/^static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-819/;"	v	typeref:typename:const int[16]
+stbi__jpeg	stb_image.h	/^} stbi__jpeg;$/;"	t	typeref:struct:__anon84e4e8860808
+stbi__jpeg_decode_block	stb_image.h	/^static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huff/;"	f	typeref:typename:int
+stbi__jpeg_decode_block_prog_ac	stb_image.h	/^static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, st/;"	f	typeref:typename:int
+stbi__jpeg_decode_block_prog_dc	stb_image.h	/^static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, in/;"	f	typeref:typename:int
+stbi__jpeg_dequantize	stb_image.h	/^static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)$/;"	f	typeref:typename:void
+stbi__jpeg_dezigzag	stb_image.h	/^static const stbi_uc stbi__jpeg_dezigzag[64+15] =$/;"	v	typeref:typename:const stbi_uc[]
+stbi__jpeg_finish	stb_image.h	/^static void stbi__jpeg_finish(stbi__jpeg *z)$/;"	f	typeref:typename:void
+stbi__jpeg_get_bit	stb_image.h	/^stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)$/;"	f	typeref:typename:stbi_inline int
+stbi__jpeg_get_bits	stb_image.h	/^stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)$/;"	f	typeref:typename:stbi_inline int
+stbi__jpeg_huff_decode	stb_image.h	/^stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)$/;"	f	typeref:typename:stbi_inline int
+stbi__jpeg_info	stb_image.h	/^static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__jpeg_info_raw	stb_image.h	/^static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__jpeg_load	stb_image.h	/^static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__re/;"	f	typeref:typename:void *
+stbi__jpeg_reset	stb_image.h	/^static void stbi__jpeg_reset(stbi__jpeg *j)$/;"	f	typeref:typename:void
+stbi__jpeg_test	stb_image.h	/^static int stbi__jpeg_test(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__l2h_gamma	stb_image.h	/^static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;$/;"	v	typeref:typename:float
+stbi__l2h_scale	stb_image.h	/^static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;$/;"	v	typeref:typename:float
+stbi__ldr_to_hdr	stb_image.h	/^static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)$/;"	f	typeref:typename:float *
+stbi__load_and_postprocess_16bit	stb_image.h	/^static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *com/;"	f	typeref:typename:stbi__uint16 *
+stbi__load_and_postprocess_8bit	stb_image.h	/^static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *com/;"	f	typeref:typename:unsigned char *
+stbi__load_gif_main	stb_image.h	/^static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *co/;"	f	typeref:typename:void *
+stbi__load_main	stb_image.h	/^static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__re/;"	f	typeref:typename:void *
+stbi__loadf_main	stb_image.h	/^static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)$/;"	f	typeref:typename:float *
+stbi__mad2sizes_valid	stb_image.h	/^static int stbi__mad2sizes_valid(int a, int b, int add)$/;"	f	typeref:typename:int
+stbi__mad3sizes_valid	stb_image.h	/^static int stbi__mad3sizes_valid(int a, int b, int c, int add)$/;"	f	typeref:typename:int
+stbi__mad4sizes_valid	stb_image.h	/^static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)$/;"	f	typeref:typename:int
+stbi__malloc	stb_image.h	/^static void *stbi__malloc(size_t size)$/;"	f	typeref:typename:void *
+stbi__malloc_mad2	stb_image.h	/^static void *stbi__malloc_mad2(int a, int b, int add)$/;"	f	typeref:typename:void *
+stbi__malloc_mad3	stb_image.h	/^static void *stbi__malloc_mad3(int a, int b, int c, int add)$/;"	f	typeref:typename:void *
+stbi__malloc_mad4	stb_image.h	/^static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)$/;"	f	typeref:typename:void *
+stbi__mul2sizes_valid	stb_image.h	/^static int stbi__mul2sizes_valid(int a, int b)$/;"	f	typeref:typename:int
+stbi__out_gif_code	stb_image.h	/^static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)$/;"	f	typeref:typename:void
+stbi__paeth	stb_image.h	/^static int stbi__paeth(int a, int b, int c)$/;"	f	typeref:typename:int
+stbi__parse_entropy_coded_data	stb_image.h	/^static int stbi__parse_entropy_coded_data(stbi__jpeg *z)$/;"	f	typeref:typename:int
+stbi__parse_huffman_block	stb_image.h	/^static int stbi__parse_huffman_block(stbi__zbuf *a)$/;"	f	typeref:typename:int
+stbi__parse_png_file	stb_image.h	/^static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)$/;"	f	typeref:typename:int
+stbi__parse_uncompressed_block	stb_image.h	/^static int stbi__parse_uncompressed_block(stbi__zbuf *a)$/;"	f	typeref:typename:int
+stbi__parse_zlib	stb_image.h	/^static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)$/;"	f	typeref:typename:int
+stbi__parse_zlib_header	stb_image.h	/^static int stbi__parse_zlib_header(stbi__zbuf *a)$/;"	f	typeref:typename:int
+stbi__pic_info	stb_image.h	/^static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__pic_is4	stb_image.h	/^static int stbi__pic_is4(stbi__context *s,const char *str)$/;"	f	typeref:typename:int
+stbi__pic_load	stb_image.h	/^static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__resul/;"	f	typeref:typename:void *
+stbi__pic_load_core	stb_image.h	/^static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *re/;"	f	typeref:typename:stbi_uc *
+stbi__pic_packet	stb_image.h	/^} stbi__pic_packet;$/;"	t	typeref:struct:__anon84e4e8861108
+stbi__pic_test	stb_image.h	/^static int stbi__pic_test(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__pic_test_core	stb_image.h	/^static int stbi__pic_test_core(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__png	stb_image.h	/^} stbi__png;$/;"	t	typeref:struct:__anon84e4e8860e08
+stbi__png_info	stb_image.h	/^static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__png_info_raw	stb_image.h	/^static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__png_is16	stb_image.h	/^static int stbi__png_is16(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__png_load	stb_image.h	/^static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__res/;"	f	typeref:typename:void *
+stbi__png_test	stb_image.h	/^static int stbi__png_test(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__pngchunk	stb_image.h	/^} stbi__pngchunk;$/;"	t	typeref:struct:__anon84e4e8860d08
+stbi__pnm_getinteger	stb_image.h	/^static int      stbi__pnm_getinteger(stbi__context *s, char *c)$/;"	f	typeref:typename:int
+stbi__pnm_info	stb_image.h	/^static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__pnm_isdigit	stb_image.h	/^static int      stbi__pnm_isdigit(char c)$/;"	f	typeref:typename:int
+stbi__pnm_isspace	stb_image.h	/^static int      stbi__pnm_isspace(char c)$/;"	f	typeref:typename:int
+stbi__pnm_load	stb_image.h	/^static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__res/;"	f	typeref:typename:void *
+stbi__pnm_skip_whitespace	stb_image.h	/^static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)$/;"	f	typeref:typename:void
+stbi__pnm_test	stb_image.h	/^static int      stbi__pnm_test(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__process_frame_header	stb_image.h	/^static int stbi__process_frame_header(stbi__jpeg *z, int scan)$/;"	f	typeref:typename:int
+stbi__process_gif_raster	stb_image.h	/^static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)$/;"	f	typeref:typename:stbi_uc *
+stbi__process_marker	stb_image.h	/^static int stbi__process_marker(stbi__jpeg *z, int m)$/;"	f	typeref:typename:int
+stbi__process_scan_header	stb_image.h	/^static int stbi__process_scan_header(stbi__jpeg *z)$/;"	f	typeref:typename:int
+stbi__psd_decode_rle	stb_image.h	/^static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)$/;"	f	typeref:typename:int
+stbi__psd_info	stb_image.h	/^static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__psd_is16	stb_image.h	/^static int stbi__psd_is16(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__psd_load	stb_image.h	/^static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__res/;"	f	typeref:typename:void *
+stbi__psd_test	stb_image.h	/^static int stbi__psd_test(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__readval	stb_image.h	/^static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)$/;"	f	typeref:typename:stbi_uc *
+stbi__refill_buffer	stb_image.h	/^static void stbi__refill_buffer(stbi__context *s)$/;"	f	typeref:typename:void
+stbi__resample	stb_image.h	/^} stbi__resample;$/;"	t	typeref:struct:__anon84e4e8860a08
+stbi__resample_row_generic	stb_image.h	/^static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int /;"	f	typeref:typename:stbi_uc *
+stbi__resample_row_h_2	stb_image.h	/^static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, /;"	f	typeref:typename:stbi_uc *
+stbi__resample_row_hv_2	stb_image.h	/^static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, /;"	f	typeref:typename:stbi_uc *
+stbi__resample_row_hv_2_simd	stb_image.h	/^static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, in/;"	f	typeref:typename:stbi_uc *
+stbi__resample_row_v_2	stb_image.h	/^static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, i/;"	f	typeref:typename:stbi_uc *
+stbi__result_info	stb_image.h	/^} stbi__result_info;$/;"	t	typeref:struct:__anon84e4e8860508
+stbi__rewind	stb_image.h	/^static void stbi__rewind(stbi__context *s)$/;"	f	typeref:typename:void
+stbi__setup_jpeg	stb_image.h	/^static void stbi__setup_jpeg(stbi__jpeg *j)$/;"	f	typeref:typename:void
+stbi__shiftsigned	stb_image.h	/^static int stbi__shiftsigned(unsigned int v, int shift, int bits)$/;"	f	typeref:typename:int
+stbi__skip	stb_image.h	/^static void stbi__skip(stbi__context *s, int n)$/;"	f	typeref:typename:void
+stbi__sse2_available	stb_image.h	/^static int stbi__sse2_available(void)$/;"	f	typeref:typename:int
+stbi__start_callbacks	stb_image.h	/^static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)$/;"	f	typeref:typename:void
+stbi__start_file	stb_image.h	/^static void stbi__start_file(stbi__context *s, FILE *f)$/;"	f	typeref:typename:void
+stbi__start_mem	stb_image.h	/^static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)$/;"	f	typeref:typename:void
+stbi__stdio_callbacks	stb_image.h	/^static stbi_io_callbacks stbi__stdio_callbacks =$/;"	v	typeref:typename:stbi_io_callbacks
+stbi__stdio_eof	stb_image.h	/^static int stbi__stdio_eof(void *user)$/;"	f	typeref:typename:int
+stbi__stdio_read	stb_image.h	/^static int stbi__stdio_read(void *user, char *data, int size)$/;"	f	typeref:typename:int
+stbi__stdio_skip	stb_image.h	/^static void stbi__stdio_skip(void *user, int n)$/;"	f	typeref:typename:void
+stbi__tga_get_comp	stb_image.h	/^static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)$/;"	f	typeref:typename:int
+stbi__tga_info	stb_image.h	/^static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)$/;"	f	typeref:typename:int
+stbi__tga_load	stb_image.h	/^static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__res/;"	f	typeref:typename:void *
+stbi__tga_read_rgb16	stb_image.h	/^static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)$/;"	f	typeref:typename:void
+stbi__tga_test	stb_image.h	/^static int stbi__tga_test(stbi__context *s)$/;"	f	typeref:typename:int
+stbi__uint16	stb_image.h	/^typedef uint16_t stbi__uint16;$/;"	t	typeref:typename:uint16_t
+stbi__uint16	stb_image.h	/^typedef unsigned short stbi__uint16;$/;"	t	typeref:typename:unsigned short
+stbi__uint32	stb_image.h	/^typedef uint32_t stbi__uint32;$/;"	t	typeref:typename:uint32_t
+stbi__uint32	stb_image.h	/^typedef unsigned int   stbi__uint32;$/;"	t	typeref:typename:unsigned int
+stbi__unpremultiply_on_load	stb_image.h	/^static int stbi__unpremultiply_on_load = 0;$/;"	v	typeref:typename:int
+stbi__vertical_flip	stb_image.h	/^static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)$/;"	f	typeref:typename:void
+stbi__vertical_flip_slices	stb_image.h	/^static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)$/;"	f	typeref:typename:void
+stbi__vertically_flip_on_load	stb_image.h	/^static int stbi__vertically_flip_on_load = 0;$/;"	v	typeref:typename:int
+stbi__zbuf	stb_image.h	/^} stbi__zbuf;$/;"	t	typeref:struct:__anon84e4e8860c08
+stbi__zbuild_huffman	stb_image.h	/^static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)$/;"	f	typeref:typename:int
+stbi__zdefault_distance	stb_image.h	/^static const stbi_uc stbi__zdefault_distance[32] =$/;"	v	typeref:typename:const stbi_uc[32]
+stbi__zdefault_length	stb_image.h	/^static const stbi_uc stbi__zdefault_length[288] =$/;"	v	typeref:typename:const stbi_uc[288]
+stbi__zdist_base	stb_image.h	/^static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,$/;"	v	typeref:typename:const int[32]
+stbi__zdist_extra	stb_image.h	/^static const int stbi__zdist_extra[32] =$/;"	v	typeref:typename:const int[32]
+stbi__zexpand	stb_image.h	/^static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  \/\/ need to make room for n bytes$/;"	f	typeref:typename:int
+stbi__zget8	stb_image.h	/^stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)$/;"	f	typeref:typename:stbi_inline stbi_uc
+stbi__zhuffman	stb_image.h	/^} stbi__zhuffman;$/;"	t	typeref:struct:__anon84e4e8860b08
+stbi__zhuffman_decode	stb_image.h	/^stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)$/;"	f	typeref:typename:stbi_inline int
+stbi__zhuffman_decode_slowpath	stb_image.h	/^static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)$/;"	f	typeref:typename:int
+stbi__zlength_base	stb_image.h	/^static const int stbi__zlength_base[31] = {$/;"	v	typeref:typename:const int[31]
+stbi__zlength_extra	stb_image.h	/^static const int stbi__zlength_extra[31]=$/;"	v	typeref:typename:const int[31]
+stbi__zreceive	stb_image.h	/^stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)$/;"	f	typeref:typename:stbi_inline unsigned int
+stbi_convert_iphone_png_to_rgb	stb_image.h	/^STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)$/;"	f	typeref:typename:STBIDEF void
+stbi_convert_wchar_to_utf8	stb_image.h	/^STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)$/;"	f	typeref:typename:STBIDEF int
+stbi_failure_reason	stb_image.h	/^STBIDEF const char *stbi_failure_reason(void)$/;"	f	typeref:typename:STBIDEF const char *
+stbi_hdr_to_ldr_gamma	stb_image.h	/^STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1\/gamma; }$/;"	f	typeref:typename:STBIDEF void
+stbi_hdr_to_ldr_scale	stb_image.h	/^STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1\/scale; }$/;"	f	typeref:typename:STBIDEF void
+stbi_image_free	stb_image.h	/^STBIDEF void stbi_image_free(void *retval_from_stbi_load)$/;"	f	typeref:typename:STBIDEF void
+stbi_info	stb_image.h	/^STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)$/;"	f	typeref:typename:STBIDEF int
+stbi_info_from_callbacks	stb_image.h	/^STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int/;"	f	typeref:typename:STBIDEF int
+stbi_info_from_file	stb_image.h	/^STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)$/;"	f	typeref:typename:STBIDEF int
+stbi_info_from_memory	stb_image.h	/^STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)$/;"	f	typeref:typename:STBIDEF int
+stbi_inline	stb_image.h	/^   #define stbi_inline /;"	d
+stbi_inline	stb_image.h	/^   #define stbi_inline$/;"	d
+stbi_io_callbacks	stb_image.h	/^} stbi_io_callbacks;$/;"	t	typeref:struct:__anon84e4e8860208
+stbi_is_16_bit	stb_image.h	/^STBIDEF int stbi_is_16_bit(char const *filename)$/;"	f	typeref:typename:STBIDEF int
+stbi_is_16_bit_from_callbacks	stb_image.h	/^STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)$/;"	f	typeref:typename:STBIDEF int
+stbi_is_16_bit_from_file	stb_image.h	/^STBIDEF int stbi_is_16_bit_from_file(FILE *f)$/;"	f	typeref:typename:STBIDEF int
+stbi_is_16_bit_from_memory	stb_image.h	/^STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)$/;"	f	typeref:typename:STBIDEF int
+stbi_is_hdr	stb_image.h	/^STBIDEF int      stbi_is_hdr          (char const *filename)$/;"	f	typeref:typename:STBIDEF int
+stbi_is_hdr_from_callbacks	stb_image.h	/^STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)$/;"	f	typeref:typename:STBIDEF int
+stbi_is_hdr_from_file	stb_image.h	/^STBIDEF int stbi_is_hdr_from_file(FILE *f)$/;"	f	typeref:typename:STBIDEF int
+stbi_is_hdr_from_memory	stb_image.h	/^STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)$/;"	f	typeref:typename:STBIDEF int
+stbi_ldr_to_hdr_gamma	stb_image.h	/^STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }$/;"	f	typeref:typename:STBIDEF void
+stbi_ldr_to_hdr_scale	stb_image.h	/^STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }$/;"	f	typeref:typename:STBIDEF void
+stbi_load	stb_image.h	/^STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)$/;"	f	typeref:typename:STBIDEF stbi_uc *
+stbi_load_16	stb_image.h	/^STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)$/;"	f	typeref:typename:STBIDEF stbi_us *
+stbi_load_16_from_callbacks	stb_image.h	/^STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, /;"	f	typeref:typename:STBIDEF stbi_us *
+stbi_load_16_from_memory	stb_image.h	/^STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *c/;"	f	typeref:typename:STBIDEF stbi_us *
+stbi_load_from_callbacks	stb_image.h	/^STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int/;"	f	typeref:typename:STBIDEF stbi_uc *
+stbi_load_from_file	stb_image.h	/^STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)$/;"	f	typeref:typename:STBIDEF stbi_uc *
+stbi_load_from_file_16	stb_image.h	/^STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)$/;"	f	typeref:typename:STBIDEF stbi__uint16 *
+stbi_load_from_memory	stb_image.h	/^STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp/;"	f	typeref:typename:STBIDEF stbi_uc *
+stbi_load_gif_from_memory	stb_image.h	/^STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x,/;"	f	typeref:typename:STBIDEF stbi_uc *
+stbi_loadf	stb_image.h	/^STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)$/;"	f	typeref:typename:STBIDEF float *
+stbi_loadf_from_callbacks	stb_image.h	/^STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int /;"	f	typeref:typename:STBIDEF float *
+stbi_loadf_from_file	stb_image.h	/^STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)$/;"	f	typeref:typename:STBIDEF float *
+stbi_loadf_from_memory	stb_image.h	/^STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp,/;"	f	typeref:typename:STBIDEF float *
+stbi_lrot	stb_image.h	/^   #define stbi_lrot(/;"	d
+stbi_set_flip_vertically_on_load	stb_image.h	/^STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)$/;"	f	typeref:typename:STBIDEF void
+stbi_set_unpremultiply_on_load	stb_image.h	/^STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)$/;"	f	typeref:typename:STBIDEF void
+stbi_uc	stb_image.h	/^typedef unsigned char stbi_uc;$/;"	t	typeref:typename:unsigned char
+stbi_us	stb_image.h	/^typedef unsigned short stbi_us;$/;"	t	typeref:typename:unsigned short
+stbi_zlib_decode_buffer	stb_image.h	/^STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)$/;"	f	typeref:typename:STBIDEF int
+stbi_zlib_decode_malloc	stb_image.h	/^STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)$/;"	f	typeref:typename:STBIDEF char *
+stbi_zlib_decode_malloc_guesssize	stb_image.h	/^STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, i/;"	f	typeref:typename:STBIDEF char *
+stbi_zlib_decode_malloc_guesssize_headerflag	stb_image.h	/^STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int init/;"	f	typeref:typename:STBIDEF char *
+stbi_zlib_decode_noheader_buffer	stb_image.h	/^STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int i/;"	f	typeref:typename:STBIDEF int
+stbi_zlib_decode_noheader_malloc	stb_image.h	/^STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)$/;"	f	typeref:typename:STBIDEF char *
+step	stb_image.h	/^   int parse, step;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+succ_high	stb_image.h	/^   int            succ_high;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+succ_low	stb_image.h	/^   int            succ_low;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+suffix	stb_image.h	/^   stbi_uc suffix;$/;"	m	struct:__anon84e4e8861208	typeref:typename:stbi_uc
+texCoords	mesh.h	/^				Vector2 texCoords;	$/;"	m	struct:vb01::Mesh::Vertex	typeref:typename:Vector2
+texture	texture.h	/^			unsigned int texture;$/;"	m	class:vb01::Texture	typeref:typename:unsigned int
+todo	stb_image.h	/^   int restart_interval, todo;$/;"	m	struct:__anon84e4e8860808	typeref:typename:int
+tq	stb_image.h	/^      int tq;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+transparent	stb_image.h	/^   int flags, bgindex, ratio, transparent, eflags;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+type	stb_image.h	/^   stbi__uint32 type;$/;"	m	struct:__anon84e4e8860d08	typeref:typename:stbi__uint32
+type	stb_image.h	/^   stbi_uc size,type,channel;$/;"	m	struct:__anon84e4e8861108	typeref:typename:stbi_uc
+up	camera.h	/^			Vector3 position=Vector3(0,0,0),direction=Vector3::VEC_K,left=Vector3::VEC_I,up=Vector3::VEC_/;"	m	class:vb01::Camera	typeref:typename:Vector3
+update	box.cpp	/^	void Box::update(){$/;"	f	class:vb01::Box	typeref:typename:void
+update	camera.cpp	/^	void Camera::update(){$/;"	f	class:vb01::Camera	typeref:typename:void
+update	material.cpp	/^	void Material::update(){$/;"	f	class:vb01::Material	typeref:typename:void
+update	mesh.cpp	/^	void Mesh::update(){$/;"	f	class:vb01::Mesh	typeref:typename:void
+update	node.cpp	/^	void Node::update(){$/;"	f	class:vb01::Node	typeref:typename:void
+update	root.cpp	/^	void Root::update(){$/;"	f	class:vb01::Root	typeref:typename:void
+use	shader.cpp	/^	void Shader::use(){glUseProgram(id);}$/;"	f	class:vb01::Shader	typeref:typename:void
+v	stb_image.h	/^      int h,v;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+validate_uint32	stb_image.h	/^typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];$/;"	t	typeref:typename:unsigned char[sizeof (stbi__uint32)==4?1:-1]
+value	stb_image.h	/^   stbi__uint16 value[288];$/;"	m	struct:__anon84e4e8860b08	typeref:typename:stbi__uint16[288]
+values	stb_image.h	/^   stbi_uc  values[256];$/;"	m	struct:__anon84e4e8860708	typeref:typename:stbi_uc[256]
+vb01	box.cpp	/^namespace vb01{$/;"	n	file:
+vb01	box.h	/^namespace vb01{$/;"	n
+vb01	camera.cpp	/^namespace vb01{$/;"	n	file:
+vb01	camera.h	/^namespace vb01{$/;"	n
+vb01	material.cpp	/^namespace vb01{$/;"	n	file:
+vb01	material.h	/^namespace vb01{$/;"	n
+vb01	mesh.cpp	/^namespace vb01{$/;"	n	file:
+vb01	mesh.h	/^namespace vb01{$/;"	n
+vb01	node.cpp	/^namespace vb01{$/;"	n	file:
+vb01	node.h	/^namespace vb01{$/;"	n
+vb01	quad.cpp	/^namespace vb01{$/;"	n	file:
+vb01	quad.h	/^namespace vb01{$/;"	n
+vb01	quaternion.cpp	/^namespace vb01{$/;"	n	file:
+vb01	quaternion.h	/^namespace vb01{$/;"	n
+vb01	root.cpp	/^namespace vb01{$/;"	n	file:
+vb01	root.h	/^namespace vb01{$/;"	n
+vb01	shader.cpp	/^namespace vb01{$/;"	n	file:
+vb01	shader.h	/^namespace vb01{$/;"	n
+vb01	texture.cpp	/^namespace vb01{$/;"	n	file:
+vb01	texture.h	/^namespace vb01{$/;"	n
+vb01	vector.cpp	/^namespace vb01{$/;"	n	file:
+vb01	vector.h	/^namespace vb01{$/;"	n
+vertices	mesh.h	/^			Vertex *vertices;$/;"	m	class:vb01::Mesh	typeref:typename:Vertex *
+vs	stb_image.h	/^   int hs,vs;   \/\/ expansion factor in each axis$/;"	m	struct:__anon84e4e8860a08	typeref:typename:int
+w	quaternion.h	/^			float w,x,y,z;$/;"	m	class:vb01::quaternion	typeref:typename:float
+w	stb_image.h	/^   int w,h;$/;"	m	struct:__anon84e4e8861308	typeref:typename:int
+w2	stb_image.h	/^      int x,y,w2,h2;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+w_lores	stb_image.h	/^   int w_lores; \/\/ horizontal pixels pre-expansion$/;"	m	struct:__anon84e4e8860a08	typeref:typename:int
+width	root.h	/^			int width,height;$/;"	m	class:vb01::Root	typeref:typename:int
+width	texture.h	/^			int width,height,numChannels;$/;"	m	class:vb01::Texture	typeref:typename:int
+window	root.h	/^			GLFWwindow *window;$/;"	m	class:vb01::Root	typeref:typename:GLFWwindow *
+x	quaternion.h	/^			float w,x,y,z;$/;"	m	class:vb01::quaternion	typeref:typename:float
+x	stb_image.h	/^      int x,y,w2,h2;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+x	vector.h	/^		float x,y,z;$/;"	m	struct:vb01::Vector3	typeref:typename:float
+x	vector.h	/^		float x,y;$/;"	m	struct:vb01::Vector2	typeref:typename:float
+y	quaternion.h	/^			float w,x,y,z;$/;"	m	class:vb01::quaternion	typeref:typename:float
+y	stb_image.h	/^      int x,y,w2,h2;$/;"	m	struct:__anon84e4e8860808::__anon84e4e8860908	typeref:typename:int
+y	vector.h	/^		float x,y,z;$/;"	m	struct:vb01::Vector3	typeref:typename:float
+y	vector.h	/^		float x,y;$/;"	m	struct:vb01::Vector2	typeref:typename:float
+ypos	stb_image.h	/^   int ypos;    \/\/ which pre-expansion row we're on$/;"	m	struct:__anon84e4e8860a08	typeref:typename:int
+ystep	stb_image.h	/^   int ystep;   \/\/ how far through vertical expansion we are$/;"	m	struct:__anon84e4e8860a08	typeref:typename:int
+z	quaternion.h	/^			float w,x,y,z;$/;"	m	class:vb01::quaternion	typeref:typename:float
+z	vector.h	/^		float x,y,z;$/;"	m	struct:vb01::Vector3	typeref:typename:float
+z_distance	stb_image.h	/^   stbi__zhuffman z_length, z_distance;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:stbi__zhuffman
+z_expandable	stb_image.h	/^   int   z_expandable;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:int
+z_length	stb_image.h	/^   stbi__zhuffman z_length, z_distance;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:stbi__zhuffman
+zbuffer	stb_image.h	/^   stbi_uc *zbuffer, *zbuffer_end;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:stbi_uc *
+zbuffer_end	stb_image.h	/^   stbi_uc *zbuffer, *zbuffer_end;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:stbi_uc **
+zout	stb_image.h	/^   char *zout;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:char *
+zout_end	stb_image.h	/^   char *zout_end;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:char *
+zout_start	stb_image.h	/^   char *zout_start;$/;"	m	struct:__anon84e4e8860c08	typeref:typename:char *
+~Camera	camera.cpp	/^	Camera::~Camera(){}$/;"	f	class:vb01::Camera
+~Material	material.cpp	/^	Material::~Material(){}$/;"	f	class:vb01::Material
+~Mesh	mesh.cpp	/^	Mesh::~Mesh(){}$/;"	f	class:vb01::Mesh
+~Node	node.cpp	/^	Node::~Node(){}$/;"	f	class:vb01::Node

texture.cpp

@@ -0,0 +1,28 @@
+#define STB_IMAGE_IMPLEMENTATION
+#include"stb_image.h"
+#include<glad.h>
+#include<glfw3.h>
+#include"texture.h"
+
+using namespace std;
+
+namespace vb01{
+	Texture::Texture(string path){
+		glGenTextures(1,&texture);
+		glBindTexture(GL_TEXTURE_2D,texture);
+		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+
+		data=stbi_load(path.c_str(),&width,&height,&numChannels,0);
+
+		glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,width,height,0,GL_RGB,GL_UNSIGNED_BYTE,data);
+		//glGenerateMipmap(GL_TEXTURE_2D);
+		stbi_image_free(data);
+	}
+
+	void Texture::select(){
+		glBindTexture(GL_TEXTURE_2D,texture);
+	}
+}

texture.h

@@ -0,0 +1,18 @@
+#ifndef TEXTURE_H
+#define TEXTURE_H
+
+#include<string>
+
+namespace vb01{
+	class Texture{
+		public:
+			Texture(std::string);
+			void select();
+		private:
+			unsigned int texture;
+			int width,height,numChannels;
+			unsigned char *data;
+	};
+}
+
+#endif

vector.cpp

@@ -0,0 +1,12 @@
+#include"vector.h"
+
+namespace vb01{
+	const Vector2 Vector2::VEC_I(1,0); 
+	const Vector2 Vector2::VEC_J(0,1); 
+	const Vector2 Vector2::VEC_ZERO(0,0); 
+
+	const Vector3 Vector3::VEC_I(1,0,0); 
+	const Vector3 Vector3::VEC_J(0,1,0); 
+	const Vector3 Vector3::VEC_K(0,0,1); 
+	const Vector3 Vector3::VEC_ZERO(0,0,0); 
+}

vector.h

@@ -0,0 +1,52 @@
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#include<cmath>
+
+namespace vb01{
+	struct Vector3{
+		Vector3(){};
+		Vector3(float x,float y,float z){
+			this->x=x;
+			this->y=y;
+			this->z=z;
+		}
+		Vector3 operator-(const Vector3 &v){return *this;}
+		template<typename T>Vector3 operator+(T s){return Vector3(x+s,y+s,z+s);}
+		template<typename T>Vector3 operator-(T s){return Vector3(x-s,y-s,z-s);}
+		template<typename T>Vector3 operator*(T s){return Vector3(x*s,y*s,z*s);}
+		template<typename T>Vector3 operator/(T s){return Vector3(x/s,y/s,z/s);}
+		float getLengthSq(){return x*x+y*y+z*z;}
+		float getLength(){return std::sqrt(getLengthSq());}
+		float dot(Vector3 v){return x*v.x+y*v.y+z*v.z;}
+		float getAngleBetween(Vector3 v){return std::acos(dot(v));}
+		Vector3 norm(){return *this/getLength();}
+		Vector3 cross(Vector3 v){return Vector3(y*v.z-v.y*z,x*v.z-v.x*z,x*v.y-v.x*y);}
+
+		float x,y,z;
+		static const Vector3 VEC_I,VEC_J,VEC_K,VEC_ZERO;
+	};
+
+	struct Vector2{
+		Vector2(){};
+		Vector2(float x,float y){
+			this->x=x;
+			this->y=y;
+		}
+		template<typename T>Vector2 operator+(T s){return Vector2(x+s,y+s);}
+		template<typename T>Vector2 operator-(T s){return Vector2(x-s,y-s);}
+		template<typename T>Vector2 operator*(T s){return Vector2(x*s,y*s);}
+		template<typename T>Vector2 operator/(T s){return Vector2(x/s,y/s);}
+		float getLengthSq(){return x*x+y*y;}
+		float getLength(){return std::sqrt(getLengthSq());}
+		float dot(Vector2 v){return x*v.x+y*v.y;}
+		float getAngleBetween(Vector2 v){return std::acos(dot(v));}
+		Vector2 norm(){return *this/getLength();}
+
+		float x,y;
+		static const Vector2 VEC_I,VEC_J,VEC_ZERO;
+	};
+}
+
+#endif
+