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

Had a linking problem in the CMakeLists, fixed.

Browse Source 
Added a test file to check for cl/gl interop support & supported cl version
Finished CL setup up to the creation of the command queue
master
mitchellhansen 8 years ago
parent bc093ef4e4
commit 49817f94b7
3 changed files with 224 additions and 127 deletions
Show Stats Download Patch File Download Diff File

8
CMakeLists.txt
Unescape View File

@ -21,8 +21,10 @@ message(STATUS "OpenCL found: ${OPENCL_FOUND}")
find_package( OpenGL REQUIRED)
message(STATUS "OpenGL found: ${OPENGL_FOUND}")
# Include the directories for the main programs headers, and SFML's headers
# Include the directories for the main program, GL, CL and SFML's headers
include_directories(${SFML_INCLUDE_DIR})
include_directories(${OpenCL_INCLUDE_DIRS})
include_directories(${OpenGL_INCLUDE_DIRS})
include_directories(include)
# Set the .cpp sources
@ -30,9 +32,9 @@ file(GLOB SOURCES "src/*.cpp")
add_executable(${PNAME} ${SOURCES})
# Link CL, GL, and SFML
target_link_libraries(${PNAME} ${SFML_LIBRARIES} ${SFML_DEPENDENCIES})
target_link_libraries (${PNAME} ${SFML_LIBRARIES} ${SFML_DEPENDENCIES})
target_link_libraries (${PNAME} ${OpenCL_LIBRARY})
target_link_libraries (${PNAME} ${OpenGL_LIBRARY})
target_link_libraries (${PNAME} ${OPENGL_LIBRARIES})
# Setup to use C++11
set_property(TARGET ${PNAME} PROPERTY CXX_STANDARD 11) # Use C++11

95
src/TestPlatform.cpp
Unescape View File

@ -0,0 +1,95 @@
#ifdef linux
#elif defined _WIN32
#elif defined TARGET_OS_MAC
# include <GL/glew.h>
# include <OpenGL/OpenGL.h>
# include <OpenCL/opencl.h>
#endif
int IsExtensionSupported(
const char* support_str,
const char* ext_string,
size_t ext_buffer_size) {
size_t offset = 0;
const char* space_substr = strnstr(ext_string + offset, " ", ext_buffer_size - offset);
size_t space_pos = space_substr ? space_substr - ext_string : 0;
while (space_pos < ext_buffer_size) {
if( strncmp(support_str, ext_string + offset, space_pos) == 0 ) {
// Device supports requested extension!
printf("Info: Found extension support ‘%s’!\n", support_str);
return 1;
}
// Keep searching -- skip to next token string
offset = space_pos + 1;
space_substr = strnstr(ext_string + offset, " ", ext_buffer_size - offset);
space_pos = space_substr ? space_substr - ext_string : 0;
}
printf("Warning: Extension not supported ‘%s’!\n", support_str);
return 0;
}
int test_for_gl_cl_sharing() {
int err = 0;
#if defined (__APPLE__) || defined(MACOSX)
static const char *CL_GL_SHARING_EXT = "cl_APPLE_gl_sharing";
#else
static const char* CL_GL_SHARING_EXT = "cl_khr_gl_sharing";
#endif
cl_uint num_devices, i;
clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices);
cl_device_id *devices = (cl_device_id *) calloc(sizeof(cl_device_id), num_devices);
clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, num_devices, devices, NULL);
// Get string containing supported device extensions
size_t ext_size = 1024;
char *ext_string = (char *) malloc(ext_size);
err = clGetDeviceInfo(devices[0], CL_DEVICE_EXTENSIONS, ext_size, ext_string, &ext_size);
free(devices);
// Search for GL support in extension string (space delimited)
int supported = IsExtensionSupported(CL_GL_SHARING_EXT, ext_string, ext_size);
if (supported) {
// Device supports context sharing with OpenGL
printf("Found GL Sharing Support!\n");
return 1;
}
return -1;
}
int query_platform_devices() {
// From stackoverflow, gets and lists the compute devices
cl_uint num_devices, i;
clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices);
cl_device_id *devices = (cl_device_id *) calloc(sizeof(cl_device_id), num_devices);
clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, num_devices, devices, NULL);
char buf[128];
for (i = 0; i < num_devices; i++) {
clGetDeviceInfo(devices[i], CL_DEVICE_NAME, 128, buf, NULL);
fprintf(stdout, "Device %s supports ", buf);
clGetDeviceInfo(devices[i], CL_DEVICE_VERSION, 128, buf, NULL);
fprintf(stdout, "%s\n", buf);
}
free(devices);
return 1;
}

248
src/main.cpp
Unescape View File

@ -1,36 +1,37 @@
#include <SFML/Graphics.hpp>
#include <iostream>
#include <string>
#include <chrono>
#include "util.hpp"
#include "RayCaster.h"
#include <Map.h>
#include "Curses.h"
#include <OpenCL/opencl.h>
# include <GL/glew.h>
const int WINDOW_X = 150;
const int WINDOW_Y = 150;
#ifdef linux
#elif defined _WIN32
#include <CL/cl.h>
#include <CL/opencl.h>
#include <windows.h>
#elif defined TARGET_OS_MAC
# include <OpenGL/OpenGL.h>
# include <OpenCL/opencl.h>
int main(){
#endif
cl_uint num_devices, i;
clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices);
cl_device_id* devices = (cl_device_id*)calloc(sizeof(cl_device_id), num_devices);
clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, num_devices, devices, NULL);
const int WINDOW_X = 150;
const int WINDOW_Y = 150;
char buf[128];
for (i = 0; i < num_devices; i++) {
clGetDeviceInfo(devices[i], CL_DEVICE_NAME, 128, buf, NULL);
fprintf(stdout, "Device %s supports ", buf);
clGetDeviceInfo(devices[i], CL_DEVICE_VERSION, 128, buf, NULL);
fprintf(stdout, "%s\n", buf);
}
int main(){
// ===================================================================== //
// ==== Opencl
free(devices);
int error = 0;
// Get the number of platforms
cl_uint platformIdCount = 0;
@ -40,28 +41,68 @@ int main(){
std::vector<cl_platform_id> platformIds (platformIdCount);
clGetPlatformIDs(platformIdCount, platformIds.data(), nullptr);
// get the number of devices, fetch them, choose the first one
cl_uint deviceIdCount = 0;
clGetDeviceIDs (platformIds [0], CL_DEVICE_TYPE_ALL, 0, nullptr,
&deviceIdCount);
std::vector<cl_device_id> deviceIds (deviceIdCount);
clGetDeviceIDs (platformIds [0], CL_DEVICE_TYPE_ALL, deviceIdCount,
deviceIds.data (), nullptr);
int error = 0;
// Try to get a GPU first
error = clGetDeviceIDs (platformIds [0], CL_DEVICE_TYPE_GPU, 0, nullptr,
&deviceIdCount);
if (deviceIdCount == 0) {
std::cout << "couldn't aquire a GPU, falling back to CPU" << std::endl;
error = clGetDeviceIDs(platformIds[0], CL_DEVICE_TYPE_CPU, 0, nullptr, &deviceIdCount);
error = clGetDeviceIDs(platformIds[0], CL_DEVICE_TYPE_CPU, deviceIdCount, deviceIds.data(), NULL);
} else {
std::cout << "aquired GPU cl target" << std::endl;
clGetDeviceIDs (platformIds[0], CL_DEVICE_TYPE_GPU, deviceIdCount, deviceIds.data (), nullptr);
}
// Hurray for standards!
// Setup the context properties to grab the current GL context
#ifdef linux
cl_context_properties context_properties[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties) glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties) glXGetCurrentDisplay(),
CL_CONTEXT_PLATFORM, (cl_context_properties) platform,
0
};
#elif defined _WIN32
cl_context_properties context_properties[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties) wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties) wglGetCurrentDC(),
CL_CONTEXT_PLATFORM, (cl_context_properties) platform,
0
};
// Set the context's properties
const cl_context_properties contextProperties [] = {
CL_CONTEXT_PLATFORM,
reinterpret_cast<cl_context_properties> (platformIds [0]),
0, 0
#elif defined TARGET_OS_MAC
CGLContextObj glContext = CGLGetCurrentContext();
CGLShareGroupObj shareGroup = CGLGetShareGroup(glContext);
cl_context_properties context_properties[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,
(cl_context_properties)shareGroup,
0
};
cl_context context = clCreateContext (
contextProperties, deviceIdCount,
deviceIds.data (), nullptr,
nullptr, &error);
#endif
// Create our shared context
auto context = clCreateContext(
context_properties,
deviceIdCount,
deviceIds.data(),
nullptr, nullptr,
&error
);
// And the cl command queue
auto commandQueue = clCreateCommandQueue(context, deviceIds[0], 0, NULL);
// At this point the shared GL/CL context is up and running
};
@ -108,7 +149,7 @@ void test_ray_reflection(){
return;
}
int main2() {
int main0() {
// Initialize the render window
Curses curse(sf::Vector2i(5, 5), sf::Vector2i(WINDOW_X, WINDOW_Y));
@ -136,7 +177,7 @@ int main2() {
window_sprite.setPosition(0, 0);
// State values
sf::Vector3i map_dim(50, 50, 50);
sf::Vector3i map_dim(100, 100, 100);
sf::Vector2i view_res(WINDOW_X, WINDOW_Y);
sf::Vector3f cam_dir(1.0f, 0.0f, 1.57f);
sf::Vector3f cam_pos(50, 50, 50);
@ -150,6 +191,7 @@ int main2() {
// Mouse capture
sf::Vector2i deltas;
sf::Vector2i fixed(window.getSize());
bool mouse_enabled = true;
while (window.isOpen()) {
@ -160,55 +202,12 @@ int main2() {
// If the user tries to exit the application via the GUI
if (event.type == sf::Event::Closed)
window.close();
if (event.type == sf::Event::KeyPressed) {
// CAMERA DIRECTION
if (event.key.code == sf::Keyboard::Left) {
cam_dir.z -= 0.1f;
std::cout << "X:" << cam_dir.x << " Y:" << cam_dir.y << " Z:" << cam_dir.z << std::endl;
}
if (event.key.code == sf::Keyboard::Right) {
cam_dir.z += 0.1f;
std::cout << "X:" << cam_dir.x << " Y:" << cam_dir.y << " Z:" << cam_dir.z << std::endl;
}
if (event.key.code == sf::Keyboard::Down) {
cam_dir.y += 0.1f;
std::cout << "X:" << cam_dir.x << " Y:" << cam_dir.y << " Z:" << cam_dir.z << std::endl;
}
if (event.key.code == sf::Keyboard::Up) {
cam_dir.y -= 0.1f;
std::cout << "X:" << cam_dir.x << " Y:" << cam_dir.y << " Z:" << cam_dir.z << std::endl;
}
//// CAMERA POSITION
//if (event.key.code == sf::Keyboard::Q) {
// cam_pos.z -= 1;
// std::cout << "X:" << cam_pos.x << " Y:" << cam_pos.y << " Z:" << cam_pos.z << std::endl;
//}
//if (event.key.code == sf::Keyboard::E) {
// cam_pos.z += 1;
// std::cout << "X:" << cam_pos.x << " Y:" << cam_pos.y << " Z:" << cam_pos.z << std::endl;
//}
//if (event.key.code == sf::Keyboard::W) {
// cam_pos.y += 1;
// std::cout << "X:" << cam_pos.x << " Y:" << cam_pos.y << " Z:" << cam_pos.z << std::endl;
//}
//if (event.key.code == sf::Keyboard::S) {
// cam_pos.y -= 1;
// std::cout << "X:" << cam_pos.x << " Y:" << cam_pos.y << " Z:" << cam_pos.z << std::endl;
//}
//if (event.key.code == sf::Keyboard::A) {
// cam_pos.x += 1;
// std::cout << "X:" << cam_pos.x << " Y:" << cam_pos.y << " Z:" << cam_pos.z << std::endl;
//}
//if (event.key.code == sf::Keyboard::D) {
// cam_pos.x -= 1;
// std::cout << "X:" << cam_pos.x << " Y:" << cam_pos.y << " Z:" << cam_pos.z << std::endl;
//}
}
}
cam_vec.x = 0;
cam_vec.y = 0;
cam_vec.z = 0;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Q)) {
cam_vec.z = 1;
}
@ -227,68 +226,69 @@ int main2() {
if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) {
cam_vec.x = -1;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
cam_dir.z = -0.1f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
cam_vec.z = +0.1f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
cam_vec.y = +0.1f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
cam_vec.y = -0.1f;
}
deltas = fixed - sf::Mouse::getPosition();
if (deltas != sf::Vector2i(0, 0))
sf::Mouse::setPosition(fixed);
cam_dir.y -= deltas.y / 300.0f;
cam_dir.z -= deltas.x / 300.0f;
cam_pos.x += cam_vec.x / 10.0;
cam_pos.y += cam_vec.y / 10.0;
cam_pos.z += cam_vec.z / 10.0;
if (deltas != sf::Vector2i(0, 0) && mouse_enabled == true) {
if (cam_vec.x > 0.0f)
cam_vec.x -= 0.1;
else if (cam_vec.x < 0.0f)
cam_vec.x += 0.1;
if (cam_vec.y > 0.0f)
cam_vec.y -= 0.1;
else if (cam_vec.y < 0.0f)
cam_vec.y += 0.1;
// Mouse movement
sf::Mouse::setPosition(fixed);
cam_dir.y -= deltas.y / 300.0f;
cam_dir.z -= deltas.x / 300.0f;
}
if (cam_vec.z > 0.0f)
cam_vec.z -= 0.1;
else if (cam_vec.z < 0.0f)
cam_vec.z += 0.1;
cam_pos.x += cam_vec.x / 1.0;
cam_pos.y += cam_vec.y / 1.0;
cam_pos.z += cam_vec.z / 1.0;
// if (cam_vec.x > 0.0f)
// cam_vec.x -= 0.1;
// else if (cam_vec.x < 0.0f)
// cam_vec.x += 0.1;
//
// if (cam_vec.y > 0.0f)
// cam_vec.y -= 0.1;
// else if (cam_vec.y < 0.0f)
// cam_vec.y += 0.1;
//
// if (cam_vec.z > 0.0f)
// cam_vec.z -= 0.1;
// else if (cam_vec.z < 0.0f)
// cam_vec.z += 0.1;
std::cout << cam_vec.x << " : " << cam_vec.y << " : " << cam_vec.z << std::endl;
// Get the elapsed time from the start of the application
elapsed_time = elap_time();
// Find the time that passed between now and the last frame
// Time keeping
elapsed_time = elap_time();
delta_time = elapsed_time - current_time;
// Set the time for the next frame to use
current_time = elapsed_time;
// If the time between the last frame and now was too large (lag)
// cull the time to a more acceptable value. So instead of jumping large
// amounts when lagging, the app only jumps in set increments
if (delta_time > 0.2f)
delta_time = 0.2f;
// Add the frame time to the accumulator, a running total of time we
// need to account for in the application
accumulator_time += delta_time;
// While we have time to step
while ((accumulator_time - step_size) >= step_size) {
accumulator_time -= step_size;
// Take away a step from the accumulator
accumulator_time -= step_size;
curse.Update(delta_time);
// And update the application for the amount of time alotted for one step
// Update(step_size);
}
// Update cycle
curse.Update(delta_time);
// map->moveLight(sf::Vector2f(0.3, 0));
}
// Fps cycle
// map->moveLight(sf::Vector2f(0.3, 0));
window.clear(sf::Color::Black);

Write Preview
Loading…
Cancel
Save