/** * Initializes the class. * If GLSLProgram is initialized for the first time, initialize GLEW * \param void * \return bool * \author <a href="mailto:[email protected]">Jens Schneider</a> * \date Aug.2004 * \see m_bGlewInitialized */ bool GLSLProgram::Initialize(void) { if (!m_bGlewInitialized) { GLenum err = glewInit(); if(err != GLEW_OK) { T_ERROR("GLEW initialization failed: %s", glewGetErrorString(err)); } else { m_bGlewInitialized=true; } } #ifdef GLSL_DEBUG // just in case someone wants to handle GLEW himself (by setting the static var to true) but failed to do so properly else { if (glMultiTexCoord2f==NULL) T_ERROR("GLEW must be initialized. Set GLSLProgram::m_bGlewInitialized = false in GLSLProgram.cpp if you want this class to do it for you"); } #endif if (!m_bGLChecked) { MESSAGE("Initializing OpenGL on a: %s", (const char*)glGetString(GL_VENDOR)); if (atof((const char*)glGetString(GL_VERSION)) >= 2.0) { MESSAGE("OpenGL 2.0 supported"); m_bGLUseARB = false; } else { // check for ARB extensions if (glewGetExtension("GL_ARB_shader_objects")) MESSAGE("ARB_shader_objects supported."); else { T_ERROR("Neither OpenGL 2.0 nor ARB_shader_objects not supported!"); return false; } if (glewGetExtension("GL_ARB_shading_language_100")) MESSAGE("ARB_shading_language_100 supported."); else { MESSAGE("Neither OpenGL 2.0 nor ARB_shading_language_100 not supported!"); return false; } glUniform1i = glUniform1iARB; glUniform2i = glUniform2iARB; glUniform1iv = glUniform1ivARB; glUniform2iv = glUniform2ivARB; glUniform3i = glUniform3iARB; glUniform4i = glUniform4iARB; glUniform3iv = glUniform3ivARB; glUniform4iv = glUniform4ivARB; glUniform1f = glUniform1fARB; glUniform2f = glUniform2fARB; glUniform1fv = glUniform1fvARB; glUniform2fv = glUniform2fvARB; glUniform3f = glUniform3fARB; glUniform4f = glUniform4fARB; glUniform3fv = glUniform3fvARB; glUniform4fv = glUniform4fvARB; glUniformMatrix2fv = glUniformMatrix2fvARB; glUniformMatrix3fv = glUniformMatrix3fvARB; glUniformMatrix4fv = glUniformMatrix4fvARB; m_bGLUseARB = true; } } return true; }
bool hasGLSLSupport(void)
{ bGeometryShader = hasGeometryShaderSupport();
bGPUShader4 = hasShaderModel4();
if (useGLSL) return true; // already initialized and GLSL is available
useGLSL = true;
if (!extensions_init) InitOpenGLExtensions(); // extensions were not yet initialized!!
/*
if (GLEW_VERSION_2_0)
{
cerr << "OpenGL 2.0 (or higher) is available!" << endl;
}
else if (GLEW_VERSION_1_5)
{
cerr << "OpenGL 1.5 core functions are available" << endl;
}
else if (GLEW_VERSION_1_4)
{
cerr << "OpenGL 1.4 core functions are available" << endl;
}
else if (GLEW_VERSION_1_3)
{
cerr << "OpenGL 1.3 core functions are available" << endl;
}
else if (GLEW_VERSION_1_2)
{
cerr << "OpenGL 1.2 core functions are available" << endl;
}
*/
if (GL_TRUE != glewGetExtension("GL_ARB_fragment_shader"))
{ cerr << "[WARNING] GL_ARB_fragment_shader extension is not available!\n";
useGLSL = false;
}
if (GL_TRUE != glewGetExtension("GL_ARB_vertex_shader"))
{ cerr << "[WARNING] GL_ARB_vertex_shader extension is not available!\n";
useGLSL = false;
}
if (GL_TRUE != glewGetExtension("GL_ARB_shader_objects"))
{ cerr << "[WARNING] GL_ARB_shader_objects extension is not available!\n";
useGLSL = false;
}
if (!useGLSL)
{ cerr << "[FAILED] OpenGL Shading Language is not available...\n\n";
}
return useGLSL;
}
void InitGLEW()
{
INFO("Initializing GLEW");
GLenum glewError = glewInit();
// Initialize all the OpenGL extensions
glewGetExtension("glMultiTexCoord2fvARB");
if(glewGetExtension("GL_EXT_frameBuffer_object"))
INFO("GL_EXT_frameBuffer_object support");
if(glewGetExtension("GL_EXT_renderBuffer_object"))
INFO("GL_EXT_renderBuffer_object support");
if(glewGetExtension("GL_ARB_vertex_buffer_object"))
INFO("GL_ARB_vertex_buffer_object support");
if(GL_ARB_multitexture)
INFO("GL_ARB_multitexture support");
if (glewGetExtension("GL_ARB_fragment_shader") != GL_TRUE ||
glewGetExtension("GL_ARB_vertex_shader") != GL_TRUE ||
glewGetExtension("GL_ARB_shader_objects") != GL_TRUE ||
glewGetExtension("GL_ARB_shading_language_100") != GL_TRUE)
{
INFO("Driver does not support OpenGL Shading Language");
INFO("EXITING ... ");
EXIT(0);
}
INFO("GLEW initialization DONE");
}
bool Cube::DoInitialize( Renderer* renderer ) throw(std::exception)
{
bool hasVBO = glewGetExtension("GL_ARB_vertex_buffer_object");
ASSERT( hasVBO, "VBOs not supported!" );
if ( m_Assets.size() ) {
for (auto& asset : m_Assets ) {
TexturePtr texture( new Texture );
texture->Load( *asset.get() );
m_Textures.push_back( texture );
}
GetRenderState()->ClearFlag( BLEND_COLOR_F );
}
glGenBuffers(1, &m_VboID);
glBindBuffer(GL_ARRAY_BUFFER, m_VboID);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices)+sizeof(normals)+sizeof(colors)+sizeof(texCoords), 0, GL_STATIC_DRAW_ARB);
std::size_t offset(0);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vertices), vertices); // copy vertices starting from 0 offest
offset += sizeof(vertices);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(normals), normals); // copy normals after vertices
offset += sizeof(normals);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(colors), colors); // copy colors after normals
if ( m_Textures.size() ) {
offset += sizeof(texCoords);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(texCoords), texCoords); // copy colors after normals
}
return true;
}
inline bool check_opengl_extension(const char * name)
{
if (glewGetExtension(name) == GL_TRUE)
return true;
std::cout << "OpenGL extension '" << name << "' not supported." << std::endl;
return false;
}
bool HasShaderModel4(void)
{
if (GL_TRUE != glewGetExtension("GL_EXT_gpu_shader4"))
return false;
return true;
}
bool HasGeometryShaderSupport(void)
{
if (GL_TRUE != glewGetExtension("GL_EXT_geometry_shader4"))
return false;
return true;
}
void keyboard(unsigned char key, int x, int y) {
switch (key) {
case 27:
glutLeaveMainLoop();
break;
case 'r':
translate_x = 0;
translate_y = 0;
scale_size = 1.0;
break;
case 's':
pause = !pause;
start_clock = std::clock();
fpsLimit = 5;
fpsCount = 0;
break;
case 'd':
pause = true;
single = true;
start_clock = std::clock();
fpsLimit = 1;
fpsCount = 0;
break;
#if defined(_WIN32)||defined(_WIN64)
case 'v':
if(glewGetExtension("WGL_EXT_swap_control")) {
vsync = 1 - vsync;
wglSwapIntervalEXT(vsync);
}
break;
#endif
}
}
///////////////////////////////////////////////////////////////////////////////////
//
// Routine to check the capability of your graphics card
//
void check_graphics()
{
const GLubyte *renderer = glGetString(GL_RENDERER);
const GLubyte *vendor = glGetString(GL_VENDOR);
const GLubyte *version = glGetString(GL_VERSION);
const GLubyte *glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION);
GLint major, minor;
glGetIntegerv(GL_MAJOR_VERSION, &major);
glGetIntegerv(GL_MINOR_VERSION, &minor);
printf(" ----------------- Checking graphics capability ...\n");
printf(" GL Vendor: %s \n", vendor);
printf(" GL Renderer: %s \n", renderer);
printf(" GL version: %s\n", version);
printf(" GL version: %d.%d\n", major, minor);
printf(" GLSL version: %s\n", glslVersion);
// now check the availability of shaders
if (! GLEW_ARB_vertex_program) printf(" ARB vertex program is not supported!!\n");
else printf(" ARB vertex program is supported!!\n");
if (! GLEW_ARB_vertex_shader) printf(" ARB vertex shader is not supported!!\n");
else printf(" ARB vertex shader is supported!!\n");
if (! GLEW_ARB_fragment_program) printf(" ARB fragment program is not supported!!\n");
else printf(" ARB fragment program is supported!!\n");
if (! GLEW_ARB_fragment_shader) printf(" ARB fragment shader is not supported!!\n");
else printf(" ARB fragment shader is supported!!\n");
// another way to query the shaders support
if (glewGetExtension("GL_ARB_fragment_shader") != GL_TRUE ||
glewGetExtension("GL_ARB_vertex_shader") != GL_TRUE ||
glewGetExtension("GL_ARB_shader_objects") != GL_TRUE ||
glewGetExtension("GL_ARB_shading_language_100") != GL_TRUE)
{
fprintf(stderr, "Driver does not support OpenGL Shading Language\n");
exit(1);
}
else fprintf(stderr, "GLSL supported and ready to go\n");
printf(" ----------------- checking graphics capability done. \n");
}
bool ofGLCheckExtension(string searchName){
#if defined( TARGET_OPENGLES ) || defined( TARGET_LINUX )
vector<string> extensionsList = ofGLSupportedExtensions();
set<string> extensionsSet;
extensionsSet.insert(extensionsList.begin(),extensionsList.end());
return extensionsSet.find(searchName)!=extensionsSet.end();
#else
return glewGetExtension(searchName.c_str());
#endif
}
/*
Checks whether graphics driver supports all required OpenGL features
*/
void glutWidget::checkExtensions()
{
//query some extensions to make sure they are present
if(glewGetExtension("GL_ARB_shading_language_100") != GL_TRUE)
{
std::cout << "ERROR: Shading language extension not present." << std::endl;
}
if(glewGetExtension("GL_ARB_vertex_program") != GL_TRUE)
{
std::cout << "ERROR: Vertex program extension not present." << std::endl;
}
if(glewGetExtension("GL_ARB_vertex_shader") != GL_TRUE)
{
std::cout << "ERROR: Vertex shader extension not present." << std::endl;
}
if(glewGetExtension("GL_ARB_fragment_program") != GL_TRUE)
{
std::cout << "ERROR: Fragment program extension not present." << std::endl;
}
if(glewGetExtension("GL_ARB_fragment_shader") != GL_TRUE)
{
std::cout << "ERROR: Fragment shader extension not present." << std::endl;
}
if(glewGetExtension("GL_ARB_vertex_buffer_object") != GL_TRUE)
{
std::cout << "ERROR: VBO extension not present." << std::endl;
}
}
// InitGCC
void RendererGL::InitGCC()
{
// EGCC_VertexShader1_1
m_bGCC[ EGCC_VertexShader1_1 ] = (bool)glewGetExtension("GL_ARB_vertex_shader");
// EGCC_OpenGL2
char *temp;
temp = (char*) glGetString(GL_VERSION);
if (temp)
{
if ( temp[0] == '2' )
m_bGCC[ gfx::EGCC_OpenGL2 ] = true;
else
m_bGCC[ gfx::EGCC_OpenGL2 ] = false;
if ( temp[0] == '3' )
m_bGCC[ gfx::EGCC_OpenGL3 ] = true;
else
m_bGCC[ gfx::EGCC_OpenGL3 ] = false;
if ( temp[0] == '4' )
m_bGCC[ gfx::EGCC_OpenGL4 ] = true;
else
m_bGCC[ gfx::EGCC_OpenGL4 ] = false;
}
// EGCC_FragmentShader1_1
m_bGCC[ gfx::EGCC_FragmentShader1_1 ] = (bool)glewGetExtension("GL_ARB_fragment_shader");
// EGCC_ShaderObject
m_bGCC[ gfx::EGCC_ShaderObject ] = (bool)glewGetExtension("GL_ARB_shader_objects");
// EGCC_GeometryShader
m_bGCC[ gfx::EGCC_GeometryShader4 ] = (bool)glewGetExtension("GL_EXT_geometry_shader4");
// EGCC_ShaderModel 4
m_bGCC[ gfx::EGCC_ShaderModel4 ] = (bool)glewGetExtension("GL_EXT_gpu_shader4");
// EGCC_ShaderModel 3
m_bGCC[ gfx::EGCC_ShaderModel3 ] = (bool)glewGetExtension("GL_EXT_gpu_shader3");
// EGCC_ShaderModel 2
m_bGCC[ gfx::EGCC_ShaderModel2 ] = (bool)glewGetExtension("GL_EXT_gpu_shader2");
// support for compresed textures
m_bGCC[gfx::EGCC_DXT1] = m_bGCC[gfx::EGCC_DXT3]
= m_bGCC[gfx::EGCC_DXT5] = (bool)glewGetExtension("");
}
void start() {
#if defined(_WIN32)||(_WIN64)
if (glewGetExtension("WGL_EXT_swap_control")) {
wglSwapIntervalEXT(vsync);
}
#endif
Segregation** seg_ptr = get_ptr();
*seg_ptr = this;
glutDisplayFunc(_wrapDisplay);
glutKeyboardFunc(_wrapKeyboard);
glutIdleFunc(_wrapIdle);
glutMouseFunc(_wrapMouse);
glutMotionFunc(_wrapMotion);
start_clock = std::clock();
glutMainLoop();
}
void Enable_shader(void){
GLenum err = glewInit();
if (GLEW_OK != err)
{
fprintf(stderr, "Error %s\n", glewGetErrorString(err));
exit(1);
}
fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
if (GLEW_ARB_vertex_program)
fprintf(stdout, "Status: ARB vertex programs available.\n");
if (glewGetExtension("GL_ARB_fragment_program"))
fprintf(stdout, "Status: ARB fragment programs available.\n");
if (glewIsSupported("GL_VERSION_1_4 GL_ARB_point_sprite"))
fprintf(stdout, "Status: ARB point sprites available.\n");
}
bool FrameBuffer::Allocate( int width, int height, int type /* = GL_RGBA */ )
{
// TODO: Check for FBO extensions!
bool b = glewGetExtension("GL_ARB_framebuffer_object");
GL_ASSERT( b, "Missing extension 'ARB_framebuffer_object'!");
glGenFramebuffers(1, (GLuint*)&m_FrameBufferID);
GL_ASSERT( m_FrameBufferID > 0 , "Error generating frame buffer!" );
glBindFramebuffer(GL_FRAMEBUFFER, m_FrameBufferID);
// add a draw buffer - default = true
if ( m_Flags & F_ENABLE_COLOR_BUFFER_F ) {
// create a depth buffer
if ( m_Flags & F_ENABLE_DEPTH_BUFFER_F ) {
glGenRenderbuffers(1, (GLuint*)&m_DepthBufferID);
GL_ASSERT( m_DepthBufferID > 0, "Error generating depth buffer!" );
glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBufferID);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
// we will need to get access to this depth buffer - if we don't attach a texture
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_DepthBufferID);
}
// create a texture to render into
b = m_Texture->Allocate( width, height, type );
ASSERT( b, "Error allocating texture!" );
// Set "renderedTexture" as our colour attachement #0
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_Texture->GetTextureId(), 0);
glDrawBuffer( GL_COLOR_ATTACHMENT0 );
}
else if ( m_Flags & F_ENABLE_DEPTH_BUFFER_F ) {
// depth buffer only
// create a texture to render into
b = m_Texture->Allocate( width, height, 16 ); // 16 bit float depth texture!
ASSERT( b, "Error allocating texture!" );
// Set "renderedTexture" as our depth attachement #0
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_Texture->GetTextureId(), 0);
glDrawBuffer( NULL );
}
b &= ( glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE );
return b;
}
static void keyboard(unsigned char key, int x, int y)
{
if (key == 'q' || key == 'Q')
{
/* 終了 */
exit(0);
}
else if (key == 'p' || key == 'P')
{
/* 一時停止 */
move = 1 - move;
}
else if (key == 'd' || key == 'D')
{
/* 描画モード切替 */
pmode++;
if (pmode > 2)
pmode = 0;
}
else if (key == 'b' || key == 'B')
{
/* 描画モード切替 */
drawVBO = 1 - drawVBO;
}
else if (key == 's' || key == 'S')
{
/* 描画モード切替 */
if (glewGetExtension("WGL_EXT_swap_control"))
{
vsync = 1 - vsync;
if (vsync == 0)
wglSwapIntervalEXT(0);
else
wglSwapIntervalEXT(1);
}
}
}
bool init()
{
GLenum glewerr;
if((glewerr=glewInit()) != GLEW_OK)
{
LOG("glewinit() failed : ",glewGetErrorString(glewerr),"\n");
return false;
}
glGetError();
std::cout << "Initializing on "<<glGetString(GL_VENDOR)<<" "<<glGetString(GL_RENDERER)<<" using OpenGL "<<glGetString(GL_VERSION)<<"\n";
LOG("Initializing on ",glGetString(GL_VENDOR)," ",glGetString(GL_RENDERER)," using OpenGL ",glGetString(GL_VERSION),"\n");
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback( debugOut, NULL );
glClearDepth(1);
openGL.clearDepth();
openGL.getHardwardProperties();
openGL.applyAll();
LOG("\nSupport of bindless_texture: ",glewGetExtension("GL_ARB_bindless_texture")==GL_TRUE);
LOG("Support of sparse_texture: ",glewGetExtension("GL_ARB_sparse_texture")==GL_TRUE);
texBufferPool = new TextureBufferPool;
vertexBufferPool = new VertexBufferPoolType(2 << 20, VertexFormat::VNCT, DrawMode::DYNAMIC);
indexBufferPool = new IndexBufferPoolType(8 << 20, DrawMode::DYNAMIC);
indexBufferPool->buffer().bind();
textureSampler[TextureMode::NoFilter] = Texture::genTextureSampler(false,false,false,false);
textureSampler[TextureMode::Filtered] = Texture::genTextureSampler(true,true,true,false);
textureSampler[TextureMode::FilteredNoRepeat] = Texture::genTextureSampler(false,true,true,false);
textureSampler[TextureMode::OnlyLinearNoRepeat] = Texture::genTextureSampler(false,true,false,false);
textureSampler[TextureMode::DepthMap] = Texture::genTextureSampler(false,true,false,true);
ShaderCompiler vDrawQuad(ShaderCompiler::VERTEX_SHADER);
vDrawQuad.setSource(drawQuad_vertex);
ShaderCompiler pDrawQuad(ShaderCompiler::PIXEL_SHADER);
pDrawQuad.setSource(drawQuad_pixel);
auto optShader = Shader::combine(vDrawQuad.compile({}), pDrawQuad.compile({}));
if(!optShader.hasValue())
{
LOG_EXT("DrawQuad Vertex shader error:\n", vDrawQuad.error());
LOG_EXT("DrawQuad Pixel shader error:\n", pDrawQuad.error());
LOG_EXT("DrawQuad Link erorr:", Shader::lastLinkError());
}
else
drawQuadShader = optShader.value();
ShaderCompiler vDepthPass(ShaderCompiler::VERTEX_SHADER);
vDepthPass.setSource(depthPass_vertex);
LOG("No gs for DepthPass shader, expect a warning");
optShader = Shader::linkVertexShader(vDepthPass.compile({}));
if(!optShader.hasValue())
{
LOG_EXT("DepthPass Vertex shader error:\n", vDepthPass.error());
LOG_EXT("DepthPass Link erorr:", Shader::lastLinkError());
}
else
depthPassShader = optShader.value();
VNCT_Vertex vData[4] = {{vec3(-1,-1,0),vec3(),vec2(0,0),vec3()},
{vec3(-1, 1,0),vec3(),vec2(0,1),vec3()},
{vec3( 1, 1,0),vec3(),vec2(1,1),vec3()},
{vec3( 1,-1,0),vec3(),vec2(1,0),vec3()}};
uint iData[6] = {0,1,2,2,3,0};
VBuffer* tmpVB = vertexBufferPool->alloc(4);
IBuffer* tmpIB = indexBufferPool->alloc(6);
tmpVB->flush(reinterpret_cast<float*>(vData),0,4);
tmpIB->flush(iData,0,6);
quadMeshBuffers = new MeshBuffers(tmpVB,tmpIB);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
if(openGL.hardward(GLState::Hardward::MAJOR_VERSION) > 4 ||
(openGL.hardward(GLState::Hardward::MAJOR_VERSION)==4 && openGL.hardward(GLState::Hardward::MINOR_VERSION)>=3))
{
if(glewGetExtension("GL_ARB_bindless_texture")!=GL_TRUE)
{
LOG("You don't support GL_ARB_bindless_texture, you can't run TIMEngine sorry.");
return false;
}
return true;
}
else
{
LOG("You don't have a sufficient openGL version.");
return false;
}
}
/*
* @return 0 on error; 1 otherwise*/
static int __initOpenGL()
{
// GL_ARB_fragment_shader
// GL_ARB_vertex_shader
#ifdef HAVE_GLEW
glewInit();
if (!GLEW_VERSION_2_0)
{
fprintf(stderr, "OpenGL 2.0 not available\n");
return 1;
}
/* check if we have shader support */
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
{
}
else
{
}
/* check if we can do point sprites */
if (glewGetExtension("GL_ARB_point_sprite"))
{
float maxSize = 0.0f;
/* find out what the max point sprite size is */
glGetFloatv(GL_POINT_SIZE_MAX_ARB, &maxSize);
if (maxSize < 32)
{
}
else
{
// glPointSize(maxSize);
// rSysi->have_point_sprite = TRUE;
}
}
#else
#endif
#if 0
#if 1
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
#else
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#endif
#endif
// glEnable(GL_TEXTURE_2D);
// glDisable(GL_DEPTH_TEST);
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
// glClearDepth(1.0f);
// glShadeModel(GL_SMOOTH);
// glEnable(GL_DEPTH_TEST);
// glDepthFunc(GL_LEQUAL);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
// glDisable(GL_ARB_texture_non_power_of_two);
printf("Using: %s\n", glGetString(GL_VERSION));
return 1;
}
bool GLSLShader::areVBOSupported()
{
if (!glewGetExtension("GL_vertex_buffer_object"))
return false;
return true;
}
bool GLSLShader::areGeometryShadersSupported()
{
if (!glewGetExtension("GL_ARB_geometry_shader4"))
return false;
return true;
}
// ---------------------------------------------------------------------------
// Function: prep_framebuffers
// Design: Belongs to OpenGL component
// Purpose:
// Updated: Sep 10, 2012
// ---------------------------------------------------------------------------
void prep_framebuffers()
{
if (!GL_ARB_framebuffer_object ||
!glewGetExtension("GL_ARB_framebuffer_object")) {
std::cerr << "NO FBO SUPPORT" << std::endl;
exit(EXIT_FAILURE);
} else {
std::cout << "GL_ARB_framebuffer_object SUPPORT" << std::endl;
}
// if (!checkForErrors()) {
// std::cerr << "Stage 0w - Problem generating desktop FBO" << std::endl;
// exit(EXIT_FAILURE);
// }
checkForErrors();
glGenFramebuffers(1, &desktopFBO);
if (!checkForErrors()) {
std::cerr << "Stage 0z - Problem generating desktop FBO" << std::endl;
exit(EXIT_FAILURE);
}
glBindFramebuffer(GL_FRAMEBUFFER, desktopFBO);
if (!checkForErrors() ) {
std::cerr << "Stage 0y - Problem generating desktop FBO" << std::endl;
exit(EXIT_FAILURE);
}
if(desktopTexture == 0) {
glGenTextures(1, &desktopTexture);
}
glBindTexture(GL_TEXTURE_2D, desktopTexture);
if (!checkForErrors()) {
std::cerr << "Stage 0a - Problem generating desktop FBO" << std::endl;
exit(EXIT_FAILURE);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (!checkForErrors()) {
std::cerr << "Stage 0b - Problem generating desktop FBO" << std::endl;
exit(EXIT_FAILURE);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
if (!checkForErrors()) {
std::cerr << "Stage 0c - Problem generating desktop FBO" << std::endl;
exit(EXIT_FAILURE);
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, physicalWidth, physicalHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
if (!checkForErrors()) {
std::cerr << "Stage 0d - Problem generating desktop FBO" << std::endl;
exit(EXIT_FAILURE);
}
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, desktopTexture, 0);
if (!checkForErrors() ||
glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
std::cerr << "Stage 0e - Problem generating desktop FBO" << std::endl;
exit(EXIT_FAILURE);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffers(2, fbos);
glGenRenderbuffers(1, &depthBuffer);
glGenTextures(2, textures);
for (int i = 0; i < 1; ++i) {//2; ++i) {
glBindFramebuffer(GL_FRAMEBUFFER, fbos[i]);
glBindTexture(GL_TEXTURE_2D, textures[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, textureWidth, textureHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, textures[i], 0);
glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer);
if (i == 0) {
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24,
textureWidth, textureHeight);
}
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, depthBuffer);
if (!checkForErrors()) {
std::cerr << "Stage 1 - Problem generating FBO " << i << std::endl;
exit(EXIT_FAILURE);
}
std::cout << "Generating FBO #" << i << std::endl;
std::cout << "FBO: " << textureWidth << "x" << textureHeight << std::endl;
if (!checkForErrors() ||
glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
std::cerr << "Stage 2 - Problem generating FBO " << i << std::endl;
exit(EXIT_FAILURE);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
}
void PolyMeshNode::draw()
{
//Load texture
if (this->texture != NULL)
{
glBindTexture(GL_TEXTURE_2D, this->texture->textureID);
}
//Load material
if (this->material != NULL)
{
glMaterialfv(GL_FRONT, GL_AMBIENT, this->material->ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, this->material->diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, this->material->specular);
glMaterialfv(GL_FRONT, GL_SHININESS, this->material->shininess);
}
//Check vertex buffer object extension
if (glewGetExtension("GL_ARB_vertex_buffer_object"))
{
//Load vertices
glBindBuffer(GL_ARRAY_BUFFER, this->mesh->vbo_vertices);
glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
glEnableClientState(GL_VERTEX_ARRAY);
//Load normals
glBindBuffer(GL_ARRAY_BUFFER, this->mesh->vbo_normals);
glNormalPointer(GL_FLOAT, 0, BUFFER_OFFSET(0));
glEnableClientState(GL_NORMAL_ARRAY);
//Load UVs
glBindBuffer(GL_ARRAY_BUFFER, this->mesh->vbo_uvs);
glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(0));
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->mesh->vbo_index);
glDrawElements(GL_TRIANGLES, 3*this->mesh->numFaces, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
} else {
//Drawing with vertex arrays
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, this->mesh->vertexArray);
glNormalPointer(GL_FLOAT, 0, this->mesh->normalsArray);
glTexCoordPointer(2, GL_FLOAT, 0, this->mesh->uvArray);
glDrawElements(GL_TRIANGLES, 3*this->mesh->numFaces, GL_UNSIGNED_INT, this->mesh->indexArray);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
/*
//Old immediate mode drawing code
glBegin(GL_TRIANGLES);
for (int face = 0; face < this->numFaces; face++)
{
//Draw the vertex at each of the vertex numbders
glTexCoord2f((GLfloat)this->uvs[this->uvIndex[face][0]]->u, (GLfloat)this->uvs[this->uvIndex[face][0]]->v);
glNormal3f((GLfloat)this->normals[this->normalsIndex[face][0]]->x, (GLfloat)this->normals[this->normalsIndex[face][0]]->y, (GLfloat)this->normals[this->normalsIndex[face][0]]->z);
glVertex3f((GLfloat)this->vertices[this->index[face][0]]->x, (GLfloat)this->vertices[this->index[face][0]]->y, (GLfloat)this->vertices[this->index[face][0]]->z);
glTexCoord2f((GLfloat)this->uvs[this->uvIndex[face][1]]->u, (GLfloat)this->uvs[this->uvIndex[face][1]]->v);
glNormal3f((GLfloat)this->normals[this->normalsIndex[face][1]]->x, (GLfloat)this->normals[this->normalsIndex[face][1]]->y, (GLfloat)this->normals[this->normalsIndex[face][1]]->z);
glVertex3f((GLfloat)this->vertices[this->index[face][1]]->x, (GLfloat)this->vertices[this->index[face][1]]->y, (GLfloat)this->vertices[this->index[face][1]]->z);
glTexCoord2f((GLfloat)this->uvs[this->uvIndex[face][2]]->u, (GLfloat)this->uvs[this->uvIndex[face][2]]->v);
glNormal3f((GLfloat)this->normals[this->normalsIndex[face][2]]->x, (GLfloat)this->normals[this->normalsIndex[face][2]]->y, (GLfloat)this->normals[this->normalsIndex[face][2]]->z);
glVertex3f((GLfloat)this->vertices[this->index[face][2]]->x, (GLfloat)this->vertices[this->index[face][2]]->y, (GLfloat)this->vertices[this->index[face][2]]->z);
/* Non-Optimized code for debugging
//Get vertex numbers
int v1, v2, v3;
v1 = this->index[face][0];
v2 = this->index[face][1];
v3 = this->index[face][2];
//Get Normal numbers
int n1, n2, n3;
n1 = this->normalsIndex[face][0];
n2 = this->normalsIndex[face][1];
n3 = this->normalsIndex[face][2];
//Get UVs
int uv1, uv2, uv3;
uv1 = this->uvIndex[face][0];
uv2 = this->uvIndex[face][1];
uv3 = this->uvIndex[face][2];
//Draw the vertex at each of the vertex numbders
glTexCoord2f((GLfloat)this->uvs[uv1]->u, (GLfloat)this->uvs[uv1]->v);
glNormal3f((GLfloat)this->normals[n1]->x, (GLfloat)this->normals[n1]->y, (GLfloat)this->normals[n1]->z);
glVertex3f((GLfloat)this->vertices[v1]->x, (GLfloat)this->vertices[v1]->y, (GLfloat)this->vertices[v1]->z);
glTexCoord2f((GLfloat)this->uvs[uv2]->u, (GLfloat)this->uvs[uv2]->v);
glNormal3f((GLfloat)this->normals[n2]->x, (GLfloat)this->normals[n2]->y, (GLfloat)this->normals[n2]->z);
glVertex3f((GLfloat)this->vertices[v2]->x, (GLfloat)this->vertices[v2]->y, (GLfloat)this->vertices[v2]->z);
glTexCoord2f((GLfloat)this->uvs[uv3]->u, (GLfloat)this->uvs[uv3]->v);
glNormal3f((GLfloat)this->normals[n3]->x, (GLfloat)this->normals[n3]->y, (GLfloat)this->normals[n3]->z);
glVertex3f((GLfloat)this->vertices[v3]->x, (GLfloat)this->vertices[v3]->y, (GLfloat)this->vertices[v3]->z);
*/
/*
}
glEnd();
*/
}
void cgtk::init()
{
cout << "glew init " << endl;
GLenum err = glewInit();
// initialize all the OpenGL extensions
glewGetExtension("glMultiTexCoord2fvARB");
if(glewGetExtension("GL_EXT_framebuffer_object") )cout << "GL_EXT_framebuffer_object support " << endl;
if(glewGetExtension("GL_EXT_renderbuffer_object"))cout << "GL_EXT_renderbuffer_object support " << endl;
if(glewGetExtension("GL_ARB_vertex_buffer_object")) cout << "GL_ARB_vertex_buffer_object support" << endl;
if(GL_ARB_multitexture)cout << "GL_ARB_multitexture support " << endl;
if (glewGetExtension("GL_ARB_fragment_shader") != GL_TRUE ||
glewGetExtension("GL_ARB_vertex_shader") != GL_TRUE ||
glewGetExtension("GL_ARB_shader_objects") != GL_TRUE ||
glewGetExtension("GL_ARB_shading_language_100") != GL_TRUE)
{
cout << "Driver does not support OpenGL Shading Language" << endl;
exit(1);
}
//glEnable(GL_CULL_FACE);
glClearColor(0.0, 0.0, 0.0, 0);
create_volumetexture();
//load_volumetexture_k("data\\output31_int.bin");
//load_volumetexture_step("data\\step_by_step2.bin");
// CG init
//cgSetErrorCallback(cgErrorCallback);
context = cgCreateContext();
if (cgGLIsProfileSupported(CG_PROFILE_VP40))
{
vertexProfile = CG_PROFILE_VP40;
cout << "CG_PROFILE_VP40 supported." << endl;
}
else
{
if (cgGLIsProfileSupported(CG_PROFILE_ARBVP1))
vertexProfile = CG_PROFILE_ARBVP1;
else
{
cout << "Neither arbvp1 or vp40 vertex profiles supported on this system." << endl;
exit(1);
}
}
if (cgGLIsProfileSupported(CG_PROFILE_FP40))
{
fragmentProfile = CG_PROFILE_FP40;
cout << "CG_PROFILE_FP40 supported." << endl;
}
else
{
if (cgGLIsProfileSupported(CG_PROFILE_ARBFP1))
fragmentProfile = CG_PROFILE_ARBFP1;
else
{
cout << "Neither arbfp1 or fp40 fragment profiles supported on this system." << endl;
exit(1);
}
}
// load the vertex and fragment raycasting programs
load_vertex_program(vertex_main,"raycasting_shader.cg","vertex_main");
cgErrorCallback();
load_fragment_program(fragment_main,"raycasting_shader.cg","fragment_main");
cgErrorCallback();
// Create the to FBO's one for the backside of the volumecube and one for the finalimage rendering
glGenFramebuffersEXT(1, &framebuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,framebuffer);
glGenTextures(1, &backface_buffer);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, backface_buffer);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,GL_RGBA16F_ARB, WINDOW_SIZE_W, WINDOW_SIZE_H, 0, GL_RGBA, GL_FLOAT, NULL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, backface_buffer, 0);
glGenTextures(1, &final_image);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, final_image);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,GL_RGBA16F_ARB, WINDOW_SIZE_W, WINDOW_SIZE_H, 0, GL_RGBA, GL_FLOAT, NULL);
glGenRenderbuffersEXT(1, &renderbuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, WINDOW_SIZE_W, WINDOW_SIZE_H);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, renderbuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
