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

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();

27
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;
}
generate_octree(dimensions);
}
voxel_data[i] = 1;
}
// for (uint64_t i = 0; i < dimensions * dimensions * dimensions; i++) {
// if (rand() % 25 < 2)
// voxel_data[i] = 1;
// else
// voxel_data[i] = 0;
// }
setVoxel(sf::Vector3i(1, 1, 1), 0);
void Map::generate_octree(unsigned int dimensions) {
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){

55
src/map/Octree.cpp
View File

@@ -21,18 +21,13 @@ void Octree::Generate(char* data, sf::Vector3i dimensions) {
PrettyPrintUINT64(std::get<0>(root_node), &output_stream);
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));
descriptor_buffer_position--;
root_index = descriptor_buffer_position;
descriptor_buffer_position--;
// ========================================
@@ -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;
}

4
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);
@@ -1094,4 +1094,4 @@ void Hardware_Caster::device::print(std::ostream& stream) const {
void Hardware_Caster::device::print_packed_data(std::ostream& stream) {
stream.write(reinterpret_cast<char*>(&data), sizeof(data));
}
}