////////////////////////////////////////////////////////////////////////////////
//! Initialize GL
////////////////////////////////////////////////////////////////////////////////
CUTBoolean initGL(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(window_width, window_height);
glutCreateWindow("Cuda GL Interop (VBO)");
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMotionFunc(motion);
// initialize necessary OpenGL extensions
glewInit();
if (! glewIsSupported("GL_VERSION_2_0 ")) {
fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush(stderr);
return CUTFalse;
}
// default initialization
glClearColor(0.0, 0.0, 0.0, 1.0);
glDisable(GL_DEPTH_TEST);
// viewport
glViewport(0, 0, window_width, window_height);
// projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)window_width / (GLfloat) window_height, 0.1, 10.0);
CUT_CHECK_ERROR_GL();
return CUTTrue;
}
/**
* Main entry point.
*/
int main(int argc, char* argv[])
{
glusInitFunc(init);
glusReshapeFunc(reshape);
glusUpdateFunc(update);
glusTerminateFunc(terminate);
glusPrepareContext(3, 3, GLUS_FORWARD_COMPATIBLE_BIT);
if (!glusCreateWindow("GLUS Example Window", 640, 480, GLUS_FALSE))
{
printf("Could not create window!");
return -1;
}
// Init GLEW
glewExperimental = GL_TRUE;
glewInit();
// Only continue, if OpenGL 3.3 is supported.
if (!glewIsSupported("GL_VERSION_3_3"))
{
printf("OpenGL 3.3 not supported.");
glusDestroyWindow();
return -1;
}
glusRun();
return 0;
}
int setupBasicShader(std::string vertfile, std::string fragfile)
{
/* init glew and load compiled shaders */
glewInit();
if(!glewIsSupported("GL_VERSION_2_0 GL_ARB_multitexture GL_EXT_framebuffer_object"))
{
fprintf(stderr, "Required OpenGL extensions missing\n");
return -1;
}
glm::ivec2 shaders = loadShaders(vertfile, fragfile);
GLuint vertexShader = shaders.x;
GLuint fragmentShader = shaders.y;
/* create and link program */
int program = glCreateProgram();
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
GLint pstatus;
glGetProgramiv(program, GL_LINK_STATUS, &pstatus);
if(pstatus != GL_TRUE)
{
char log[2048];
int len;
glGetProgramInfoLog(program, 2048, (GLsizei*)&len, log);
fprintf(stderr, "%s", log);
glDeleteProgram(program);
return -1;
}
return program;
}
// initialize OpenGL
void initGL(int *argc, char **argv)
{
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(width, height);
glutCreateWindow("CUDA Particles");
glewInit();
if (!glewIsSupported("GL_VERSION_2_0 GL_VERSION_1_5 GL_ARB_multitexture GL_ARB_vertex_buffer_object"))
{
fprintf(stderr, "Required OpenGL extensions missing.");
exit(EXIT_FAILURE);
}
#if defined (WIN32)
if (wglewIsSupported("WGL_EXT_swap_control"))
{
// disable vertical sync
wglSwapIntervalEXT(0);
}
#endif
glEnable(GL_DEPTH_TEST);
glClearColor(0.25, 0.25, 0.25, 1.0);
glutReportErrors();
}
int main(int argc, char* argv[])
{
glusInitFunc(init);
glusPrepareContext(4, 3, GLUS_FORWARD_COMPATIBLE_BIT);
if (!glusCreateWindow("C++ OpenGL Compute Shaders sample", 640, 480, GLUS_FALSE))
{
printf("Could not create window!");
return -1;
}
// Init GLEW
glewExperimental = GL_TRUE;
GLenum err=glewInit();
if(err!=GLEW_OK)
{
sprintf("glewInitError", "Error: %s\n", glewGetErrorString(err));
return -1;
}
glGetError(); // flush error state variable, caused by glew errors
if (!glewIsSupported("GL_VERSION_4_3"))
{
printf("OpenGL 4.3 not supported.");
glusDestroyWindow();
return -1;
}
glusRun();
return 0;
}
bool initSDLvideo(int width, int height, int bpp, int fullscreen)
{
int status;
SDL_Surface* screen;
fprintf(stderr, "Initialising OpenGL subsystem...\n");
status = SDL_InitSubSystem(SDL_INIT_VIDEO);
assert(status == 0);
if(status)
{
fprintf(stderr, "Failed to init SDL OpenGL subsystem!\n");
return false;
}
screen = SDL_SetVideoMode(width, height, bpp,
SDL_HWSURFACE |
SDL_ANYFORMAT |
SDL_DOUBLEBUF |
SDL_OPENGL |
(fullscreen ? SDL_FULLSCREEN : 0));
assert(screen);
if(!screen)
{
fprintf(stderr, "Failed to set screen resolution mode: %i x %i", width, height);
return false;
}
SDL_WM_SetCaption(WINDOW_TITLE, NULL);
fprintf(stderr, "Checking graphic hardware capabilities...\n");
GLenum err = glewInit();
if(GLEW_OK != err)
{
fprintf(stderr, "GLEW init error: %s\n", glewGetErrorString(err));
return false;
}
if(glewIsSupported("GL_VERSION_2_0"))
{
fprintf(stderr, "OpenGL 2.0 support found\n");
}
else
{
fprintf(stderr, "Fatal error: No OpenGL 2.0 support\n");
return false;
}
glClearColor(0.48f, 0.58f, 0.72f, 0.0f); // cornflower blue
// glClearColor(0.85f, 0.85f, 0.85f, 0.0f);
glClearDepth(1.0f);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
glShadeModel(GL_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
return true;
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE );
glutInitWindowSize(sWidth,sHeight);
glutCreateWindow( "FrameBuffer Objects!" );
// Setup GLEW
GLenum err = glewInit();
if (err != GLEW_OK || !glewIsSupported("GL_VERSION_2_0"))
{
printf("OpenGL 2.0 not supported. No shaders!\n");
printf("%s\n", glewGetErrorString(err));
printf("%s\n", (char*)glGetString(GL_VERSION));
return 0;
}
printf("OpenGL 2.0 supported.\n");
init();
initShader();
glutDisplayFunc( display );
glutReshapeFunc( reshape );
glutKeyboardFunc( keyboard );
glutIdleFunc( idle );
glutMainLoop();
return 0;
}
void RasterizerGLES3::initialize() {
if (OS::get_singleton()->is_stdout_verbose()) {
print_line("Using GLES3 video driver");
}
#ifdef GLEW_ENABLED
GLuint res = glewInit();
ERR_FAIL_COND(res != GLEW_OK);
if (OS::get_singleton()->is_stdout_verbose()) {
print_line(String("GLES2: Using GLEW ") + (const char *)glewGetString(GLEW_VERSION));
}
// Check for GL 2.1 compatibility, if not bail out
if (!glewIsSupported("GL_VERSION_3_0")) {
ERR_PRINT("Your system's graphic drivers seem not to support OpenGL 3.0+ / GLES 3.0, sorry :(\n"
"Try a drivers update, buy a new GPU or try software rendering on Linux; Godot will now crash with a segmentation fault.");
OS::get_singleton()->alert("Your system's graphic drivers seem not to support OpenGL 3.0+ / GLES 3.0, sorry :(\n"
"Godot Engine will self-destruct as soon as you acknowledge this error message.",
"Fatal error: Insufficient OpenGL / GLES drivers");
// TODO: If it's even possible, we should stop the execution without segfault and memory leaks :)
}
#endif
#ifdef GLAD_ENABLED
if (!gladLoadGL()) {
ERR_PRINT("Error initializing GLAD");
}
#ifdef __APPLE__
// FIXME glDebugMessageCallbackARB does not seem to work on Mac OS X and opengl 3, this may be an issue with our opengl canvas..
#else
glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(_gl_debug_print, NULL);
glEnable(_EXT_DEBUG_OUTPUT);
#endif
#endif
/* glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_ERROR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_PORTABILITY_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_PERFORMANCE_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_OTHER_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageInsertARB(
GL_DEBUG_SOURCE_API_ARB,
GL_DEBUG_TYPE_OTHER_ARB, 1,
GL_DEBUG_SEVERITY_HIGH_ARB,5, "hello");
*/
const GLubyte *renderer = glGetString(GL_RENDERER);
print_line("OpenGL ES 3.0 Renderer: " + String((const char *)renderer));
storage->initialize();
canvas->initialize();
scene->initialize();
}
///////////////////////////////////////////////////////////////////////
//main, setup and execution of environment
int main(int argc, char **argv) {
printf("calling putenv with: LIBGL_ALWAYS_SOFTWARE=1 \n");
if(putenv("LIBGL_ALWAYS_SOFTWARE=1")!=0)
{
fprintf(stderr,"putenv failed\n");
}
if(argc < 2)
{
printf("please select illumination model 1 2 or 3\n");
printf("usage: cgExercise02 <model number>\n");
return EXIT_FAILURE;
}
shader = atoi(argv[1]);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(320,320);
glutCreateWindow("Computer Graphics");
glutDisplayFunc(renderScene);
glutIdleFunc(renderScene);
glutReshapeFunc(changeSize);
glutKeyboardFunc(processNormalKeys);
glutMouseFunc(mouseClick);
glutMotionFunc(mouseMotion);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0,0.0,0.0,1.0);
glewInit();
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
printf("Ready for GLSL\n");
else {
printf("No GLSL support\n");
exit(1);
}
if (glewIsSupported("GL_VERSION_3_1"))
printf("Ready for OpenGL 3.1\n");
else {
printf("OpenGL 3.1 not supported\n");
exit(1);
}
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader && GL_EXT_geometry_shader4)
printf("Ready for GLSL - vertex, fragment, and geometry units\n");
else {
printf("Not totally ready :( \n");
exit(1);
}
initialize();
setShaders();
glutMainLoop();
return EXIT_SUCCESS;
}
bool CFrameBufferObject::IsSupported()
{
if (glewIsSupported("GL_EXT_framebuffer_object"))
m_supported = true;
else
m_supported = false;
return m_supported;
}
void CDDS::SetAFNum(GLfloat AFSet)
{
if (!glewIsSupported("GL_EXT_texture_filter_anisotropic"))
return;
GLfloat AFMAX=1.0f;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,&AFMAX);
CDDS::AFNum=max(1.0f,min(AFSet,AFMAX));
}
void GLGraphics::initAPIs()
{
assert(glewInit() == GLEW_OK);
assert(GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader);
assert(glewIsSupported("GL_VERSION_2_0"));
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
bool Application::InitialseWindow(unsigned int a_uiWindowWidth, unsigned int a_uiWindowHeight, bool a_bFullScreen /*= false*/)
{
m_uiWindowWidth = a_uiWindowWidth;
m_uiWinidowHeight = a_uiWindowHeight;
m_bFullScreen = a_bFullScreen;
if(!glfwInit())
{
return false;
}
// this creates the window to the size that was passed in and checks if full screen or not
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE,GL_TRUE);
glfwOpenWindow(m_uiWindowWidth, m_uiWinidowHeight, 8,8,8,8, 24, 8,(m_bFullScreen) ? GLFW_FULLSCREEN:GLFW_WINDOW);
glfwDisable(GLFW_AUTO_POLL_EVENTS);
glfwSetWindowTitle("Application");
// enable / disable vSync
EnableVSync(m_bVSyncEnabled);
glewExperimental = true;
if(glewInit() != GLEW_OK)
{
glfwTerminate();
return false;
}
// Setup OpenGL error callbacks if supported
if (glewIsSupported("GL_ARB_debug_output"))
{
glDebugMessageCallbackARB(glErrorCallback, nullptr);
glEnable(GL_DEBUG_OUTPUT);
}
else
{
printf("OpenGL error callbacks are not supported");
}
const char* fontName = "./arial.png";
const char* xmlName = "./arial.xml";
m_texture = new CTexture();
m_spriteBatch = new CSpritebatch(m_uiWindowWidth, m_uiWinidowHeight);
m_spriteBatch->Begin();
// sets the colour for the screen
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
//Enable some Blending.
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glDisable(GL_CULL_FACE);
return true;
}
bool CCEGLView::initGL()
{
m_hDC = GetDC(m_hWnd);
SetupPixelFormat(m_hDC);
//SetupPalette();
m_hRC = wglCreateContext(m_hDC);
wglMakeCurrent(m_hDC, m_hRC);
// check OpenGL version at first
const GLubyte* glVersion = glGetString(GL_VERSION);
CCLOG("OpenGL version = %s", glVersion);
if ( atof((const char*)glVersion) < 1.5 )
{
char strComplain[256] = {0};
sprintf(strComplain,
"OpenGL 1.5 or higher is required (your version is %s). Please upgrade the driver of your video card.",
glVersion);
CCMessageBox(strComplain, "OpenGL version too old");
return false;
}
GLenum GlewInitResult = glewInit();
if (GLEW_OK != GlewInitResult)
{
CCMessageBox((char *)glewGetErrorString(GlewInitResult), "OpenGL error");
return false;
}
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
{
CCLog("Ready for GLSL");
}
else
{
CCLog("Not totally ready :(");
}
if (glewIsSupported("GL_VERSION_2_0"))
{
CCLog("Ready for OpenGL 2.0");
}
else
{
CCLog("OpenGL 2.0 not supported");
}
if(glew_dynamic_binding() == false)
{
CCMessageBox("No OpenGL framebuffer support. Please upgrade the driver of your video card.", "OpenGL error");
return false;
}
// Enable point size by default on windows.
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
return true;
}
////////////////////////////////////////////////////////////////////////////////
//! Initialize GL
////////////////////////////////////////////////////////////////////////////////
CUTBoolean initGL(int *argc, char **argv)
{
// Create GL context
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(windowW, windowH);
glutCreateWindow("CUDA FFT Ocean Simulation");
vertShaderPath = cutFindFilePath("ocean.vert", argv[0]);
fragShaderPath = cutFindFilePath("ocean.frag", argv[0]);
if (vertShaderPath == 0 || fragShaderPath == 0) {
fprintf(stderr, "Error finding shader files!\n");
cudaThreadExit();
exit(EXIT_FAILURE);
}
// initialize necessary OpenGL extensions
glewInit();
if (! glewIsSupported("GL_VERSION_2_0 "
)) {
fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush(stderr);
return CUTFalse;
}
if (!glewIsSupported( "GL_VERSION_1_5 GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object" )) {
fprintf(stderr, "Error: failed to get minimal extensions for demo\n");
fprintf(stderr, "This sample requires:\n");
fprintf(stderr, " OpenGL version 1.5\n");
fprintf(stderr, " GL_ARB_vertex_buffer_object\n");
fprintf(stderr, " GL_ARB_pixel_buffer_object\n");
cleanup();
exit(-1);
}
// default initialization
glClearColor(0.0, 0.0, 0.0, 1.0);
glEnable(GL_DEPTH_TEST);
// load shader
shaderProg = loadGLSLProgram(vertShaderPath, fragShaderPath);
CUT_CHECK_ERROR_GL();
return CUTTrue;
}
// initialize OpenGL
void initGL(int *argc, char **argv)
{
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(winWidth, winHeight);
glutCreateWindow("CUDA Smoke Particles");
glewInit();
if (!glewIsSupported("GL_VERSION_2_0 GL_VERSION_1_5")) {
fprintf(stderr, "The following required OpenGL extensions missing:\n\tGL_VERSION_2_0\n\tGL_VERSION_1_5\n");
fprintf(stderr, " PASSED\n");
cutilExit(*argc, argv);
exit(-1);
}
if (!glewIsSupported("GL_ARB_multitexture GL_ARB_vertex_buffer_object GL_EXT_geometry_shader4")) {
fprintf(stderr, "The following required OpenGL extensions missing:\n\tGL_ARB_multitexture\n\tGL_ARB_vertex_buffer_object\n\tGL_EXT_geometry_shader4.\n");
fprintf(stderr, " PASSED\n");
cutilExit(*argc, argv);
exit(-1);
}
#if defined (_WIN32)
if (wglewIsSupported("WGL_EXT_swap_control")) {
// disable vertical sync
wglSwapIntervalEXT(0);
}
#endif
glEnable(GL_DEPTH_TEST);
// load floor texture
char* imagePath = cutFindFilePath("floortile.ppm", argv[0]);
if (imagePath == 0) {
fprintf(stderr, "Error finding floor image file\n");
fprintf(stderr, " FAILED\n");
exit(EXIT_FAILURE);
}
floorTex = loadTexture(imagePath);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0f);
floorProg = new GLSLProgram(floorVS, floorPS);
glutReportErrors();
}
GlProgram::
GlProgram() :
program(0), previousProgram(0)
{
if (!glewIsSupported("GL_ARB_shader_objects"))
Misc::throwStdErr("GLProgram: GL_ARB_shader_objects not supported");
program = glCreateProgramObjectARB();
}
////////////////////////////////////////////////////////////////////////////////
//! Initialize OpenGL
////////////////////////////////////////////////////////////////////////////////
CUTBoolean
initGL(int *argc, char **argv)
{
// Create GL context
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(window_width, window_height);
glutCreateWindow("CUDA Marching Cubes");
// initialize necessary OpenGL extensions
glewInit();
if (! glewIsSupported("GL_VERSION_2_0 "
)) {
fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush(stderr);
return CUTFalse;
}
// default initialization
glClearColor(0.1, 0.2, 0.3, 1.0);
glEnable(GL_DEPTH_TEST);
// good old-fashioned fixed function lighting
float black[] = { 0.0, 0.0, 0.0, 1.0 };
float white[] = { 1.0, 1.0, 1.0, 1.0 };
float ambient[] = { 0.1, 0.1, 0.1, 1.0 };
float diffuse[] = { 0.9, 0.9, 0.9, 1.0 };
float lightPos[] = { 0.0, 0.0, 1.0, 0.0 };
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black);
glLightfv(GL_LIGHT0, GL_AMBIENT, white);
glLightfv(GL_LIGHT0, GL_DIFFUSE, white);
glLightfv(GL_LIGHT0, GL_SPECULAR, white);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
// load shader program
gl_Shader = compileASMShader(GL_FRAGMENT_PROGRAM_ARB, shader_code);
if (g_FrameBufferObject) {
delete g_FrameBufferObject; g_FrameBufferObject = NULL;
}
if (g_bFBODisplay) {
g_FrameBufferObject = new CFrameBufferObject(window_width, window_height, 32, true, GL_TEXTURE_2D);
}
glutReportErrors();
return CUTTrue;
}
void CheckOpenGL()
{
bool supported;
glewInit();
if (glewIsSupported("GL_VERSION_3_3"))
{
supported = 1;
}
}
int main(int argc, char **argv) {
if (argc < 6) {
printf("usage: leitura arqin.raw width height slices dslices colormap\n");
exit(1);
}
glutInit(&argc, argv);
//glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100, 100);
glutInitWindowSize(640, 640);
glutCreateWindow("Teste de Vizualizacao com textura 3D");
glutDisplayFunc(&DrawGLScene);
glutIdleFunc(&DrawGLScene);
glutReshapeFunc(&ReSizeGLScene);
glutKeyboardFunc(&keyPressed);
glutMotionFunc(MoveMouseBotaoPressionado);
glutPassiveMotionFunc(MoveMouse);
glutMouseFunc(GerenciaMouse);
raw = readRAW(argc, argv);
GLenum err = glewInit();
if (GLEW_OK != err) {
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
}
if (glewIsSupported("GL_VERSION_2_1"))
printf("Ready for OpenGL 2.1\n");
else {
printf("OpenGL 2.1 not supported\n");
exit(1);
}
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader
&& GL_EXT_geometry_shader4)
printf("Ready for GLSL - vertex, fragment, and geometry units\n");
else {
printf("Not totally ready :( \n");
exit(1);
}
if(argc==7) colorMapRead(argv[6],cm);
else {
createColorMap(cm);
//colorMapWrite("teste.map", cm);
//colorMapRead("teste.map", cm);
}
InitGL(640, 640);
/* Start Event Processing Engine */
glutMainLoop();
return 1;
}
void GimRasterizer::init_extensions() {
if(!glewIsSupported(REQUIRED_EXTENSIONS)) {
Logger::err("Fatal") << "Could not initialize OpenGL extensions"
<< std::endl ;
ogf_assert_not_reached ;
}
glGenProgramsNV(1, &fragment_program);
}
///////////////////////////////////////////////////////////////////////
//main, setup and execution of environment
int main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(568,320);
glutCreateWindow("Computer Graphics");
glutDisplayFunc(renderScene);
glutIdleFunc(renderScene);
glutReshapeFunc(changeSize);
glutKeyboardFunc(processNormalKeys);
glutMouseFunc(mouseClick);
glutMotionFunc(mouseMotion);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0,0.0,0.0,1.0);
glewInit();
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
printf("Ready for GLSL\n");
else {
printf("No GLSL support\n");
exit(1);
}
if (glewIsSupported("GL_VERSION_3_3"))
printf("Ready for OpenGL 3.3\n");
else {
printf("OpenGL 3.3 not supported\n");
exit(1);
}
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader && GL_EXT_geometry_shader4)
printf("Ready for GLSL - vertex, fragment, and geometry units\n");
else {
printf("Not totally ready :( \n");
exit(1);
}
if (GL_ARB_fragment_program && GL_ARB_vertex_program && GL_EXT_framebuffer_object)
printf("Ready for FrameBuffer\n");
else {
printf("Not totally ready :( \n");
exit(1);
}
initialize();
#ifdef __linux__
int i=pthread_getconcurrency();
#endif
setShaders();
glutMainLoop();
return EXIT_SUCCESS;
}
Renderer* Init(Settings vs)
{
assert(!initted);
if (initted) return 0;
// no mode set, find an ok one
if ((vs.width <= 0) || (vs.height <= 0)) {
const std::vector<VideoMode> modes = GetAvailableVideoModes();
assert(!modes.empty());
vs.width = modes.front().width;
vs.height = modes.front().height;
}
WindowSDL *window = new WindowSDL(vs, "Pioneer");
width = window->GetWidth();
height = window->GetHeight();
glewInit();
if (!glewIsSupported("GL_ARB_vertex_buffer_object"))
OS::Error("OpenGL extension ARB_vertex_buffer_object not supported. Pioneer can not run on your graphics card.");
Renderer *renderer = 0;
shadersAvailable = glewIsSupported("GL_VERSION_2_0");
shadersEnabled = vs.shaders && shadersAvailable;
if (shadersEnabled)
renderer = new RendererGL2(window, vs);
else
renderer = new RendererLegacy(window, vs);
printf("Initialized %s\n", renderer->GetName());
initted = true;
MaterialDescriptor desc;
desc.vertexColors = true;
vtxColorMaterial = renderer->CreateMaterial(desc);
vtxColorMaterial->IncRefCount();
return renderer;
}
bool ofGLCheckExtension(string searchName){
#if defined( TARGET_OPENGLES )
vector<string> extensionsList = ofGLSupportedExtensions();
set<string> extensionsSet;
extensionsSet.insert(extensionsList.begin(),extensionsList.end());
return extensionsSet.find(searchName)!=extensionsSet.end();
#else
return glewIsSupported(searchName.c_str());
#endif
}
bool CCEGLView::createWithSize(int w, int h)
{
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER | SDL_INIT_NOPARACHUTE);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
//
// SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
// SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
unsigned flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
// flags |= SDL_WINDOW_FULLSCREEN;
// flags |= SDL_WINDOW_RESIZABLE;
// flags |= SDL_WINDOW_BORDERLESS;
_window = SDL_CreateWindow("Cocos2d SDL ", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags);
//SDL_GL_MakeCurrent(_window, SDL_GL_CreateContext(_window));
SDL_GL_CreateContext(_window);
#if CC_TARGET_PLATFORM == CC_PLATFORM_WIN32
if (glewInit() != GLEW_OK)
return false;
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
{
CCLog("Ready for GLSL");
}
else
{
CCLog("Not totally ready :(");
}
if (glewIsSupported("GL_VERSION_2_0"))
{
CCLog("Ready for OpenGL 2.0");
}
else
{
CCLog("OpenGL 2.0 not supported");
}
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
SDL_GL_SetSwapInterval(1);
setFrameSize(w, h);
// setDesignResolutionSize(800, 600, kResolutionShowAll);
#endif
return true;
}
int main(int argc, char **argv) {
// GLUT initialization
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA|GLUT_MULTISAMPLE);
glutInitContextVersion (4, 2);
glutInitContextProfile (GLUT_CORE_PROFILE );
glutInitContextFlags(GLUT_DEBUG);
glutInitWindowPosition(100,100);
glutInitWindowSize(640,360);
glutCreateWindow("Lighthouse3D - Simplest Demo");
// Callback Registration
glutDisplayFunc(renderScene);
glutReshapeFunc(changeSize);
glutIdleFunc(renderScene);
// return from main loop
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);
// Init GLEW
glewExperimental = GL_TRUE;
glewInit();
if (glewIsSupported("GL_VERSION_4_2"))
printf("Ready for OpenGL 4.2\n");
else {
printf("OpenGL 4.2 not supported\n");
exit(1);
}
printf ("Vendor: %s\n", glGetString (GL_VENDOR));
printf ("Renderer: %s\n", glGetString (GL_RENDERER));
printf ("Version: %s\n", glGetString (GL_VERSION));
printf ("GLSL: %s\n", glGetString (GL_SHADING_LANGUAGE_VERSION));
int param;
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, ¶m);
if (param == GL_CONTEXT_CORE_PROFILE_BIT)
printf("Context Profile: Core\n");
else
printf("Context Profile: Compatibility\n");
glGetIntegerv(GL_CONTEXT_FLAGS, ¶m);
setupShaders();
initGL();
// GLUT main loop
glutMainLoop();
return(1);
}
//-----------------------------------------------------------------------------
void QGLImageGpuWidget::paintGL()
{
if(image_ == 0)
return;
// printf("QGLImageGpuWidget::paintGL()\n");
if (!glewIsSupported( "GL_VERSION_1_5 GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object" ))
{
printf("!!!!!!!!!!!! CALL GLEW INIT !!!!!!!!!!!!\n");
glewInit();
return;
}
// check for min/max values if normalization is activated
if(normalize_)
this->autoMinMax();
// fill the picture buffer object
fillPbo();
// common display code path
{
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, gl_pbo_);
glBindTexture(GL_TEXTURE_2D, gl_tex_ );
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, image_->width(), image_->height(),
GL_RGBA, GL_UNSIGNED_BYTE, NULL );
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity ();
glOrtho (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
glViewport(0, 0, (int)floor(image_->width()*zoom_), (int)floor(image_->height()*zoom_));
#if 0
glBegin(GL_TRIANGLES);
glTexCoord2f(0, 0); glVertex2f(-1, 1);
glTexCoord2f(2, 0); glVertex2f( 3, 1);
glTexCoord2f(0, 2); glVertex2f(-1,-3);
glEnd();
#else
glBegin(GL_QUADS);
glTexCoord2f( 0.0, 0.0); glVertex3f(-1.0, 1.0, 0.5);
glTexCoord2f( 1.0, 0.0); glVertex3f( 1.0, 1.0, 0.5);
glTexCoord2f( 1.0, 1.0); glVertex3f( 1.0, -1.0, 0.5);
glTexCoord2f( 0.0, 1.0); glVertex3f(-1.0, -1.0, 0.5);
glEnd ();
#endif
}
glPopMatrix();
// printf("QGLImageGpuWidget::paintGL() done\n");
}
// Initialize GL
//*****************************************************************************
bool InitGL(int* argc, char **argv )
{
// init GLUT and GLUT window
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_ALPHA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition (glutGet(GLUT_SCREEN_WIDTH)/2 - iGraphicsWinWidth/2,
glutGet(GLUT_SCREEN_HEIGHT)/2 - iGraphicsWinHeight/2);
glutInitWindowSize(iGraphicsWinWidth, iGraphicsWinHeight);
iGLUTWindowHandle = glutCreateWindow("OpenCL/OpenGL post-processing");
#if !(defined (__APPLE__) || defined(MACOSX))
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);
#endif
// register GLUT callbacks
glutDisplayFunc(DisplayGL);
glutKeyboardFunc(KeyboardGL);
glutReshapeFunc(Reshape);
glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
// create GLUT menu
iGLUTMenuHandle = glutCreateMenu(mainMenu);
glutAddMenuEntry("Toggle Post-processing (Blur filter) ON/OFF <spacebar>", ' ');
glutAddMenuEntry("Toggle Processor between GPU and CPU [p]", 'p');
glutAddMenuEntry("Toggle GL animation (rotation) ON/OFF [a]", 'a');
glutAddMenuEntry("Increment blur radius [+ or =]", '=');
glutAddMenuEntry("Decrement blur radius [- or _]", '-');
glutAddMenuEntry("Quit <esc>", '\033');
glutAttachMenu(GLUT_RIGHT_BUTTON);
// init GLEW
glewInit();
GLboolean bGLEW = glewIsSupported("GL_VERSION_2_0 GL_ARB_pixel_buffer_object");
oclCheckErrorEX(bGLEW, shrTRUE, pCleanup);
// default initialization
glClearColor(0.5, 0.5, 0.5, 1.0);
glDisable(GL_DEPTH_TEST);
// viewport
glViewport(0, 0, iGraphicsWinWidth, iGraphicsWinHeight);
// projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)iGraphicsWinWidth / (GLfloat) iGraphicsWinHeight, 0.1, 10.0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_LIGHT0);
float red[] = { 1.0, 0.1, 0.1, 1.0 };
float white[] = { 1.0, 1.0, 1.0, 1.0 };
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, red);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0);
return true;
}
void initGL(int *argc, char **argv)
{
// initialize GLUT callback functions
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_ALPHA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(width, height);
glutCreateWindow("CUDA bicubic texture filtering");
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
initMenus();
glewInit();
if (!glewIsSupported("GL_VERSION_2_0 "
"GL_ARB_pixel_buffer_object "
))
{
fprintf(stderr, "Required OpenGL extensions are missing.");
exit(EXIT_FAILURE);
}
#if USE_BUFFER_TEX
if (!glewIsSupported("GL_EXT_texture_buffer_object"))
{
fprintf(stderr, "OpenGL extension: GL_EXT_texture_buffer_object missing.\n");
exit(EXIT_FAILURE);
}
if (!glewIsSupported("GL_NV_gpu_program4"))
{
fprintf(stderr, "OpenGL extension: GL_NV_gpu_program4 missing.\n");
exit(EXIT_FAILURE);
}
#endif
}
int main(int argc, char **argv)
{
srand(time(NULL));
time(&startTime);
lastTime = startTime;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(500, 500);
glutInitWindowSize(800, 600);
glutCreateWindow("Test");
glewInit();
if (!glfwInit())
exit(EXIT_FAILURE);
Init();
if (glewIsSupported("GL_VERSION_3_3"))
{
std::cout << "GLEW Version is 3.3\n";
}
else
{
std::cout << "GLEW 3.3 is not supported\n";
}
glEnable(GL_DEPTH_TEST);
glutIgnoreKeyRepeat(true);
glutIdleFunc(idleFunction);
glutDisplayFunc(renderScene);
glutReshapeFunc(reshapeView);
glutSpecialFunc(specialKeyPressed);
glutSpecialUpFunc(specialKeyReleased);
glutKeyboardFunc(keyPressed);
glutMotionFunc(mouseDrag);
glutPassiveMotionFunc(mouseMove);
glutMouseFunc(mouseClick);
glutMouseWheelFunc(mouseScroll);
const unsigned char* version = glGetString(GL_VERSION);
std::cout << "Using openGL version " << version << std::endl;
glutFullScreen(); // making the window full screen
fpsLastTime = 0;
fpsCurrentTime = 0;
glfwSetTime(0);
myfile.open("fps.txt");
glutMainLoop();
myfile.close();
return 0;
}