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

Linux build working again, removed the GL_Testing stuff, I'm going to move to Vulkan eventually. Got voxel search working mostly with the new octree changes. Issue with mirroring of voxel data currently

Browse Source
This commit is contained in:
MitchellHansen
2017-07-02 12:36:25 -07:00
parent 04842dd597
commit 5e9401cd27
11 changed files with 72 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/Camera.h
View File

@@ -3,6 +3,7 @@
#include <SFML/System/Vector2.hpp>
#include "util.hpp"
#include "Pub_Sub.h"
#include <cmath>
class Camera : public VrEventSubscriber{
public:

43
include/GL_Testing.h
View File

@@ -1,43 +0,0 @@
#pragma once
#include <string>
#include <util.hpp>
#include <cstring>
#ifdef _WIN32
#define GLEW_STATIC
#include <GL/glew.h>
#elif defined TARGET_OS_MAC
#include <OpenGL/gl.h>
#endif
class GL_Testing
{
public:
GL_Testing();
~GL_Testing(){};
enum Shader_Type {VERTEX, FRAGMENT};
void compile_shader(std::string file_path, Shader_Type t);
void create_program();
void create_buffers();
void transform();
void rotate(double delta);
void draw();
private:
GLuint VBO; //raw points
GLuint EBO; //link triangles
GLuint VAO;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint shader_program;
GLfloat *matrix;
double counter = 0;
};

5
include/map/Map.h
View File

@@ -25,10 +25,9 @@ public:
Map(uint32_t dimensions);
void setVoxel(sf::Vector3i position, int val);
bool getVoxelFromOctree(sf::Vector3i position);
bool getVoxel(sf::Vector3i pos);
Octree octree;
bool test();
@@ -40,8 +39,6 @@ private:
std::stringstream output_stream;
// =========================
void generate_octree(unsigned int dimensions);
char* voxel_data;
};

5
include/map/Octree.h
View File

@@ -24,7 +24,6 @@ public:
static const int buffer_size = 100000;
Octree();
~Octree() {};
@@ -56,10 +55,12 @@ public:
// With a position and the head of the stack. Traverse down the voxel hierarchy to find
// the IDX and stack position of the highest resolution (maybe set resolution?) oct
bool get_voxel(sf::Vector3i position);
bool GetVoxel(sf::Vector3i position);
void print_block(int block_pos);
bool Validate(char* data, sf::Vector3i dimensions);
private:
std::tuple<uint64_t, uint64_t> GenerationRecursion(

2
include/raycaster/Hardware_Caster.h
View File

@@ -85,7 +85,7 @@ struct device_info {
cl_uint cl_device_preferred_vector_width_double;
char cl_device_profile[256];
size_t cl_device_profiling_timer_resolution;
cl_device_type cl_device_type;
cl_device_type device_type;
char cl_device_vendor[128];
cl_uint cl_device_vendor_id;
char cl_device_version[128];

2
include/util.hpp
View File

@@ -7,7 +7,7 @@
#include <sstream>
#include <string>
#include <imgui/imgui.h>
#include <cmath>
const double PI = 3.141592653589793238463;
const float PI_F = 3.14159265358979f;

199
src/GL_Testing.cpp
View File

@@ -1,199 +0,0 @@
#include "GL_Testing.h"
GL_Testing::GL_Testing() {
GLfloat tmp[] = {
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, static_cast<float>(cos(1.0f)), static_cast<float>(sin(1.0f)), 0.0f,
0.0f, static_cast<float>(-sin(1.0f)), static_cast<float>(cos(1.0f)), 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
matrix = new GLfloat[16];
memcpy(matrix, tmp, sizeof(GLfloat) * 16);
#ifdef linux
GLint err = glewInit();
#elif _WIN32
GLint err = glewInit();
#elif TARGET_OS_MAC
GLint err = 0;
#endif
if (err) {
std::cout << "error initializing glew" << std::endl;
}
}
void GL_Testing::compile_shader(std::string file_path, Shader_Type t) {
// Load in the source and cstring it
const char* source;
std::string tmp;
tmp = read_file(file_path);
source = tmp.c_str();
GLint success;
GLchar log[512];
if (t == Shader_Type::VERTEX) {
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &source, NULL);
glCompileShader(vertex_shader);
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(vertex_shader, 512, NULL, log);
std::cout << "Vertex shader failed compilation: " << log << std::endl;
}
} else if (t == Shader_Type::FRAGMENT) {
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &source, NULL);
glCompileShader(fragment_shader);
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(fragment_shader, 512, NULL, log);
std::cout << "Vertex shader failed compilation: " << log << std::endl;
}
}
}
void GL_Testing::create_program() {
GLint success;
GLchar log[512];
shader_program = glCreateProgram();
glAttachShader(shader_program, vertex_shader);
glAttachShader(shader_program, fragment_shader);
glLinkProgram(shader_program);
glGetProgramiv(shader_program, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shader_program, 512, NULL, log);
std::cout << "Failed to link shaders into program: " << log << std::endl;
}
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
}
void GL_Testing::create_buffers() {
GLfloat vertices[] = {
0.5f, 0.5f, 0.0f, // Top Right
0.5f, -0.5f, 0.0f, // Bottom Right
-0.5f, -0.5f, 0.0f, // Bottom Left
-0.5f, 0.5f, 0.0f // Top Left
};
GLuint indices[] = { // Note that we start from 0!
0, 1, 3 // First Triangle
// Second Triangle
};
#ifdef linux
glGenVertexArrays(1, &VAO);
#elif defined _WIN32
glGenVertexArrays(1, &VAO);
#elif defined TARGET_OS_MAC
glGenVertexArraysAPPLE(1, &VAO);
#endif
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);
// Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s).
#ifdef linux
glBindVertexArray(VAO);
#elif defined _WIN32
glBindVertexArray(VAO);
#elif defined TARGET_OS_MAC
glBindVertexArrayAPPLE(VAO);
#endif
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
#ifdef linux
glbindvertexarray(0);
#elif defined _win32
glbindvertexarray(0);
#elif defined target_os_mac
glbindvertexarrayapple(0);
#endif
}
void GL_Testing::transform()
{
GLuint transformLoc = glGetUniformLocation(shader_program, "transform");
glUseProgram(shader_program);
glUniformMatrix4fv(transformLoc, 1, GL_FALSE, matrix);
}
void GL_Testing::rotate(double delta) {
counter += delta;
GLfloat tmp[] = {
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, static_cast<float>(cos(counter)), static_cast<float>(sin(counter)), 0.0f,
0.0f, static_cast<float>(-sin(counter)), static_cast<float>(cos(counter)), 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
memcpy(matrix, tmp, sizeof(GLfloat) * 16);
}
void GL_Testing::draw() {
glUseProgram(shader_program);
#ifdef linux
glBindVertexArray(VAO);
#elif defined _WIN32
glBindVertexArray(VAO);
#elif defined TARGET_OS_MAC
glBindVertexArrayAPPLE(VAO);
#endif
//glDrawArrays(GL_TRIANGLES, 0, 6);
glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);
#ifdef linux
glbindVertexArray(0);
#elif defined _win32
glbindVertexArray(0);
#elif defined target_os_mac
glbindVertexArrayAPPLE(0);
#endif
}
//

28
src/main.cpp
View File

@@ -1,6 +1,6 @@

// This has to be up here or else glew will complain
#include "GL_Testing.h"
//#include "GL_Testing.h"
#ifdef linux
#include <CL/cl.h>
@@ -16,8 +16,8 @@
#elif defined TARGET_OS_MAC
#include <OpenGL/gl.h>
# include <OpenGL/OpenGL.h>
# include <OpenCL/opencl.h>
#include <OpenGL/OpenGL.h>
#include <OpenCL/opencl.h>
#include <OpenCL/cl_gl_ext.h>
#include <OpenCL/cl_ext.h>
#endif
@@ -65,31 +65,14 @@ float elap_time(){
sf::Sprite window_sprite;
sf::Texture window_texture;
// Y: -1.57 is straight up
// Y: 1.57 is straight down
// TODO:
// - Texture axis sign flipping issue
// - Diffuse fog hard cut off
// - Infinite light distance, no inverse square
// - Inconsistent lighting constants. GUI manipulation
// - Far pointers, attachment lookup and aux buffer, contour lookup & masking
// Ancilary settings buffer and memory controller
// - Attachment lookup and aux buffer, contour lookup & masking
int main() {
// Keep at this at the top of main. I think it has to do with it and
// sf::RenderWindow stepping on each others feet
#ifdef linux
glewInit();
#elif defined _WIN32
//glewInit();
#elif defined TARGET_OS_MAC
// Do nothing, extension wrangling handled by macOS
#endif
// =============================
Map _map(32);
//_map.test();
@@ -113,7 +96,6 @@ int main() {
abort();
}
// Create and generate the old 3d array style map
Old_Map* map = new Old_Map(sf::Vector3i(MAP_X, MAP_Y, MAP_Z));
map->generate_terrain();

23
src/map/Map.cpp
View File

@@ -5,31 +5,34 @@ Map::Map(uint32_t dimensions) {
srand(time(nullptr));
voxel_data = new char[dimensions * dimensions * dimensions];
voxel_data = new char[dimensions * dimensions * dimensions]();
for (uint64_t i = 0; i < dimensions * dimensions * dimensions; i++) {
if (rand() % 25 < 2)
voxel_data[i] = 1;
else
voxel_data[i] = 0;
}
// for (uint64_t i = 0; i < dimensions * dimensions * dimensions; i++) {
// if (rand() % 25 < 2)
// voxel_data[i] = 1;
// else
// voxel_data[i] = 0;
// }
generate_octree(dimensions);
}
void Map::generate_octree(unsigned int dimensions) {
setVoxel(sf::Vector3i(1, 1, 1), 0);
octree.Generate(voxel_data, sf::Vector3i(dimensions, dimensions, dimensions));
octree.Validate(voxel_data, sf::Vector3i(dimensions, dimensions, dimensions));
}
void Map::setVoxel(sf::Vector3i world_position, int val) {
void Map::setVoxel(sf::Vector3i pos, int val) {
voxel_data[pos.x + OCT_DIM * (pos.y + OCT_DIM * pos.z)] = val;
}
bool Map::getVoxelFromOctree(sf::Vector3i position)
{
return octree.get_voxel(position);
return 0;
}
bool Map::getVoxel(sf::Vector3i pos){

53
src/map/Octree.cpp
View File

@@ -22,18 +22,13 @@ void Octree::Generate(char* data, sf::Vector3i dimensions) {
output_stream << " " << OCT_DIM << " " << counter++ << std::endl;
// ==============================
// ============= TEMP!!! ===================
if (stack_pos - 1 > stack_pos) {
global_pos -= stack_pos;
stack_pos = 0x8000;
}
else {
stack_pos -= 1;
}
std::get<0>(root_node) |= 1;
memcpy(&descriptor_buffer[descriptor_buffer_position], &std::get<0>(root_node), sizeof(uint64_t));
root_index = descriptor_buffer_position;
descriptor_buffer_position--;
// ========================================
DumpLog(&output_stream, "raw_output.txt");
@@ -48,13 +43,15 @@ void Octree::Generate(char* data, sf::Vector3i dimensions) {
}
bool Octree::get_voxel(sf::Vector3i position) {
bool Octree::GetVoxel(sf::Vector3i position) {
// Struct that holds the state necessary to continue the traversal from the found voxel
oct_state state;
// push the root node to the parent stack
uint64_t head = descriptor_buffer[root_index];
uint64_t current_index = root_index;
uint64_t head = descriptor_buffer[current_index];
// PrettyPrintUINT64(head);
state.parent_stack[state.parent_stack_position] = head;
// Set our initial dimension and the position at the corner of the oct to keep track of our position
@@ -98,6 +95,7 @@ bool Octree::get_voxel(sf::Vector3i position) {
mask_index += 2;
// What is up with the binary operator on this one? TODO
state.idx_stack[state.scale] ^= idx_set_y_mask;
}
@@ -131,7 +129,8 @@ bool Octree::get_voxel(sf::Vector3i position) {
// access the element at which head points to and then add the specified number of indices
// to get to the correct child descriptor
head = descriptor_buffer[(head & child_pointer_mask) + count];
current_index = current_index + (head & child_pointer_mask) + count;
head = descriptor_buffer[current_index];
// Increment the parent stack position and put the new oct node as the parent
state.parent_stack_position++;
@@ -313,7 +312,35 @@ std::tuple<uint64_t, uint64_t> Octree::GenerationRecursion(char* data, sf::Vecto
}
char Octree::get1DIndexedVoxel(char* data, sf::Vector3i dimensions, sf::Vector3i position) {
return data[position.x + OCT_DIM * (position.y + OCT_DIM * position.z)];
return data[position.x + dimensions.x * (position.y + dimensions.y * position.z)];
}
bool Octree::Validate(char* data, sf::Vector3i dimensions){
// std::cout << (int)get1DIndexedVoxel(data, dimensions, sf::Vector3i(16, 16, 16)) << std::endl;
// std::cout << (int)GetVoxel(sf::Vector3i(16, 16, 16)) << std::endl;
std::cout << "Validating map..." << std::endl;
for (int x = 0; x < OCT_DIM; x++) {
for (int y = 0; y < OCT_DIM; y++) {
for (int z = 0; z < OCT_DIM; z++) {
sf::Vector3i pos(x, y, z);
char arr_val = get1DIndexedVoxel(data, dimensions, pos);
char oct_val = GetVoxel(pos);
if (arr_val != oct_val) {
std::cout << "X: " << pos.x << " Y: " << pos.y << " Z: " << pos.z << " ";
std::cout << (int)arr_val << " : " << (int)oct_val << std::endl;
}
}
}
}
std::cout << "Done" << std::endl;
}

2
src/raycaster/Hardware_Caster.cpp
View File

@@ -478,7 +478,7 @@ int Hardware_Caster::query_hardware() {
clGetDeviceInfo(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof(cl_uint), &d.cl_device_preferred_vector_width_double, NULL);
clGetDeviceInfo(id, CL_DEVICE_PROFILE, sizeof(char) * 256, &d.cl_device_profile, NULL);
clGetDeviceInfo(id, CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof(size_t), &d.cl_device_profiling_timer_resolution, NULL);
clGetDeviceInfo(id, CL_DEVICE_TYPE, sizeof(cl_device_type), &d.cl_device_type, NULL);
clGetDeviceInfo(id, CL_DEVICE_TYPE, sizeof(cl_device_type), &d.device_type, NULL);
clGetDeviceInfo(id, CL_DEVICE_VENDOR, sizeof(char)*128, &d.cl_device_vendor, NULL);
clGetDeviceInfo(id, CL_DEVICE_VENDOR_ID, sizeof(cl_uint), &d.cl_device_vendor_id, NULL);
clGetDeviceInfo(id, CL_DEVICE_VERSION, sizeof(char)*128, &d.cl_device_version, NULL);