/*!
\internal
*/
QCLImage3D QCLContextGL::createTexture3D
(QMacCompatGLenum type, QMacCompatGLuint texture,
QMacCompatGLint mipmapLevel, QCLMemoryObject::Access access)
{
return createTexture3D(GLenum(type), GLuint(texture),
GLint(mipmapLevel), access);
}
int main(int argc, char* argv[])
{
Window win(g_window_res);
// initialize the transfer function
Transfer_function transfer_fun;
// first clear possible old values
transfer_fun.reset();
// the add_stop method takes:
// - unsigned char or float - data value (0.0 .. 1.0) or (0..255)
// - vec4f - color and alpha value (0.0 .. 1.0) per channel
//transfer fuer aufgabe 31 und 32
transfer_fun.add(0.0f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(1.0f, glm::vec4(1.0, 1.0, 1.0, 1.0));
// transfer fuer aufgabe 33
/*transfer_fun.add(0.0f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(0.2f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(0.25f, glm::vec4(0.5, 0.5, 0.5, 0.1));
transfer_fun.add(0.3f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(0.35f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(0.55f, glm::vec4(1.0, 1.0, 1.0, 0.2));
transfer_fun.add(0.75f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(1.0f, glm::vec4(0.0, 0.0, 0.0, 0.0));*/
// transfer fuer aufgabe 4
/*transfer_fun.add(0.0f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(0.2f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(0.25f, glm::vec4(0.5, 0.5, 0.5, 1.0));
transfer_fun.add(0.3f, glm::vec4(0.0, 0.0, 0.0, 0.0));
transfer_fun.add(1.0f, glm::vec4(0.0, 0.0, 0.0, 0.0));*/
///NOTHING TODO UNTIL HERE-------------------------------------------------------------------------------
//init volume loader
Volume_loader_raw loader;
//read volume dimensions
glm::ivec3 vol_dimensions = loader.get_dimensions(g_file_string);
unsigned max_dim = std::max(std::max(vol_dimensions.x,
vol_dimensions.y),
vol_dimensions.z);
// calculating max volume bounds of volume (0.0 .. 1.0)
glm::vec3 max_volume_bounds = glm::vec3(vol_dimensions) / glm::vec3((float)max_dim);
// loading volume file data
auto volume_data = loader.load_volume(g_file_string);
auto channel_size = loader.get_bit_per_channel(g_file_string) / 8;
auto channel_count = loader.get_channel_count(g_file_string);
// init and upload volume texture
glActiveTexture(GL_TEXTURE0);
createTexture3D(vol_dimensions.x, vol_dimensions.y, vol_dimensions.z, channel_size, channel_count, (char*)&volume_data[0]);
// init and upload transfer function texture
glActiveTexture(GL_TEXTURE1);
createTexture2D(255u, 1u, (char*)&transfer_fun.get_RGBA_transfer_function_buffer()[0]);
// setting up proxy geometry
Cube cube(glm::vec3(0.0, 0.0, 0.0), max_volume_bounds);
// loading actual raytracing shader code (volume.vert, volume.frag)
// edit volume.frag to define the result of our volume raycaster
GLuint program(0);
try {
program = loadShaders(g_file_vertex_shader, g_file_fragment_shader);
} catch (std::logic_error& e) {
std::cerr << e.what() << std::endl;
}
// init object manipulator (turntable)
Manipulator manipulator;
// manage keys here
// add new input if neccessary (ie changing sampling distance, isovalues, ...)
while (!win.shouldClose()) {
// exit window with escape
if (win.isKeyPressed(GLFW_KEY_ESCAPE)) {
win.stop();
}
if (win.isKeyPressed(GLFW_KEY_LEFT)) {
g_light_pos.x -= 0.5f;
}
if (win.isKeyPressed(GLFW_KEY_RIGHT)) {
g_light_pos.x += 0.5f;
}
if (win.isKeyPressed(GLFW_KEY_UP)) {
g_light_pos.z -= 0.5f;
}
if (win.isKeyPressed(GLFW_KEY_DOWN)) {
g_light_pos.z += 0.5f;
}
if (win.isKeyPressed(GLFW_KEY_MINUS)) {
g_iso_value -= 0.002f;
g_iso_value = std::max(g_iso_value, 0.0f);
}
if (win.isKeyPressed(GLFW_KEY_EQUAL) || win.isKeyPressed(GLFW_KEY_KP_ADD)) {
g_iso_value += 0.002f;
g_iso_value = std::min(g_iso_value, 1.0f);
}
if (win.isKeyPressed(GLFW_KEY_D)) {
g_sampling_distance -= 0.0001f;
g_sampling_distance = std::max(g_sampling_distance, 0.0001f);
}
if (win.isKeyPressed(GLFW_KEY_S)) {
g_sampling_distance += 0.0001f;
g_sampling_distance = std::min(g_sampling_distance, 0.2f);
}
//pre-classification
if (win.isKeyPressed(GLFW_KEY_O)){
g_switch_classification = 0;
}
//post-classification
if (win.isKeyPressed(GLFW_KEY_L)) {
g_switch_classification = 1;
}
// to add key inputs:
// check win.isKeyPressed(KEY_NAME)
// - KEY_NAME - key name (GLFW_KEY_A ... GLFW_KEY_Z)
//if (win.isKeyPressed(GLFW_KEY_X)){
//
// ... do something
//
//}
/// reload shader if key R ist pressed
if (win.isKeyPressed(GLFW_KEY_R)) {
if (g_reload_shader_pressed != true) {
GLuint newProgram(0);
try {
std::cout << "Reload shaders" << std::endl;
newProgram = loadShaders(g_file_vertex_shader, g_file_fragment_shader);
}
catch (std::logic_error& e) {
std::cerr << e.what() << std::endl;
newProgram = 0;
}
if (0 != newProgram) {
glDeleteProgram(program);
program = newProgram;
}
g_reload_shader_pressed = true;
}
} else {
g_reload_shader_pressed = false;
}
/// show transfer function if T is pressed
if (win.isKeyPressed(GLFW_KEY_T)){
if (!g_show_transfer_function_pressed){
g_show_transfer_function = !g_show_transfer_function;
}
g_show_transfer_function_pressed = true;
} else {
g_show_transfer_function_pressed = false;
}
auto size = win.windowSize();
glViewport(0, 0, size.x, size.y);
glClearColor(g_background_color.x, g_background_color.y, g_background_color.z, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
float fovy = 45.0f;
float aspect = (float)size.x / (float)size.y;
float zNear = 0.025f, zFar = 10.0f;
glm::mat4 projection = glm::perspective(fovy, aspect, zNear, zFar);
glm::vec3 translate = max_volume_bounds * glm::vec3(-0.5f);
glm::vec3 eye = glm::vec3(0.0f, 0.0f, 1.5f);
glm::vec3 target = glm::vec3(0.0f);
glm::vec3 up(0.0f, 1.0f, 0.0f);
auto view = glm::lookAt(eye, target, up);
auto model_view = view
* manipulator.matrix(win)
// rotate head upright
* glm::rotate(0.5f*float(M_PI), glm::vec3(0.0f,1.0f,0.0f))
* glm::rotate(0.5f*float(M_PI), glm::vec3(1.0f,0.0f,0.0f))
* glm::translate(translate)
;
glm::vec4 camera_translate = glm::column(glm::inverse(model_view), 3);
glm::vec3 camera_location = glm::vec3(camera_translate.x, camera_translate.y, camera_translate.z);
camera_location /= glm::vec3(camera_translate.w);
glm::vec4 light_location = glm::vec4(g_light_pos, 1.0f) * model_view;
glUseProgram(program);
glUniform1i(glGetUniformLocation(program, "volume_texture"), 0);
glUniform1i(glGetUniformLocation(program, "transfer_texture"), 1);
glUniform3fv(glGetUniformLocation(program, "camera_location"), 1,
glm::value_ptr(camera_location));
glUniform1f(glGetUniformLocation(program, "sampling_distance"), g_sampling_distance);
glUniform1i(glGetUniformLocation(program, "switch_classification"), g_switch_classification);
glUniform1f(glGetUniformLocation(program, "iso_value"), g_iso_value);
glUniform3fv(glGetUniformLocation(program, "max_bounds"), 1,
glm::value_ptr(max_volume_bounds));
glUniform3iv(glGetUniformLocation(program, "volume_dimensions"), 1,
glm::value_ptr(vol_dimensions));
glUniform3fv(glGetUniformLocation(program, "light_position"), 1,
//glm::value_ptr(glm::vec3(light_location.x, light_location.y, light_location.z)));
glm::value_ptr(g_light_pos));
glUniform3fv(glGetUniformLocation(program, "light_color"), 1,
glm::value_ptr(g_light_color));
glUniform3fv(glGetUniformLocation(program, "light_color"), 1,
glm::value_ptr(g_light_color));
glUniformMatrix4fv(glGetUniformLocation(program, "Projection"), 1, GL_FALSE,
glm::value_ptr(projection));
glUniformMatrix4fv(glGetUniformLocation(program, "Modelview"), 1, GL_FALSE,
glm::value_ptr(model_view));
cube.draw();
glUseProgram(0);
if (g_show_transfer_function)
transfer_fun.update_and_draw();
win.update();
}
return 0;
}
/*!
\internal
*/
QCLImage3D QCLContextGL::createTexture3D
(QMacCompatGLuint texture, QCLMemoryObject::Access access)
{
return createTexture3D(GLenum(GL_TEXTURE_3D), GLuint(texture),
GLint(0), access);
}
/*!
\overload
Creates a 3D OpenCL image object from the specified OpenGL
\a texture object, and \a access mode. If texture type is
assumed to be \c{GL_TEXTURE_3D} and the mipmap level is
assumed to be 0.
This function will only work if supportsObjectSharing() is true.
*/
QCLImage3D QCLContextGL::createTexture3D(GLuint texture, QCLMemoryObject::Access access)
{
return createTexture3D(GL_TEXTURE_3D, texture, 0, access);
}
