int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); glutInitWindowSize(width, height); glutCreateWindow("Image Processing"); glewInit(); GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ std::cout << "glewInit failed, aborting." << std::endl; exit (1); } std::cout << "Status: Using GLEW " << glewGetString(GLEW_VERSION) << std::endl; std::cout << "OpenGL version " << glGetString(GL_VERSION) << " supported" << std::endl; initVAO(); initTextures(); passthroughProgram = initShader("passthroughVS.glsl", "passthroughFS.glsl"); boxBlurProgram = initShader("passthroughVS.glsl", "boxBlurFS.glsl"); glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glUseProgram(passthroughProgram); glActiveTexture(GL_TEXTURE0); glutMainLoop(); return 0; }
GLuint initGLSLProgram(char *vertexShaderFilename, char *fragmentShaderFilename) { GLuint shaderProgram; GLuint vertexShader,fragmentShader; vertexShader = initShader(vertexShaderFilename,GL_VERTEX_SHADER); fragmentShader = initShader(fragmentShaderFilename,GL_FRAGMENT_SHADER); shaderProgram = glCreateProgram(); glAttachShader(shaderProgram,vertexShader); glAttachShader(shaderProgram,fragmentShader); glLinkProgram(shaderProgram); glUseProgram(shaderProgram); return shaderProgram; }
void TMIP::initializeResources() { auto volumes = inport_.getData(); int numVolumes = static_cast<int>(volumes->size()); auto samplers = std::min(maxSamplers_, numVolumes); initShader(shader_, samplers); if (numVolumes > maxSamplers_) { samplers = (numVolumes - maxSamplers_) % (maxSamplers_ - 1) + 1; initShader(shaderLast_, samplers); } }
unsigned int SampleUtils::createProgramFromBuffer(const char* vertexShaderBuffer, const char* fragmentShaderBuffer) { #ifdef USE_OPENGL_ES_2_0 GLuint vertexShader = initShader(GL_VERTEX_SHADER, vertexShaderBuffer); if (!vertexShader) return 0; GLuint fragmentShader = initShader(GL_FRAGMENT_SHADER, fragmentShaderBuffer); if (!fragmentShader) return 0; GLuint program = glCreateProgram(); if (program) { glAttachShader(program, vertexShader); checkGlError("glAttachShader"); glAttachShader(program, fragmentShader); checkGlError("glAttachShader"); glLinkProgram(program); GLint linkStatus = GL_FALSE; glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); if (linkStatus != GL_TRUE) { GLint bufLength = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength); if (bufLength) { char* buf = (char*) malloc(bufLength); if (buf) { glGetProgramInfoLog(program, bufLength, NULL, buf); LOG("Could not link program: %s", buf); free(buf); } } glDeleteProgram(program); program = 0; } } return program; #else return 0; #endif }
CoordSystemRenderer::CoordSystemRenderer(float length): _length(length) { initShader(); initVBO(); }
void init(SDL_Surface* screen) { const unsigned char* version = glGetString(GL_VERSION); std::cout << "OpenGL version: " << version << std::endl; GLint maxTex; glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTex); std::cout << "Maximum texture units: " << maxTex << std::endl; glClearColor(0.0, 0.0, 0.0, 1.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45, static_cast<float>(screen->w)/static_cast<float>(screen->h), 1.0, 500.0); glMatrixMode(GL_MODELVIEW); glShadeModel(GL_SMOOTH); // This is the default setting anyways. glEnable(GL_DEPTH_TEST); cam = new Camera(0.0, 0.0, 0.0, 0.0, 0.0); initShader("shader/lighting.vs", "shader/lighting.frag", prog, vert, frag); monkey = obj.load("model/obj/stapler.obj"); return; }
void LevelOneScreen::onEntry(){ //Initialize SpriteFont _spriteFont.init("Fonts/shangri-la.ttf", 32); //Initialize spriteBatch _spriteBatch.init(); //Initialize the shader initShader(); //Initialize GUI initUI(); //Initialize audio engine _audioEngine.init(); loadMusic(); //Initialize Level initLevel(); _screenSize = glm::vec2(_window->getScreenWidth(), _window->getScreenHeight()); //initialize camera _camera.init(_window->getScreenWidth(), _window->getScreenHeight()); //For Debuging _camera.setScale(1.3); }
int main(int argc, char** argv) { loadTerrain(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_RGBA | GLUT_DOUBLE | GLUT_MULTISAMPLE); glutInitWindowSize(s_width, s_height); glutInitWindowPosition(0, 0); glutCreateWindow("Terrain"); glewInit(); initVertexBufferObject(); initTexture(); initShader(); glClearColor(1.0, 1.0, 1.0, 1.0); glEnable(GL_DEPTH_TEST); glEnable(GL_MULTISAMPLE); glutDisplayFunc(on_display); glutReshapeFunc(on_reshape); glutKeyboardFunc(on_keyboard); glutTimerFunc(1, on_timer, 1); glutMainLoop(); return 0; }
int main( int argc, char *argv[] ) { XVisualInfo *xvVisualInfo; Colormap cmColorMap; XSetWindowAttributes winAttr; GLXContext glXContext; int Attr[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER, None }; // Connect to X Server dpy = XOpenDisplay(NULL); if(dpy == NULL) return 0; // Could not open display // GLX extension is supported? if(!glXQueryExtension(dpy, NULL, NULL)) return 0; // Return, if X server haven't GLX // Find visual xvVisualInfo = glXChooseVisual(dpy, DefaultScreen(dpy), Attr); if(xvVisualInfo == NULL) return 0; // If Visual info can't be shoosed // Create new colormap for our window cmColorMap = XCreateColormap(dpy, RootWindow(dpy, xvVisualInfo->screen), xvVisualInfo->visual, AllocNone); winAttr.colormap = cmColorMap; winAttr.border_pixel = 0; winAttr.background_pixel = 0; winAttr.event_mask = ExposureMask | ButtonPressMask | StructureNotifyMask | KeyPressMask; // Create window win = XCreateWindow(dpy, RootWindow(dpy, xvVisualInfo->screen), 0, 0, 640, 480, 0, xvVisualInfo->depth, InputOutput, xvVisualInfo->visual, CWBorderPixel | CWColormap | CWEventMask, &winAttr); // Create OpenGL rendering context glXContext = glXCreateContext(dpy, xvVisualInfo, None, True); if(glXContext == NULL) return 0; // Can't create rendering context // Make it current glXMakeCurrent(dpy, win, glXContext); // Map window on the display XMapWindow(dpy, win); initShader(); loadTextures(); // Enter to the main X loop event_loop(); glDeleteTextures( 1, &datatexID ); glDeleteObjectARB( g_vertexShader ); glDeleteObjectARB( g_fragmentShader ); glDeleteObjectARB( g_programObj ); return 0; }
void TripleChannelRaycaster::initContext(GLContextData& contextData) const { /* Create a new data item: */ DataItem* dataItem=new DataItem; contextData.addDataItem(this,dataItem); /* Initialize the data item: */ initDataItem(dataItem); try { /* Load and compile the vertex program: */ std::string vertexShaderName=VISUALIZER_SHADERDIR; vertexShaderName.append("/TripleChannelRaycaster.vs"); dataItem->shader.compileVertexShader(vertexShaderName.c_str()); std::string fragmentShaderName=VISUALIZER_SHADERDIR; fragmentShaderName.append("/TripleChannelRaycaster.fs"); dataItem->shader.compileFragmentShader(fragmentShaderName.c_str()); dataItem->shader.linkShader(); /* Initialize the raycasting shader: */ initShader(dataItem); } catch(std::runtime_error err) { /* Print an error message, but continue: */ std::cerr<<"TripleChannelRaycaster::initContext: Caught exception "<<err.what()<<std::endl; } }
PlaneMesh::PlaneMesh(): shader(initShader()), vao(initVAO(shader, vertex_attrib_idx, uniform)), mode(GL_TRIANGLES), first_idx(0), count(6) { }
int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); glutInitWindowSize(1027, 768); glutCreateWindow("Meshes with Shaders"); glewInit(); GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ std::cout << "glewInit failed, aborting." << std::endl; exit (1); } std::cout << "Status: Using GLEW " << glewGetString(GLEW_VERSION) << std::endl; std::cout << "OpenGL version " << glGetString(GL_VERSION) << " supported" << std::endl; init(); initGrid(); initShader(); glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutMainLoop(); return 0; }
int main(int argc, char* argv[]){ srand ( time(NULL) ); int val=0; glutInit(&argc,argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB ); glutInitWindowPosition( 5, 20); glutInitWindowSize(300, 300); glutCreateWindow("OpenGL Swizzle Test on 4D Points"); glutReshapeFunc( resize ); glutIdleFunc( idle ); glutDisplayFunc( draw ); glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT); glewInit(); if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader) printf("Ready for GLSL\n"); else { printf("Not totally ready \n"); exit(1); } initPoints(); initShader(); glutMainLoop( ); return(0); }
int intro_init( void ) { if( !EXT_Init() ) return( 0 ); initShader( &pid, vsh_2d, fsh_rayt ); return 1; }
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; }
CoordSystem::CoordSystem(float length): _length(length) { initShader(); initVBO(); }
void init(void) { initExtensionEntries (); initBuffer (); initShader (); initRendering (); }
int main(int argc, char** argv) { int i,j; /* flat mesh */ for(i=0;i<N;i++) for(j=0;j<N;j++) data[i][j]=0.0; glutInit(&argc, argv); #ifndef __APPLE__ glewInit(); #endif glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(512, 512); glutCreateWindow("Simple GLSL example"); glutDisplayFunc(draw); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutIdleFunc(idle); glutMouseFunc(mouseButton); glutMotionFunc(mouseMotion); init(); initShader("vmesh.glsl", "fPassthrough.glsl"); glutMainLoop(); return 0 ; /* to keep compiler from complaining */ }
int main(int argc,char** argv) { int err; glutInit(&argc,argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(512, 512); glutInitWindowPosition(256, 256); glutCreateWindow("GLSL Test : Draw a triangle"); err = glewInit(); if( GLEW_OK != err )printf("glewinit: %s\n", glewGetErrorString(err)); glViewport(0, 0, 512, 512); glEnable(GL_DEPTH_TEST); initShader(); initVBO(); glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutReshapeFunc(callback_reshape); glutMouseFunc(callback_mouse); glutMotionFunc(callback_move); glutMainLoop(); glDeleteShader(vShader); glUseProgram(0); return 0; }
int initGL() { //初始化GLFW if (!glfwInit()) return -1; //创建窗口 window = glfwCreateWindow(640, 480, "Magic Cube", NULL, NULL); if (!window) { glfwTerminate(); return -2; } //让窗体环境正确 glfwMakeContextCurrent(window); //初始化GLEW if (glewInit() != GLEW_OK) return -3; initShader(); initCallBack(); //初始化Opengl的一些东西 glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); glfwSetWindowSize(window, 870, 512); return true; }
int main(){ //Change this line to use your name! yourName = "Karl Li"; // Needed in OSX to force use of OpenGL3.2 glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2); glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); init(); initCuda(); CUT_CHECK_ERROR_GL(); initVAO(); initTextures(); GLuint passthroughProgram; passthroughProgram = initShader("shaders/passthroughVS.glsl", "shaders/passthroughFS.glsl"); glUseProgram(passthroughProgram); glActiveTexture(GL_TEXTURE0); // send into GLFW main loop while(1){ display(); if (glfwGetKey(GLFW_KEY_ESC) == GLFW_PRESS || !glfwGetWindowParam( GLFW_OPENED )){ exit(0); } } glfwTerminate(); return 0; }
void PhysicsDebugDrawer::init () { initShader(); initVaoVbo(); }
bool MiniMap::init() { size = 200; GLuint tmpHandle; glGenTextures(1, &tmpHandle); mmTexture = TextureManager::shared().createTextureFromHandle("minimap", tmpHandle); if(!initShader()) { LOG_ERROR("Could not initialize mini-map shaders"); return false; } if(!initFBO()) { LOG_ERROR("Could not initialize mini-map fbo"); return false; } if(!initVAOs()) { LOG_ERROR("Could not initialize mini-map vao"); return false; } mmWindow = new Window( vec2(-1.0, -1.0), vec2(0.0, 0.0), vec2(size), mmTexture, WINDOW_DRAGGABLE, "Minimap"); Interface::shared().makeActive(mmWindow); return true; }
void Vision::initialize(std::uint16_t & width, std::uint16_t & height) { // Firstly, let the decorated renderer (most likely the window) perform its initialization. // m_decoratedRenderer->initialize(width, height); m_vao.create(); m_vao.bind(); m_verticesPositions.create(); m_verticesPositions.setUsagePattern(QOpenGLBuffer::StaticDraw); m_verticesPositions.bind(); m_verticesPositions.allocate(verticesPositionData.constData(), verticesPositionData.size() * sizeof(QVector3D)); m_verticesPositions.release(); initShader(); m_shader.bind(); m_verticesPositions.bind(); m_shader.enableAttributeArray(m_vertexPositionAttribute); m_shader.setAttributeBuffer(m_vertexPositionAttribute, GL_FLOAT, 0, 3); m_verticesPositions.release(); m_shader.release(); m_vao.release(); }
int glInit(void){ if(debugmode) printf("DEBUG -- Initialising OpenGL \n"); GLenum glewError = glewInit(); if( glewError != GLEW_OK ){ printf( "Error initializing GLEW! %s\n", glewGetErrorString( glewError ) ); return FALSE; } glDisable(GL_DEPTH_TEST); glClearColor(0.0f, 0.0f, 0.0f, 0.5f); glEnable(GL_TEXTURE_2D); //todo move this stuff glViewport(0, 0, playwidth, playheight); glMatrixMode(GL_PROJECTION);// Select The Projection Matrix glLoadIdentity();// Reset The Projection Matrix glOrtho(-1.0f, 1.0f, -1.0f, 1.0f, 0.1f, 100.0f); //maybe change glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix glLoadIdentity(); // Reset The Modelview Matrix glColor3f(1.0f, 1.0f, 1.0f); //wont need this much longer //todo error checkelecking if(!initShader()) return FALSE; if(!initFB()) return FALSE; // glUseProgram(programobject); initVBO(); return TRUE; }
GLColoredBox::GLColoredBox(float size_x, float size_y, float size_z): _size_x(size_x),_size_y(size_y),_size_z(size_z) { initShader(); initVBO(); }
int main(int argc, char** argv) { readArguments(argc, argv); volume = new Volume(); if(!strcmp(pathExtension, "tif")) volume->loadTIFData(path, firstSlice, lastSlice); else if(!strcmp(pathExtension, "pgm")) volume->loadPGMData(path, firstSlice, lastSlice); else volume->loadRAWData(path, firstSlice, firstSlice, lastSlice); //triCubicInterpolationPreFilter = new TriCubicInterpolationPreFilter(); //triCubicInterpolationPreFilter->applyPreFilterForAccurateCubicBSplineInterpolation(volume->getData(), volume->getWidth(), volume->getHeight(), volume->getDepth()); minMaxOctree = new MinMaxOctree(volume->getWidth(), volume->getHeight(), volume->getDepth()); minMaxOctree->build(volume->getData(), volume->getWidth(), volume->getHeight(), volume->getDepth()); glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_ALPHA); glutInitWindowSize(windowWidth, windowHeight); glutCreateWindow("Volume Rendering"); glutReshapeFunc(reshape); glutDisplayFunc(display); glutIdleFunc(idle); glutKeyboardFunc(keyboard); glutSpecialFunc(specialKeyboard); glutMouseFunc(mouse); glewInit(); initGL(); initShader("Shaders/VRBlendRaycasting", VOLUME_RENDERING_SHADER); initShader("Shaders/VRContextPreservingPreIntegrationRaycasting", CONTEXT_PRESERVING_VOLUME_RENDERING_SHADER); initShader("Shaders/VRPreIntegrationRaycasting", PRE_INTEGRATION_TRANSFER_FUNCTION_SHADER); initShader("Shaders/VRLocalIlluminationPreIntegrationRaycasting", LOCAL_ILLUMINATION_SHADER); initShader("Shaders/VRNonPolygonalRaycasting", NON_POLYGONAL_SHADER); initShader("Shaders/FCNormalEstimation", FC_NORMAL_ESTIMATION_SHADER); initShader("Shaders/FCCurvatureEstimation", FC_CURVATURE_ESTIMATION_SHADER); initShader("Shaders/FCFinalRendering", FC_FINAL_RENDERING_SHADER); glUseProgram(0); glutMainLoop(); delete volume; delete minMaxOctree; delete myGLImageViewer; delete myGLCloudViewer; delete transferFunction; delete triCubicInterpolationPreFilter; return 0; }
void GLWidget::resizeGL(int w, int h) { // TODO: m_windowWidth = w; m_windowHeight = h; initShader(); }
bool Self::initWithTexture(cocos2d::Texture2D* texture, const cocos2d::Rect& rect, bool rotated) { if (not Super::initWithTexture(texture, rect, rotated)) { return false; } initShader(); return true; }
/*! Init the geometry object */ void GLObjectObjFl::init(void) { if(_file_ok) { initShader(); initVBO(); } }