GLuint loadBMP_custom(const char * imagepath){ printf("Reading image %s\n", imagepath); // Data read from the header of the BMP file unsigned char header[54]; unsigned int dataPos; unsigned int imageSize; unsigned int width, height; // Actual RGB data unsigned char * data; // Open the file FILE * file = fopen(imagepath,"rb"); if (!file) {printf("%s could not be opened. Are you in the right directory ? Don't forget to read the FAQ !\n", imagepath); getchar(); return 0;} // Read the header, i.e. the 54 first bytes // If less than 54 bytes are read, problem if ( fread(header, 1, 54, file)!=54 ){ printf("Not a correct BMP file\n"); return 0; } // A BMP files always begins with "BM" if ( header[0]!='B' || header[1]!='M' ){ printf("Not a correct BMP file\n"); return 0; } // Make sure this is a 24bpp file if ( *(int*)&(header[0x1E])!=0 ) {printf("Not a correct BMP file\n"); return 0;} if ( *(int*)&(header[0x1C])!=24 ) {printf("Not a correct BMP file\n"); return 0;} // Read the information about the image dataPos = *(int*)&(header[0x0A]); imageSize = *(int*)&(header[0x22]); width = *(int*)&(header[0x12]); height = *(int*)&(header[0x16]); // Some BMP files are misformatted, guess missing information if (imageSize==0) imageSize=width*height*3; // 3 : one byte for each Red, Green and Blue component if (dataPos==0) dataPos=54; // The BMP header is done that way // Create a buffer data = new unsigned char [imageSize]; // Read the actual data from the file into the buffer fread(data,1,imageSize,file); // Everything is in memory now, the file wan be closed fclose (file); // Create one OpenGL texture GLuint textureID; glGenTextures(1, &textureID); // "Bind" the newly created texture : all future texture functions will modify this texture glBindTexture(GL_TEXTURE_2D, textureID); // Give the image to OpenGL glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, width, height, 0, GL_BGR, GL_UNSIGNED_BYTE, data); // OpenGL has now copied the data. Free our own version delete [] data; // Poor filtering, or ... //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // ... nice trilinear filtering. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glGenerateMipmap(GL_TEXTURE_2D); // Return the ID of the texture we just created return textureID; }
bool ImGui_ImplSdl_CreateDeviceObjects() { // Backup GL state GLint last_texture, last_array_buffer; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer); const GLchar *vertex_shader = "uniform mat4 ProjMtx;\n" "attribute vec2 Position;\n" "attribute vec2 UV;\n" "attribute vec4 Color;\n" "varying vec2 Frag_UV;\n" "varying vec4 Frag_Color;\n" "void main()\n" "{\n" " Frag_UV = UV;\n" " Frag_Color = Color;\n" " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n" "}\n"; const GLchar* fragment_shader = // WebGL requires precision specifiers but OpenGL 2.1 disallows // them, so I define the shader without it and then add it here. "precision mediump float;\n" "uniform sampler2D Texture;\n" "varying vec2 Frag_UV;\n" "varying vec4 Frag_Color;\n" "void main()\n" "{\n" " gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV);\n" "}\n"; g_ShaderHandle = glCreateProgram(); g_VertHandle = glCreateShader(GL_VERTEX_SHADER); g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(g_VertHandle, 1, &vertex_shader, 0); glShaderSource(g_FragHandle, 1, &fragment_shader, 0); glCompileShader(g_VertHandle); glCompileShader(g_FragHandle); glAttachShader(g_ShaderHandle, g_VertHandle); glAttachShader(g_ShaderHandle, g_FragHandle); glLinkProgram(g_ShaderHandle); g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture"); g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx"); g_AttribLocationPosition = glGetAttribLocation(g_ShaderHandle, "Position"); g_AttribLocationUV = glGetAttribLocation(g_ShaderHandle, "UV"); g_AttribLocationColor = glGetAttribLocation(g_ShaderHandle, "Color"); glGenBuffers(1, &g_VboHandle); glGenBuffers(1, &g_ElementsHandle); ImGuiIO& io = ImGui::GetIO(); // Build texture unsigned char* pixels; int width, height; io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); // Load as RGBA 32-bits for OpenGL3 demo because it is more likely to be compatible with user's existing shader. // Create OpenGL texture glGenTextures(1, &g_FontTexture); glBindTexture(GL_TEXTURE_2D, g_FontTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); // Store our identifier io.Fonts->TexID = (void *)(intptr_t)g_FontTexture; // Cleanup (don't clear the input data if you want to append new fonts later) io.Fonts->ClearInputData(); io.Fonts->ClearTexData(); // Restore modified GL state glBindTexture(GL_TEXTURE_2D, last_texture); glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer); return true; }
Texture* TextureManagerGL::create(SDL_Surface* image) { int texture_w = powerOfTwo(image->w); int texture_h = powerOfTwo(image->h); //int texture_w = image->w; //int texture_h = image->h; //LOGD("[Lincity]TextureManagerGL::create() - w=%d h=%d w=%d h=%d pitch=%d\n",texture_w,texture_h,image->w,image->h,image->pitch); #if SDL_BYTEORDER == SDL_BIG_ENDIAN SDL_Surface* convert = SDL_CreateRGBSurface(SDL_SWSURFACE, texture_w, texture_h, 32, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff); #else SDL_Surface* convert = SDL_CreateRGBSurface(SDL_SWSURFACE, texture_w, texture_h, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000); #endif if(convert == 0) { std::ostringstream msg; msg << "Couldn't convert SDL_Surface while creating texture" << " (out of memory?): " << SDL_GetError(); throw std::runtime_error(msg.str()); } SDL_SetAlpha(image, 0, 0); SDL_BlitSurface(image, 0, convert, 0); GLuint handle; glGenTextures(1, &handle); SDL_PixelFormat* format = convert->format; glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glBindTexture(GL_TEXTURE_2D, handle); //LOGD("[Lincity]TextureManagerGL::create() - Handle %d\n",handle); //glPixelStorei(GL_UNPACK_ALIGNMENT, 1); //glPixelStorei(GL_UNPACK_ROW_LENGTH, convert->pitch/format->BytesPerPixel); //assert(convert->pitch == texture_w * convert->format->BytesPerPixel); /* glTexImage2D(GL_TEXTURE_2D, 0, format->BytesPerPixel, convert->w, convert->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, convert->pixels); */ glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, convert->w, convert->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, convert->pixels); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); /* glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP); */ //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE); TextureGL* texture = new TextureGL(handle); texture->rect = Rect2D(0, 0, (float) image->w/(float) texture_w, (float) image->h/(float) texture_h); /* texture->rect = Rect2D(0, 0, 1., 1.); */ texture->width = image->w; texture->height = image->h; SDL_FreeSurface(image); SDL_FreeSurface(convert); if (int a = glGetError() != 0) { LOGD("[Lincity]TextureManagerGL::create() ERROR OCCURED : %d\n",a); switch (a) { case GL_INVALID_ENUM: LOGD("[Lincity]TextureManagerGL::create() GL_INVALID_ENUM\n"); break; case GL_INVALID_VALUE: LOGD("[Lincity]TextureManagerGL::create() GL_INVALID_VALUE\n"); break; case GL_INVALID_OPERATION: LOGD("[Lincity]TextureManagerGL::create() GL_INVALID_OPERATION\n"); break; case GL_STACK_OVERFLOW: LOGD("[Lincity]TextureManagerGL::create() GL_STACK_OVERFLOW\n");; break; case GL_STACK_UNDERFLOW: LOGD("[Lincity]TextureManagerGL::create() GL_STACK_UNDERFLOW\n"); break; case GL_OUT_OF_MEMORY: LOGD("[Lincity]TextureManagerGL::create() GL_OUT_OF_MEMORY\n"); break; } } return texture; }
static void init_opengl() { { glGenBuffers( 1, &posVbo ); glBindBuffer( GL_ARRAY_BUFFER, posVbo ); glBufferData( GL_ARRAY_BUFFER, 256 * 256 * 2, NULL, GL_STATIC_DRAW ); GLubyte * row = new GLubyte[256 * 2]; for( int j = 0 ; j < 256; j++ ) { GLubyte y = j; for( int i = 0; i < 256; i++ ) { GLubyte x = i; row[ i * 2 + 0 ] = x; row[ i * 2 + 1 ] = y; } glBufferSubData( GL_ARRAY_BUFFER, j * 256 * 2, 256 * 2, row ); } delete [] row; } { // init color vbo with random data glGenBuffers( 1, &colVbo ); glBindBuffer( GL_ARRAY_BUFFER, colVbo ); glBufferData( GL_ARRAY_BUFFER, sizeof(bufdata), NULL, GL_DYNAMIC_DRAW ); GLubyte col[1024]; for( int j = 0; j < sizeof( bufdata ) / sizeof( col ); j++ ) { for( int i = 0; i < 1024; i++ ) { col[ i ] = GLubyte( rand() ); } glBufferSubData( GL_ARRAY_BUFFER, j * sizeof( col ), sizeof( col ), col ); } } glBindBuffer( GL_ARRAY_BUFFER, 0 ); GLuint vs = glCreateShader( GL_VERTEX_SHADER ); { char vshader[] = "attribute vec4 pos;\n" "attribute vec4 col;\n" "varying vec4 ocol;\n" "\n" "void main() {\n" " // step 1: scale normalized to integer [0,255]\n" " // step 2: scale / bias s.t. lower left corner of lower left pixel is [0,0]\n" " // and upper right corner of upper right pixel is [512,512]\n" " // and odd integers are at pixel centers\n" " // step 3: bias so screen corners are at [-256,-256] and [256,256]\n" " // step 4: scale so screen corners are [-1,-1] and [1,1]\n" " // vec2 p = ( pos.xy * 255.0 * 2.0 + 1.0 - 256.0 ) / 256.0;\n" " //\n" " // Or reducing steps 1-4 into a single MAD\n" " vec2 p = pos.xy * (255.0/128.0) - (255.0/256.0);\n" " gl_Position = vec4( p.x, p.y, 0.0, 1.0 );\n" " ocol = col;\n" "}\n"; char *vshader_list[] = { vshader, NULL }; int vshader_list_sizes[] = { sizeof( vshader ), 0 }; glShaderSource( vs, 1, vshader_list, vshader_list_sizes ); glCompileShader( vs ); char dbgLog[1<<15]; int dbgLogLen = 0; glGetShaderInfoLog( vs, (1<<15) - 2, &dbgLogLen, dbgLog ); dbgLog[ dbgLogLen ] = 0; printf( "%s\n", dbgLog ); } GLuint fs = glCreateShader( GL_FRAGMENT_SHADER ); { char fshader[] = "varying vec4 ocol;\n" "\n" "void main() {\n" " gl_FragColor = ocol;\n" "}\n"; char *fshader_list[] = { fshader, NULL }; int fshader_list_sizes[] = { sizeof( fshader ), 0 }; glShaderSource( fs, 1, fshader_list, fshader_list_sizes ); glCompileShader( fs ); char dbgLog[1<<15]; int dbgLogLen = 0; glGetShaderInfoLog( fs, (1<<15) - 2, &dbgLogLen, dbgLog ); dbgLog[ dbgLogLen ] = 0; printf( "%s\n", dbgLog ); } prog = glCreateProgram(); glAttachShader( prog, vs ); glAttachShader( prog, fs ); glLinkProgram( prog ); { char dbgLog[1<<15]; int dbgLogLen = 0; glGetProgramInfoLog( prog, (1<<15) - 2, &dbgLogLen, dbgLog ); dbgLog[ dbgLogLen ] = 0; printf( "%s\n", dbgLog ); } glBindAttribLocation( prog, 0, "pos" ); glBindAttribLocation( prog, 1, "col" ); glLinkProgram( prog ); { char dbgLog[1<<15]; int dbgLogLen = 0; glGetProgramInfoLog( prog, (1<<15) - 2, &dbgLogLen, dbgLog ); dbgLog[ dbgLogLen ] = 0; printf( "%s\n", dbgLog ); } glBindTexture( GL_TEXTURE_2D, fbotex ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, fbotex_sz, fbotex_sz, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glGenFramebuffers( 1, &fbo ); glBindFramebuffer( GL_FRAMEBUFFER, fbo ); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbotex, 0 ); GLenum fbostatus = glCheckFramebufferStatus( GL_FRAMEBUFFER ); printf( "framebuffer %s\n", fbostatus == GL_FRAMEBUFFER_COMPLETE ? "complete" : "incomplete" ); glBindFramebuffer( GL_FRAMEBUFFER, 0 ); }
GLUSboolean init(GLUSvoid) { GLfloat* points = (GLfloat*) malloc(WATER_PLANE_LENGTH * WATER_PLANE_LENGTH * 4 * sizeof(GLfloat)); GLuint* indices = (GLuint*) malloc(WATER_PLANE_LENGTH * (WATER_PLANE_LENGTH - 1) * 2 * sizeof(GLuint)); GLUStgaimage image; GLUStextfile vertexSource; GLUStextfile fragmentSource; GLuint x, z, i, k; GLuint waterTexture; for (z = 0; z < WATER_PLANE_LENGTH; z++) { for (x = 0; x < WATER_PLANE_LENGTH; x++) { points[(x + z * (WATER_PLANE_LENGTH)) * 4 + 0] = -(GLfloat) WATER_PLANE_LENGTH / 2 + 0.5f + (GLfloat) x; points[(x + z * (WATER_PLANE_LENGTH)) * 4 + 1] = 0.0f; points[(x + z * (WATER_PLANE_LENGTH)) * 4 + 2] = +(GLfloat) WATER_PLANE_LENGTH / 2 - 0.5f - (GLfloat) z; points[(x + z * (WATER_PLANE_LENGTH)) * 4 + 3] = 1.0f; } } for (k = 0; k < WATER_PLANE_LENGTH - 1; k++) { for (i = 0; i < WATER_PLANE_LENGTH; i++) { if (k % 2 == 0) { indices[(i + k * (WATER_PLANE_LENGTH)) * 2 + 0] = i + (k + 1) * WATER_PLANE_LENGTH; indices[(i + k * (WATER_PLANE_LENGTH)) * 2 + 1] = i + k * WATER_PLANE_LENGTH; } else { indices[(i + k * (WATER_PLANE_LENGTH)) * 2 + 0] = WATER_PLANE_LENGTH - 1 - i + k * WATER_PLANE_LENGTH; indices[(i + k * (WATER_PLANE_LENGTH)) * 2 + 1] = WATER_PLANE_LENGTH - 1 - i + (k + 1) * WATER_PLANE_LENGTH; } } } // glusFileLoadText("../Example15_ES/shader/Water.vert.glsl", &vertexSource); glusFileLoadText("../Example15_ES/shader/Water.frag.glsl", &fragmentSource); glusProgramBuildFromSource(&g_program, (const GLUSchar**) &vertexSource.text, (const GLUSchar**) &fragmentSource.text); glusFileDestroyText(&vertexSource); glusFileDestroyText(&fragmentSource); // g_projectionMatrixLocation = glGetUniformLocation(g_program.program, "u_projectionMatrix"); g_viewMatrixLocation = glGetUniformLocation(g_program.program, "u_viewMatrix"); g_inverseViewNormalMatrixLocation = glGetUniformLocation(g_program.program, "u_inverseViewNormalMatrix"); g_waterPlaneLengthLocation = glGetUniformLocation(g_program.program, "u_waterPlaneLength"); g_cubemapLocation = glGetUniformLocation(g_program.program, "u_cubemap"); g_waterTextureLocation = glGetUniformLocation(g_program.program, "u_waterTexture"); g_passedTimeLocation = glGetUniformLocation(g_program.program, "u_passedTime"); g_waveParametersLocation = glGetUniformLocation(g_program.program, "u_waveParameters"); g_waveDirectionsLocation = glGetUniformLocation(g_program.program, "u_waveDirections"); g_vertexLocation = glGetAttribLocation(g_program.program, "a_vertex"); // glGenBuffers(1, &g_verticesVBO); glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO); glBufferData(GL_ARRAY_BUFFER, WATER_PLANE_LENGTH * WATER_PLANE_LENGTH * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenBuffers(1, &g_indicesVBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, WATER_PLANE_LENGTH * (WATER_PLANE_LENGTH - 1) * 2 * sizeof(GLuint), (GLuint*) indices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // free(points); free(indices); // glGenTextures(1, &g_cubemap); glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap); glusImageLoadTga("water_pos_x.tga", &image); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusImageDestroyTga(&image); glusImageLoadTga("water_neg_x.tga", &image); glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusImageDestroyTga(&image); glusImageLoadTga("water_pos_y.tga", &image); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusImageDestroyTga(&image); glusImageLoadTga("water_neg_y.tga", &image); glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusImageDestroyTga(&image); glusImageLoadTga("water_pos_z.tga", &image); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusImageDestroyTga(&image); glusImageLoadTga("water_neg_z.tga", &image); glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusImageDestroyTga(&image); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glBindTexture(GL_TEXTURE_CUBE_MAP, 0); // waterTexture = initWaterTexture((GLUSfloat) WATER_PLANE_LENGTH); glUseProgram(g_program.program); glUniform1f(g_waterPlaneLengthLocation, (GLUSfloat) WATER_PLANE_LENGTH); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap); glUniform1i(g_cubemapLocation, 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, waterTexture); glUniform1i(g_waterTextureLocation, 1); glGenVertexArrays(1, &g_vao); glBindVertexArray(g_vao); glBindBuffer(GL_ARRAY_BUFFER, g_verticesVBO); glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(g_vertexLocation); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indicesVBO); // initBackground(); // glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepthf(1.0f); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); return GLUS_TRUE; }
//加载图片 //以RGBA格式存储图片 static bool LoadImg(const char* fname,GLint nID) { //初始化FreeImage FreeImage_Initialise(TRUE); //定义图片格式为未知 FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; //获取图片格式 fif = FreeImage_GetFileType(fname,0); //根据获取格式读取图片数据 FIBITMAP* bitmap = FreeImage_Load(fif,fname,0); if(!bitmap) { printf("load error!\n"); return false; } int x,y; RGBQUAD m_rgb; //获取图片长宽 width = (int)FreeImage_GetWidth(bitmap); height = (int)FreeImage_GetHeight(bitmap); imgBuf = new unsigned char[width*height*4]; //获取图片数据 //按RGBA格式保存到数组中 for(y=0;y<height;y++) { for(x=0;x<width;x++) { //获取像素值 FreeImage_GetPixelColor(bitmap,x,y,&m_rgb); //将RGB值存入数组 imgBuf[y*width*4+x*4+0] = m_rgb.rgbRed; imgBuf[y*width*4+x*4+1] = m_rgb.rgbGreen; imgBuf[y*width*4+x*4+2] = m_rgb.rgbBlue; //判断是否透明图片 //如果是就取alpha值保存 if(FreeImage_IsTransparent(bitmap)) imgBuf[y*width*4+x*4+3] = m_rgb.rgbReserved; else imgBuf[y*width*4+x*4+3] = 255; } } //绑定纹理ID if(nID==0) { glGenTextures(1, &g_texture1); glBindTexture(GL_TEXTURE_2D, g_texture1); } else { glGenTextures(1, &g_texture2); glBindTexture(GL_TEXTURE_2D, g_texture2); } glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, imgBuf); //释放FreeImage delete imgBuf; FreeImage_Unload(bitmap); return true; }
void GLES2TextureBuffer::buildMipmaps(const PixelBox &data) { int width; int height; int logW; int logH; int level; PixelBox scaled = data; scaled.data = data.data; scaled.left = data.left; scaled.right = data.right; scaled.top = data.top; scaled.bottom = data.bottom; scaled.front = data.front; scaled.back = data.back; width = data.getWidth(); height = data.getHeight(); logW = computeLog(width); logH = computeLog(height); level = (logW > logH ? logW : logH); for (int mip = 0; mip <= level; mip++) { GLenum glFormat = GLES2PixelUtil::getGLOriginFormat(scaled.format); GLenum dataType = GLES2PixelUtil::getGLOriginDataType(scaled.format); glTexImage2D(mFaceTarget, mip, glFormat, width, height, 0, glFormat, dataType, scaled.data); GL_CHECK_ERROR; if (mip != 0) { OGRE_DELETE[] (uint8*) scaled.data; scaled.data = 0; } if (width > 1) { width = width / 2; } if (height > 1) { height = height / 2; } int sizeInBytes = PixelUtil::getMemorySize(width, height, 1, data.format); scaled = PixelBox(width, height, 1, data.format); scaled.data = new uint8[sizeInBytes]; Image::scale(data, scaled, Image::FILTER_LINEAR); }
//----------------------------------------------------------------------------- // Very fast texture-to-texture blitter and hardware bi/trilinear scaling implementation using FBO // Destination texture must be 1D, 2D, 3D, or Cube // Source texture must be 1D, 2D or 3D // Supports compressed formats as both source and destination format, it will use the hardware DXT compressor // if available. // @author W.J. van der Laan void GLES2TextureBuffer::blitFromTexture(GLES2TextureBuffer *src, const Image::Box &srcBox, const Image::Box &dstBox) { return; // todo - add a shader attach... // std::cerr << "GLES2TextureBuffer::blitFromTexture " << // src->mTextureID << ":" << srcBox.left << "," << srcBox.top << "," << srcBox.right << "," << srcBox.bottom << " " << // mTextureID << ":" << dstBox.left << "," << dstBox.top << "," << dstBox.right << "," << dstBox.bottom << std::endl; // Store reference to FBO manager GLES2FBOManager *fboMan = static_cast<GLES2FBOManager *>(GLES2RTTManager::getSingletonPtr()); RenderSystem* rsys = Root::getSingleton().getRenderSystem(); rsys->_disableTextureUnitsFrom(0); glActiveTexture(GL_TEXTURE0); // Disable alpha, depth and scissor testing, disable blending, // and disable culling glDisable(GL_DEPTH_TEST); glDisable(GL_SCISSOR_TEST); glDisable(GL_BLEND); glDisable(GL_CULL_FACE); // Set up source texture glBindTexture(src->mTarget, src->mTextureID); GL_CHECK_ERROR; // Set filtering modes depending on the dimensions and source if(srcBox.getWidth()==dstBox.getWidth() && srcBox.getHeight()==dstBox.getHeight() && srcBox.getDepth()==dstBox.getDepth()) { // Dimensions match -- use nearest filtering (fastest and pixel correct) glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST); GL_CHECK_ERROR; glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST); GL_CHECK_ERROR; } else { // Dimensions don't match -- use bi or trilinear filtering depending on the // source texture. if(src->mUsage & TU_AUTOMIPMAP) { // Automatic mipmaps, we can safely use trilinear filter which // brings greatly improved quality for minimisation. glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); GL_CHECK_ERROR; glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR); GL_CHECK_ERROR; } else { // Manual mipmaps, stay safe with bilinear filtering so that no // intermipmap leakage occurs. glTexParameteri(src->mTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR); GL_CHECK_ERROR; glTexParameteri(src->mTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR); GL_CHECK_ERROR; } } // Clamp to edge (fastest) glTexParameteri(src->mTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); GL_CHECK_ERROR; glTexParameteri(src->mTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); GL_CHECK_ERROR; // Store old binding so it can be restored later GLint oldfb; glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldfb); GL_CHECK_ERROR; // Set up temporary FBO glBindFramebuffer(GL_FRAMEBUFFER, fboMan->getTemporaryFBO()); GL_CHECK_ERROR; GLuint tempTex = 0; if(!fboMan->checkFormat(mFormat)) { // If target format not directly supported, create intermediate texture GLenum tempFormat = GLES2PixelUtil::getClosestGLInternalFormat(fboMan->getSupportedAlternative(mFormat)); glGenTextures(1, &tempTex); GL_CHECK_ERROR; glBindTexture(GL_TEXTURE_2D, tempTex); GL_CHECK_ERROR; #if GL_APPLE_texture_max_level glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL_APPLE, 0); GL_CHECK_ERROR; #endif // Allocate temporary texture of the size of the destination area glTexImage2D(GL_TEXTURE_2D, 0, tempFormat, GLES2PixelUtil::optionalPO2(dstBox.getWidth()), GLES2PixelUtil::optionalPO2(dstBox.getHeight()), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); GL_CHECK_ERROR; glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tempTex, 0); GL_CHECK_ERROR; // Set viewport to size of destination slice glViewport(0, 0, dstBox.getWidth(), dstBox.getHeight()); GL_CHECK_ERROR; } else { // We are going to bind directly, so set viewport to size and position of destination slice glViewport(dstBox.left, dstBox.top, dstBox.getWidth(), dstBox.getHeight()); GL_CHECK_ERROR; } // Process each destination slice for(size_t slice=dstBox.front; slice<dstBox.back; ++slice) { if(!tempTex) { // Bind directly bindToFramebuffer(GL_COLOR_ATTACHMENT0, slice); } /// Calculate source texture coordinates float u1 = (float)srcBox.left / (float)src->mWidth; float v1 = (float)srcBox.top / (float)src->mHeight; float u2 = (float)srcBox.right / (float)src->mWidth; float v2 = (float)srcBox.bottom / (float)src->mHeight; /// Calculate source slice for this destination slice float w = (float)(slice - dstBox.front) / (float)dstBox.getDepth(); /// Get slice # in source w = w * (float)srcBox.getDepth() + srcBox.front; /// Normalise to texture coordinate in 0.0 .. 1.0 w = (w+0.5f) / (float)src->mDepth; /// Finally we're ready to rumble glBindTexture(src->mTarget, src->mTextureID); GL_CHECK_ERROR; glEnable(src->mTarget); GL_CHECK_ERROR; GLfloat squareVertices[] = { -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f, }; GLfloat texCoords[] = { u1, v1, w, u2, v1, w, u2, v2, w, u1, v2, w }; GLuint posAttrIndex = 0; GLuint texAttrIndex = 0; if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS)) { GLSLESProgramPipeline* programPipeline = GLSLESProgramPipelineManager::getSingleton().getActiveProgramPipeline(); posAttrIndex = (GLuint)programPipeline->getAttributeIndex(VES_POSITION, 0); texAttrIndex = (GLuint)programPipeline->getAttributeIndex(VES_TEXTURE_COORDINATES, 0); } else { GLSLESLinkProgram* linkProgram = GLSLESLinkProgramManager::getSingleton().getActiveLinkProgram(); posAttrIndex = (GLuint)linkProgram->getAttributeIndex(VES_POSITION, 0); texAttrIndex = (GLuint)linkProgram->getAttributeIndex(VES_TEXTURE_COORDINATES, 0); } // Draw the textured quad glVertexAttribPointer(posAttrIndex, 2, GL_FLOAT, 0, 0, squareVertices); GL_CHECK_ERROR; glEnableVertexAttribArray(posAttrIndex); GL_CHECK_ERROR; glVertexAttribPointer(texAttrIndex, 3, GL_FLOAT, 0, 0, texCoords); GL_CHECK_ERROR; glEnableVertexAttribArray(texAttrIndex); GL_CHECK_ERROR; glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); GL_CHECK_ERROR; glDisable(src->mTarget); GL_CHECK_ERROR; if(tempTex) { // Copy temporary texture glBindTexture(mTarget, mTextureID); GL_CHECK_ERROR; switch(mTarget) { case GL_TEXTURE_2D: case GL_TEXTURE_CUBE_MAP: glCopyTexSubImage2D(mFaceTarget, mLevel, dstBox.left, dstBox.top, 0, 0, dstBox.getWidth(), dstBox.getHeight()); GL_CHECK_ERROR; break; } } } // Finish up if(!tempTex) { // Generate mipmaps if(mUsage & TU_AUTOMIPMAP) { glBindTexture(mTarget, mTextureID); GL_CHECK_ERROR; glGenerateMipmap(mTarget); GL_CHECK_ERROR; } } // Reset source texture to sane state glBindTexture(src->mTarget, src->mTextureID); GL_CHECK_ERROR; // Detach texture from temporary framebuffer glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0); GL_CHECK_ERROR; // Restore old framebuffer glBindFramebuffer(GL_FRAMEBUFFER, oldfb); GL_CHECK_ERROR; glDeleteTextures(1, &tempTex); GL_CHECK_ERROR; }
GLTextureCube::GLTextureCube(uint16 width, uint16 height, PixelFormat format, uint8 mips) { mRenderData = RenderDataPtr(new RenderData); mRenderData->texHandle = 0; mTexData.width = width; mTexData.height = height; if (mips == 0) { uint32 m = 1; uint32 s = mTexData.width > mTexData.height ? mTexData.width : mTexData.height; while (s > 1) { s /= 2; m++; } mTexData.mipLevels = m; } else { mTexData.mipLevels = mips; } mTexData.pixelFormat = format; mIsLocked = false; ENQUEUE_RENDER_COMMAND_2PARAMS(GLTexture2D, RenderDataPtr, mRenderData, mRenderData, TexData, mTexData, mTexData, { if (!mRenderData->texHandle) { GLenum internalFormat; GLenum lockFormat; GLenum lockType; GLTexture::_pixelFormatParams(mTexData.pixelFormat, internalFormat, lockFormat, lockType); glGenTextures(1, &mRenderData->texHandle); Main::getRenderSystem()._rtBindTextureCube(mRenderData->texHandle, 0); for (int i = 0; i < 6; i++) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internalFormat, mTexData.width, mTexData.height, 0, lockFormat, lockType, nullptr); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, mTexData.mipLevels - 1); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT); if (mTexData.mipLevels > 1) { glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glGenerateMipmap(GL_TEXTURE_CUBE_MAP); } } });
void CreateBuffers(int screen_width, int screen_height) { width = screen_width; height = screen_height; glGenFramebuffersEXT(1, &halfsizeFb); glGenTextures(1, &halfsizeTex); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, halfsizeFb); glBindTexture(GL_TEXTURE_RECTANGLE_ARB, halfsizeTex); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB16F_ARB, width>>1, height>>1, 0, GL_RGB, GL_HALF_FLOAT_ARB, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, halfsizeTex, 0); if (!CheckFBO()) { DeleteBuffers(); return; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glGenFramebuffersEXT(1, &luminanceFb); glGenTextures(1, &luminanceTex); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, luminanceFb); glBindTexture(GL_TEXTURE_2D, luminanceTex); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F_ARB, 128, 128, 0, GL_RGB, GL_FLOAT, NULL); glGenerateMipmapEXT(GL_TEXTURE_2D); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, luminanceTex, 0); if (!CheckFBO()) { DeleteBuffers(); return; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glError(); glGenFramebuffersEXT(1, &bloomFb1); glGenTextures(1, &bloomTex1); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, bloomFb1); glBindTexture(GL_TEXTURE_RECTANGLE_ARB, bloomTex1); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB16F_ARB, width>>2, height>>2, 0, GL_RGB, GL_HALF_FLOAT_ARB, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, bloomTex1, 0); if (!CheckFBO()) { DeleteBuffers(); return; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glGenFramebuffersEXT(1, &bloomFb2); glGenTextures(1, &bloomTex2); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, bloomFb2); glBindTexture(GL_TEXTURE_RECTANGLE_ARB, bloomTex2); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB16F_ARB, width>>2, height>>2, 0, GL_RGB, GL_HALF_FLOAT_ARB, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, bloomTex2, 0); if (!CheckFBO()) { DeleteBuffers(); return; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glGenFramebuffersEXT(1, &fb); glGenTextures(1, &tex); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB16F_ARB, width, height, 0, GL_RGB, GL_HALF_FLOAT_ARB, NULL); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, tex, 0); glError(); glGenRenderbuffersEXT(1, &depthbuffer); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthbuffer); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuffer); glError(); if (!CheckFBO()) { DeleteBuffers(); return; } postprocessBloom1Downsample = new PostprocessDownsampleShader("postprocessBloom1Downsample", "#extension GL_ARB_texture_rectangle : enable\n"); postprocessBloom2Downsample = new PostprocessShader("postprocessBloom2Downsample", "#extension GL_ARB_texture_rectangle : enable\n"); postprocessBloom3VBlur = new PostprocessShader("postprocessBloom3VBlur"); postprocessBloom4HBlur = new PostprocessShader("postprocessBloom4HBlur"); postprocessCompose = new PostprocessComposeShader("postprocessCompose", "#extension GL_ARB_texture_rectangle : enable\n"); postprocessLuminance = new PostprocessShader("postprocessLuminance", "#extension GL_ARB_texture_rectangle : enable\n"); glError(); }
//---------------------------------------------------------------------- // Draw the cover //---------------------------------------------------------------------- void C_Cover::Draw() { if (0 == vOfs) return; glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,txd.wd,txd.ht,0,GL_RGBA,GL_UNSIGNED_BYTE,txd.rgba); glDrawArrays(GL_TRIANGLE_STRIP,vOfs,4); return; }
/** Creates new pbuffers */ RenderTarget::RenderTarget(int texsize, int width, int height, bool use_fbo) : useFBO(use_fbo) { int mindim = 0; int origtexsize = 0; this->renderToTexture = 0; this->useFBO = use_fbo; this->texsize = texsize; #ifdef USE_FBO if(this->useFBO) { //glewInit(); if(glewIsSupported("GL_EXT_framebuffer_object")) { GLuint fb, depth_rb, rgba_tex, other_tex; glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fb ); glGenRenderbuffersEXT(1, &depth_rb); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, depth_rb ); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, this->texsize,this->texsize ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb ); this->fbuffer[0] = fb; this->depthb[0]= depth_rb; glGenTextures(1, &other_tex); glBindTexture(GL_TEXTURE_2D,other_tex); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, texsize, texsize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL ); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //glGenerateMipmapEXT(GL_TEXTURE_2D); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glGenTextures(1, &rgba_tex); glBindTexture(GL_TEXTURE_2D, rgba_tex); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, texsize, texsize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //glGenerateMipmapEXT(GL_TEXTURE_2D); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, rgba_tex, 0 ); this->textureID[0] = rgba_tex; this->textureID[1] = other_tex; GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status == GL_FRAMEBUFFER_COMPLETE_EXT) { this->renderToTexture = 1; return; } } } this->useFBO=false; #else this->useFBO=false; #endif /** Fallback pbuf;fer creation via teximage hack */ /** Check the texture size against the viewport size */ /** If the viewport is smaller, then we'll need to scale the texture size down */ /** If the viewport is larger, scale it up */ mindim = width < height ? width : height; origtexsize = this->texsize; this->texsize = nearestPower2( mindim, SCALE_MINIFY ); this->texsize = origtexsize; // ^-- ok, texsize is just ignored with this glGenTextures(1, &this->textureID[0] ); glBindTexture(GL_TEXTURE_2D, this->textureID[0] ); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, this->texsize, this->texsize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); return; }
void Mandlebrot::init(void) { // Create and compile our GLSL program from the shaders init_prog = LoadShaders("/home/steve/fractals/fractals/second_mandlebrot/passthrough.vert", "/home/steve/fractals/fractals/second_mandlebrot/init.frag"); if (!init_prog) exit(-1); kern_prog = LoadShaders("/home/steve/fractals/fractals/second_mandlebrot/passthrough.vert", "/home/steve/fractals/fractals/second_mandlebrot/mand_kern.frag"); if (!kern_prog) exit(-1); show_prog = LoadShaders("/home/steve/fractals/fractals/second_mandlebrot/passthrough.vert", "/home/steve/fractals/fractals/second_mandlebrot/mand_show.frag"); if (!show_prog) exit(-1); // Make a square. glGenVertexArrays(1, &handles["init_VAO"]); glBindVertexArray(handles["init_VAO"]); glGenBuffers(1, &handles["init_VBO"]); glBindBuffer(GL_ARRAY_BUFFER, handles["init_VBO"]); glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(0); glGenBuffers(1, &handles["init_uv_VBO"]); glBindBuffer(GL_ARRAY_BUFFER, handles["init_uv_VBO"]); glBufferData(GL_ARRAY_BUFFER, sizeof(g_textcoords), g_textcoords, GL_DYNAMIC_DRAW); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(1); glBindVertexArray(0); // glDeleteBuffers(1, &handles["init_VBO"]); // glDeleteBuffers(1, &handles["init_uv_VBO"]); glGenVertexArrays(1, &handles["kern_VAO"]); glBindVertexArray(handles["kern_VAO"]); glGenBuffers(1, &handles["kern_VBO"]); glBindBuffer(GL_ARRAY_BUFFER, handles["kern_VBO"]); glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(0); glGenBuffers(1, &handles["kern_uv_VBO"]); glBindBuffer(GL_ARRAY_BUFFER, handles["kern_uv_VBO"]); glBufferData(GL_ARRAY_BUFFER, sizeof(g_textcoords), g_textcoords, GL_DYNAMIC_DRAW); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(1); glBindVertexArray(0); // glDeleteBuffers(1, &handles["kern_VBO"]); // glDeleteBuffers(1, &handles["kern_uv_VBO"]); // Create a 1-d texture to use as a color palette. const GLubyte g_colors[][4] = {{0xff, 0x88, 0, 0xff}, {0x88, 0xcc, 0x22, 0xff}, {0x00, 0xff, 0x44, 0xff}, {0x88, 0xcc, 0x66, 0xff}, {0xff, 0x88, 0x88, 0xff}, {0x88, 0x44, 0xaa, 0xff}, {0xff, 0x00, 0xcc, 0xff}, {0x88, 0x44, 0xff, 0xff}, {0x00, 0x88, 0xcc, 0xff}, {0x88, 0xcc, 0xaa, 0xff}, {0xff, 0xff, 0x88, 0xff}, {0x88, 0xcc, 0x66, 0xff}, {0x00, 0x88, 0x44, 0xff}}; glGenTextures(1, &handles["colors"]); glBindTexture(GL_TEXTURE_1D, handles["colors"]); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 12, 0, GL_RGBA, GL_UNSIGNED_BYTE, g_colors); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); handles["aspect_ratio"] = glGetUniformLocationARB(init_prog, "aspect"); handles["scale"] = glGetUniformLocation(init_prog, "scale"); handles["center"] = glGetUniformLocationARB(init_prog, "center"); handles["in_c_loc"] = glGetUniformLocation(kern_prog, "in_c"); handles["in_z_loc"] = glGetUniformLocation(kern_prog, "in_z"); handles["iters2do_loc"] = glGetUniformLocation(kern_prog, "iters_to_do"); handles["colors_loc"] = glGetUniformLocation(show_prog, "colors"); handles["iter_loc"] = glGetUniformLocationARB(show_prog, "iter"); handles["loc_loc"] = glGetUniformLocation(show_prog, "location"); glBindBuffer(GL_ARRAY_BUFFER, 0); // generate a framebuffer to render to glGenFramebuffers(1, &handles["fbo_init"]); glBindFramebuffer(GL_FRAMEBUFFER, handles["fbo_init"]); glGenTextures(1, &handles["tex_init"]); glBindTexture(GL_TEXTURE_2D, handles["tex_init"]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RG32F, 1024, 768, 0, GL_RG, GL_UNSIGNED_BYTE, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, handles["tex_init"], 0); // Always check that our framebuffer is ok if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { std::cout << "framebuffer was not properly initialized. \n"; exit(1); } // Set the list of draw buffers. glGenFramebuffers(1, &handles["fbo_kern"]); glBindFramebuffer(GL_FRAMEBUFFER, handles["fbo_kern"]); glGenTextures(1, &handles["tex_kern1"]); glBindTexture(GL_TEXTURE_2D, handles["tex_kern1"]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 1024, 768, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, handles["tex_kern1"], 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); print_handles(handles); }
//Initialises all things post process! bool Renderer::InitPostProcess(){ toDrawTo = 0; sobel = false; sobelDepth = false; quantizeCol = false; dubVis = false; blur = false; bloom = false; fog = false; //Load in all of our post processing shaders blurShader = new Shader(SHADERDIR"TexturedVertex.glsl", SHADERDIR"blurFrag.glsl"); doubVisShader = new Shader(SHADERDIR"TexturedVertex.glsl", SHADERDIR"doubleVisionFrag.glsl"); sobelShader = new Shader(SHADERDIR"TexturedVertex.glsl", SHADERDIR"sobelFrag.glsl"); sobelDepthShader = new Shader(SHADERDIR"TexturedVertex.glsl", SHADERDIR"sobelDepthFrag.glsl"); quantizeColShader = new Shader(SHADERDIR"TexturedVertex.glsl", SHADERDIR"quantizeFrag.glsl"); fogShader = new Shader(SHADERDIR"TexturedVertex.glsl", SHADERDIR"fogFrag.glsl"); bloomShader = new Shader(SHADERDIR"TexturedVertex.glsl", SHADERDIR"bloomFrag.glsl"); if (!blurShader->LinkProgram() || !sobelDepthShader->LinkProgram() || !quantizeColShader->LinkProgram() || !sobelShader->LinkProgram() || !fogShader->LinkProgram() || !doubVisShader->LinkProgram() || !bloomShader->LinkProgram()) return false; //Generate our frame buffers glGenTextures(1, &bufferDepthTex); glBindTexture(GL_TEXTURE_2D, bufferDepthTex); //Set the texture to clamp on both axis, and use no filtering glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); //And our colour textures for (int i=0; i<2; ++i){ //Generate and bind our texture glGenTextures(1, &bufferColourTex[i]); glBindTexture(GL_TEXTURE_2D, bufferColourTex[i]); //Turn off filtering and have them clamped glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); //Set the format of the texture to be 8 bits per channel of RGBA glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); } //Generate our frame buffers glGenFramebuffers(1, &bufferFBO); // We render the scene into this glGenFramebuffers(1, &processFBO); //And do post processing in this glBindFramebuffer(GL_FRAMEBUFFER, bufferFBO); //Bind our bufferFBO object glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, bufferDepthTex, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, bufferColourTex[0], 0); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE || !bufferDepthTex || !bufferColourTex[0]){ return false; } //Unbind and enable depth testing glBindFramebuffer(GL_FRAMEBUFFER, 0); quad = Mesh::GenerateQuad(); return true; }
void QGLFramebufferObjectPrivate::init(QGLFramebufferObject *q, const QSize &sz, QGLFramebufferObject::Attachment attachment, GLenum texture_target, GLenum internal_format, GLint samples, bool mipmap) { QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext()); fbo_guard.setContext(ctx); bool ext_detected = (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject); if (!ext_detected || (ext_detected && !qt_resolve_framebufferobject_extensions(ctx))) return; size = sz; target = texture_target; // texture dimensions QT_RESET_GLERROR(); // reset error state GLuint fbo = 0; glGenFramebuffers(1, &fbo); glBindFramebuffer(GL_FRAMEBUFFER_EXT, fbo); fbo_guard.setId(fbo); glDevice.setFBO(q, attachment); QT_CHECK_GLERROR(); // init texture if (samples == 0) { glGenTextures(1, &texture); glBindTexture(target, texture); glTexImage2D(target, 0, internal_format, size.width(), size.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); if (mipmap) glGenerateMipmap(GL_TEXTURE_2D); #ifndef QT_OPENGL_ES glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); #else glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); #endif glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, texture, 0); QT_CHECK_GLERROR(); valid = checkFramebufferStatus(); glBindTexture(target, 0); color_buffer = 0; } else { mipmap = false; GLint maxSamples; glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSamples); samples = qBound(0, int(samples), int(maxSamples)); glGenRenderbuffers(1, &color_buffer); glBindRenderbuffer(GL_RENDERBUFFER_EXT, color_buffer); if (glRenderbufferStorageMultisampleEXT && samples > 0) { glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, internal_format, size.width(), size.height()); } else { samples = 0; glRenderbufferStorage(GL_RENDERBUFFER_EXT, internal_format, size.width(), size.height()); } glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, color_buffer); QT_CHECK_GLERROR(); valid = checkFramebufferStatus(); if (valid) glGetRenderbufferParameteriv(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_SAMPLES_EXT, &samples); } // In practice, a combined depth-stencil buffer is supported by all desktop platforms, while a // separate stencil buffer is not. On embedded devices however, a combined depth-stencil buffer // might not be supported while separate buffers are, according to QTBUG-12861. if (attachment == QGLFramebufferObject::CombinedDepthStencil && (QGLExtensions::glExtensions() & QGLExtensions::PackedDepthStencil)) { // depth and stencil buffer needs another extension glGenRenderbuffers(1, &depth_buffer); Q_ASSERT(!glIsRenderbuffer(depth_buffer)); glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth_buffer); Q_ASSERT(glIsRenderbuffer(depth_buffer)); if (samples != 0 && glRenderbufferStorageMultisampleEXT) glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_DEPTH24_STENCIL8_EXT, size.width(), size.height()); else glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, size.width(), size.height()); stencil_buffer = depth_buffer; glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_buffer); glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, stencil_buffer); valid = checkFramebufferStatus(); if (!valid) { glDeleteRenderbuffers(1, &depth_buffer); stencil_buffer = depth_buffer = 0; } } if (depth_buffer == 0 && (attachment == QGLFramebufferObject::CombinedDepthStencil || (attachment == QGLFramebufferObject::Depth))) { glGenRenderbuffers(1, &depth_buffer); Q_ASSERT(!glIsRenderbuffer(depth_buffer)); glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth_buffer); Q_ASSERT(glIsRenderbuffer(depth_buffer)); if (samples != 0 && glRenderbufferStorageMultisampleEXT) { #ifdef QT_OPENGL_ES if (QGLExtensions::glExtensions() & QGLExtensions::Depth24) { glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_DEPTH_COMPONENT24_OES, size.width(), size.height()); } else { glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_DEPTH_COMPONENT16, size.width(), size.height()); } #else glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_DEPTH_COMPONENT, size.width(), size.height()); #endif } else { #ifdef QT_OPENGL_ES if (QGLExtensions::glExtensions() & QGLExtensions::Depth24) { glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24_OES, size.width(), size.height()); } else { glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16, size.width(), size.height()); } #else glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, size.width(), size.height()); #endif } glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_buffer); valid = checkFramebufferStatus(); if (!valid) { glDeleteRenderbuffers(1, &depth_buffer); depth_buffer = 0; } } if (stencil_buffer == 0 && (attachment == QGLFramebufferObject::CombinedDepthStencil)) { glGenRenderbuffers(1, &stencil_buffer); Q_ASSERT(!glIsRenderbuffer(stencil_buffer)); glBindRenderbuffer(GL_RENDERBUFFER_EXT, stencil_buffer); Q_ASSERT(glIsRenderbuffer(stencil_buffer)); if (samples != 0 && glRenderbufferStorageMultisampleEXT) { #ifdef QT_OPENGL_ES glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_STENCIL_INDEX8_EXT, size.width(), size.height()); #else glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples, GL_STENCIL_INDEX, size.width(), size.height()); #endif } else { #ifdef QT_OPENGL_ES glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX8_EXT, size.width(), size.height()); #else glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX, size.width(), size.height()); #endif } glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, stencil_buffer); valid = checkFramebufferStatus(); if (!valid) { glDeleteRenderbuffers(1, &stencil_buffer); stencil_buffer = 0; } } // The FBO might have become valid after removing the depth or stencil buffer. valid = checkFramebufferStatus(); if (depth_buffer && stencil_buffer) { fbo_attachment = QGLFramebufferObject::CombinedDepthStencil; } else if (depth_buffer) { fbo_attachment = QGLFramebufferObject::Depth; } else { fbo_attachment = QGLFramebufferObject::NoAttachment; } glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo); if (!valid) { if (color_buffer) glDeleteRenderbuffers(1, &color_buffer); else glDeleteTextures(1, &texture); if (depth_buffer) glDeleteRenderbuffers(1, &depth_buffer); if (stencil_buffer && depth_buffer != stencil_buffer) glDeleteRenderbuffers(1, &stencil_buffer); glDeleteFramebuffers(1, &fbo); fbo_guard.setId(0); } QT_CHECK_GLERROR(); format.setTextureTarget(target); format.setSamples(int(samples)); format.setAttachment(fbo_attachment); format.setInternalTextureFormat(internal_format); format.setMipmap(mipmap); }
void FaceCullingComponent::Initialize() { // Vertices defined in counter-clockwise winding order. mVertices = { // Back face -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, // Bottom-left 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-right 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, // bottom-right 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-right -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, // bottom-left -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, // top-left // Front face -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-left 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, // bottom-right 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, // top-right 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, // top-right -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, // top-left -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-left // Left face -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // top-right -0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-left -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // bottom-left -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // bottom-left -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-right -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // top-right // Right face 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // top-left 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // bottom-right 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-right 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // bottom-right 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // top-left 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-left // Bottom face -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // top-right 0.5f, -0.5f, -0.5f, 1.0f, 1.0f, // top-left 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, // bottom-left 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, // bottom-left -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-right -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // top-right // Top face -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, // top-left 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // bottom-right 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-right 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // bottom-right -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, // top-left -0.5f, 0.5f, 0.5f, 0.0f, 0.0f // bottom-left }; mCubePositions = { glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(2.0f, 5.0f, -15.0f), glm::vec3(-1.5f, -2.2f, -2.5f), glm::vec3(-3.8f, -2.0f, -12.3f), glm::vec3(2.4f, -0.4f, -3.5f), glm::vec3(-1.7f, 3.0f, -7.5f), glm::vec3(1.3f, -2.0f, -2.5f), glm::vec3(1.5f, 2.0f, -2.5f), glm::vec3(1.5f, 0.2f, -1.5f), glm::vec3(-1.3f, 1.0f, -1.5f) }; mPointLightPositions = { glm::vec3(0.7f, 0.2f, 2.0f), glm::vec3(2.3f, -3.3f, -4.0f), glm::vec3(-4.0f, 2.0f, -12.0f), glm::vec3(0.0f, 0.0f, -3.0f) }; //Generate VBOs and VAO. glGenVertexArrays(1, &mVAO); glGenBuffers(1, &mVBO); //Bind VAO and buffers, and fill in buffer data glBindVertexArray(mVAO); glBindBuffer(GL_ARRAY_BUFFER, mVBO); glBufferData(GL_ARRAY_BUFFER, mVertices.size() * sizeof(GLfloat), &mVertices[0], GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); int texWidth, texHeight; glActiveTexture(GL_TEXTURE0); glGenTextures(1, &mTextureDiffuse); glBindTexture(GL_TEXTURE_2D, mTextureDiffuse); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); unsigned char* diffuseMap = SOIL_load_image("res/diffuseMap.bmp", &texWidth, &texHeight, nullptr, SOIL_LOAD_AUTO); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, diffuseMap); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(diffuseMap); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE1); glGenTextures(1, &mTextureSpecular); glBindTexture(GL_TEXTURE_2D, mTextureSpecular); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); unsigned char* specularMap = SOIL_load_image("res/specularMap.bmp", &texWidth, &texHeight, nullptr, SOIL_LOAD_AUTO); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, specularMap); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(specularMap); glBindTexture(GL_TEXTURE_2D, 0); //Unbind glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); mShaderContainer = Shader("shaders/container.vert", "shaders/container.frag"); mShaderLight = Shader("shaders/light.vert", "shaders/light.frag"); }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { GLboolean pass = GL_TRUE; int x, y; GLuint tex, fb; float blue[] = {1, 0, 0, 0}; float green[] = {0, 1, 0, 0}; bool draw_green; float *draw_colors[] = {blue, green}; float w_screen = 2.0f * TEX_WIDTH / piglit_width; float h_screen = 2.0f * TEX_HEIGHT / piglit_height; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_WIDTH, TEX_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0); assert(glGetError() == 0); assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT); draw_green = true; for (y = 0; y <= piglit_height - TEX_HEIGHT; y += TEX_HEIGHT) { float y_screen = -1.0 + 2.0 * ((float)y / piglit_height); for (x = 0; x <= piglit_width - TEX_WIDTH; x += TEX_WIDTH) { float x_screen = -1.0 + 2.0 * ((float)x / piglit_width); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glDisable(GL_TEXTURE_2D); glColor4fv(draw_colors[draw_green]); piglit_draw_rect(-1, -1, 2, 2); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); glEnable(GL_TEXTURE_2D); piglit_draw_rect_tex(x_screen, y_screen, w_screen, h_screen, 0, 0, 1, 1); draw_green = !draw_green; } /* Make it a checkerboard. */ draw_green = !draw_green; } glDeleteFramebuffersEXT(1, &fb); glDeleteTextures(1, &tex); draw_green = true; for (y = 0; y <= piglit_height - TEX_HEIGHT; y += TEX_HEIGHT) { for (x = 0; x <= piglit_width - TEX_WIDTH; x += TEX_WIDTH) { float *expected = draw_colors[draw_green]; pass = pass && piglit_probe_rect_rgb(x, y, TEX_WIDTH, TEX_HEIGHT, expected); draw_green = !draw_green; } draw_green = !draw_green; } piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
/** * Do error-check tests for a non-mipmapped texture. */ static bool test_one_level_errors(GLenum target) { const GLint width = 64, height = 4, depth = 8; GLuint tex; GLint v; assert(target == GL_TEXTURE_1D || target == GL_TEXTURE_2D || target == GL_TEXTURE_3D); glCreateTextures(target, 1, &tex); glBindTextureUnit(0, tex); if (target == GL_TEXTURE_1D) { glTextureStorage1D(tex, 1, GL_RGBA8, width); } else if (target == GL_TEXTURE_2D) { glTextureStorage2D(tex, 1, GL_RGBA8, width, height); } else if (target == GL_TEXTURE_3D) { glTextureStorage3D(tex, 1, GL_RGBA8, width, height, depth); } piglit_check_gl_error(GL_NO_ERROR); glGetTextureLevelParameteriv(tex, 0, GL_TEXTURE_WIDTH, &v); if (v != width) { printf("%s: bad width: %d, should be %d\n", TestName, v, width); return false; } if (target != GL_TEXTURE_1D) { glGetTextureLevelParameteriv(tex, 0, GL_TEXTURE_HEIGHT, &v); if (v != height) { printf("%s: bad height: %d, should be %d\n", TestName, v, height); return false; } } if (target == GL_TEXTURE_3D) { glGetTextureLevelParameteriv(tex, 0, GL_TEXTURE_DEPTH, &v); if (v != depth) { printf("%s: bad depth: %d, should be %d\n", TestName, v, depth); return false; } } /* The ARB_texture_storage spec says: * * "Using any of the following commands with the same texture will * result in the error INVALID_OPERATION being generated, even if * it does not affect the dimensions or format: * * - TexImage* * - CompressedTexImage* * - CopyTexImage* * - TexStorage*" */ if (!piglit_khr_no_error && target == GL_TEXTURE_2D) { glTexImage2D(target, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); if (glGetError() != GL_INVALID_OPERATION) { printf("%s: glTexImage2D failed to generate error\n", TestName); return false; } glTextureStorage2D(tex, 1, GL_RGBA8, width, height); if (glGetError() != GL_INVALID_OPERATION) { printf("%s: glTextureStorage2D() failed to generate " "error\n", TestName); return false; } glCopyTexImage2D(target, 0, GL_RGBA, 0, 0, width, height, 0); if (glGetError() != GL_INVALID_OPERATION) { printf("%s: glCopyTexImage2D() failed to generate " "error\n", TestName); return false; } } glDeleteTextures(1, &tex); return true; }
/** * Function for initialization. */ GLUSboolean init(GLUSvoid) { // Matrix for the model GLfloat model[16]; GLUSshape cube; GLUStgaimage image; GLUStextfile vertexSource; GLUStextfile fragmentSource; // Load the source of the vertex shader. glusLoadTextFile("../Example05/Vertex.vs", &vertexSource); // Load the source of the fragment shader. glusLoadTextFile("../Example05/Fragment.fs", &fragmentSource); // Build and ... glusBuildProgram(&g_program, (const GLUSchar**)&vertexSource.text, 0, (const GLUSchar**)&fragmentSource.text); // Destroy the text resource glusDestroyTextFile(&vertexSource); // Destroy the text resource glusDestroyTextFile(&fragmentSource); // ToDo: glGenVertexArrays(1, &g_vao); // ToDo: glBindVertexArray(g_vao); glusCreateCubef(&cube, 0.5f); numberIndices = cube.numberIndices; // http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml g_projectionLocation = glGetUniformLocation(g_program.program, "projectionMatrix"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml g_modelViewLocation = glGetUniformLocation(g_program.program, "modelViewMatrix"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml g_textureLocation = glGetUniformLocation(g_program.program, "firstTexture"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml g_vertexLocation = glGetAttribLocation(g_program.program, "vertex"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml g_normalLocation = glGetAttribLocation(g_program.program, "normal"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml g_texCoordLocation = glGetAttribLocation(g_program.program, "texCoord"); // ToDo: glBindFragDataLocation(g_program.program, 0, "fragColor"); // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml glGenBuffers(1, &g_vertices); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_vertices); // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml glBufferData(GL_ARRAY_BUFFER, cube.numberVertices*4*sizeof(GLfloat), (GLfloat*)cube.vertices, GL_STATIC_DRAW); // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml glGenBuffers(1, &g_normals); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_normals); // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml glBufferData(GL_ARRAY_BUFFER, cube.numberVertices*3*sizeof(GLfloat), (GLfloat*)cube.normals, GL_STATIC_DRAW); // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml glGenBuffers(1, &g_texCoords); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_texCoords); // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml glBufferData(GL_ARRAY_BUFFER, cube.numberVertices*2*sizeof(GLfloat), (GLfloat*)cube.texCoords, GL_STATIC_DRAW); // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml glGenBuffers(1, &g_indices); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_indices); // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml glBufferData(GL_ELEMENT_ARRAY_BUFFER, cube.numberIndices*sizeof(GLuint), (GLuint*)cube.indices, GL_STATIC_DRAW); glusDestroyShapef(&cube); glusLoadTgaImage("crate.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/gentextures.html glGenTextures(1, &g_texture); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html glBindTexture(GL_TEXTURE_2D, g_texture); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml glUseProgram(g_program.program); // Calculate the model matrix ... glusLoadIdentityf(model); glusRotateRzRyRxf(model, 30.0f, 30.0f, 0.0f); // ... and the view matrix ... glusLookAtf(g_modelView, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); // ... to get the final model view matrix glusMultMatrixf(g_modelView, g_modelView, model); // http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml glUniformMatrix4fv(g_modelViewLocation, 1, GL_FALSE, g_modelView); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_vertices); // http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0); // http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml glEnableVertexAttribArray(g_vertexLocation); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_normals); // http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml glVertexAttribPointer(g_normalLocation, 3, GL_FLOAT, GL_FALSE, 0, 0); // http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml glEnableVertexAttribArray(g_normalLocation); // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml glBindBuffer(GL_ARRAY_BUFFER, g_texCoords); // http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml glVertexAttribPointer(g_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, 0); // http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml glEnableVertexAttribArray(g_texCoordLocation); // http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml glUniform1i(g_textureLocation, 0); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clearcolor.html glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/cleardepth.html glClearDepth(1.0f); //http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html glEnable(GL_DEPTH_TEST); //http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html glEnable(GL_CULL_FACE); return GLUS_TRUE; }
////////////////////////////////////////////////////////////////// // This function does any needed initialization on the rendering // context. Here it sets up and initializes the texture objects. void SetupRC() { GLbyte *pBytes; GLint iWidth, iHeight, iComponents; GLenum eFormat; GLint iLoop; // Black background glClearColor(0.0f, 0.0f, 0.0f,1.0f); shaderManager.InitializeStockShaders(); // Load textures glGenTextures(TEXTURE_COUNT, textures); for(iLoop = 0; iLoop < TEXTURE_COUNT; iLoop++) { // Bind to next texture object glBindTexture(GL_TEXTURE_2D, textures[iLoop]); // Load texture, set filter and wrap modes pBytes = gltReadTGABits(szTextureFiles[iLoop],&iWidth, &iHeight, &iComponents, &eFormat); // Load texture, set filter and wrap modes glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes); glGenerateMipmap(GL_TEXTURE_2D); // Don't need original texture data any more free(pBytes); } // Build Geometry GLfloat z; floorBatch.Begin(GL_TRIANGLE_STRIP, 28, 1); for(z = 60.0f; z >= 0.0f; z -=10.0f) { floorBatch.MultiTexCoord2f(0, 0.0f, 0.0f); floorBatch.Vertex3f(-10.0f, -10.0f, z); floorBatch.MultiTexCoord2f(0, 1.0f, 0.0f); floorBatch.Vertex3f(10.0f, -10.0f, z); floorBatch.MultiTexCoord2f(0, 0.0f, 1.0f); floorBatch.Vertex3f(-10.0f, -10.0f, z - 10.0f); floorBatch.MultiTexCoord2f(0, 1.0f, 1.0f); floorBatch.Vertex3f(10.0f, -10.0f, z - 10.0f); } floorBatch.End(); ceilingBatch.Begin(GL_TRIANGLE_STRIP, 28, 1); for(z = 60.0f; z >= 0.0f; z -=10.0f) { ceilingBatch.MultiTexCoord2f(0, 0.0f, 1.0f); ceilingBatch.Vertex3f(-10.0f, 10.0f, z - 10.0f); ceilingBatch.MultiTexCoord2f(0, 1.0f, 1.0f); ceilingBatch.Vertex3f(10.0f, 10.0f, z - 10.0f); ceilingBatch.MultiTexCoord2f(0, 0.0f, 0.0f); ceilingBatch.Vertex3f(-10.0f, 10.0f, z); ceilingBatch.MultiTexCoord2f(0, 1.0f, 0.0f); ceilingBatch.Vertex3f(10.0f, 10.0f, z); } ceilingBatch.End(); leftWallBatch.Begin(GL_TRIANGLE_STRIP, 28, 1); for(z = 60.0f; z >= 0.0f; z -=10.0f) { leftWallBatch.MultiTexCoord2f(0, 0.0f, 0.0f); leftWallBatch.Vertex3f(-10.0f, -10.0f, z); leftWallBatch.MultiTexCoord2f(0, 0.0f, 1.0f); leftWallBatch.Vertex3f(-10.0f, 10.0f, z); leftWallBatch.MultiTexCoord2f(0, 1.0f, 0.0f); leftWallBatch.Vertex3f(-10.0f, -10.0f, z - 10.0f); leftWallBatch.MultiTexCoord2f(0, 1.0f, 1.0f); leftWallBatch.Vertex3f(-10.0f, 10.0f, z - 10.0f); } leftWallBatch.End(); rightWallBatch.Begin(GL_TRIANGLE_STRIP, 28, 1); for(z = 60.0f; z >= 0.0f; z -=10.0f) { rightWallBatch.MultiTexCoord2f(0, 0.0f, 0.0f); rightWallBatch.Vertex3f(10.0f, -10.0f, z); rightWallBatch.MultiTexCoord2f(0, 0.0f, 1.0f); rightWallBatch.Vertex3f(10.0f, 10.0f, z); rightWallBatch.MultiTexCoord2f(0, 1.0f, 0.0f); rightWallBatch.Vertex3f(10.0f, -10.0f, z - 10.0f); rightWallBatch.MultiTexCoord2f(0, 1.0f, 1.0f); rightWallBatch.Vertex3f(10.0f, 10.0f, z - 10.0f); } rightWallBatch.End(); }
//----------------------------------------------------------------------------- // blitFromMemory doing hardware trilinear scaling void GLES2TextureBuffer::blitFromMemory(const PixelBox &src_orig, const Image::Box &dstBox) { // Fall back to normal GLHardwarePixelBuffer::blitFromMemory in case // - FBO is not supported // - Either source or target is luminance due doesn't looks like supported by hardware // - the source dimensions match the destination ones, in which case no scaling is needed // TODO: Check that extension is NOT available if(PixelUtil::isLuminance(src_orig.format) || PixelUtil::isLuminance(mFormat) || (src_orig.getWidth() == dstBox.getWidth() && src_orig.getHeight() == dstBox.getHeight() && src_orig.getDepth() == dstBox.getDepth())) { GLES2HardwarePixelBuffer::blitFromMemory(src_orig, dstBox); return; } if(!mBuffer.contains(dstBox)) OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Destination box out of range", "GLES2TextureBuffer::blitFromMemory"); // For scoped deletion of conversion buffer MemoryDataStreamPtr buf; PixelBox src; // First, convert the srcbox to a OpenGL compatible pixel format if(GLES2PixelUtil::getGLOriginFormat(src_orig.format) == 0) { // Convert to buffer internal format buf.bind(OGRE_NEW MemoryDataStream(PixelUtil::getMemorySize(src_orig.getWidth(), src_orig.getHeight(), src_orig.getDepth(), mFormat))); src = PixelBox(src_orig.getWidth(), src_orig.getHeight(), src_orig.getDepth(), mFormat, buf->getPtr()); PixelUtil::bulkPixelConversion(src_orig, src); } else { // No conversion needed src = src_orig; } // Create temporary texture to store source data GLuint id; GLenum target = GL_TEXTURE_2D; GLsizei width = GLES2PixelUtil::optionalPO2(src.getWidth()); GLsizei height = GLES2PixelUtil::optionalPO2(src.getHeight()); GLenum format = GLES2PixelUtil::getClosestGLInternalFormat(src.format); GLenum datatype = GLES2PixelUtil::getGLOriginDataType(src.format); // Generate texture name glGenTextures(1, &id); GL_CHECK_ERROR; // Set texture type glBindTexture(target, id); GL_CHECK_ERROR; #if GL_APPLE_texture_max_level glTexParameteri(target, GL_TEXTURE_MAX_LEVEL_APPLE, 1000 ); GL_CHECK_ERROR; #endif // Allocate texture memory glTexImage2D(target, 0, format, width, height, 0, format, datatype, 0); GL_CHECK_ERROR; // GL texture buffer GLES2TextureBuffer tex(StringUtil::BLANK, target, id, width, height, format, src.format, 0, 0, (Usage)(TU_AUTOMIPMAP|HBU_STATIC_WRITE_ONLY), false, false, 0); // Upload data to 0,0,0 in temporary texture Image::Box tempTarget(0, 0, 0, src.getWidth(), src.getHeight(), src.getDepth()); tex.upload(src, tempTarget); // Blit blitFromTexture(&tex, tempTarget, dstBox); // Delete temp texture glDeleteTextures(1, &id); GL_CHECK_ERROR; }
/////////////////////////////////////////////////////////// // Setup the rendering context void SetupRC(void) { GLbyte *pBytes; GLint iWidth, iHeight, iComponents; GLenum eFormat; lookUp=false; lookDown=false; lookLeft=false; lookRight=false; walkForward=false; walkBackward=false; strafeLeft=false; strafeRight=false; yRotationAngle=0; xRotationAngle=0; zRotationAngle=0; xTranslation=0; yTranslation=0; zTranslation=0; // Black background glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); // Set drawing color to green glColor3f(0.0f, 1.0f, 0.0f); glShadeModel(GL_SMOOTH); glEnable(GL_RESCALE_NORMAL); glFrontFace(GL_CW); glEnable (GL_DEPTH_TEST); //light valuse and coords GLfloat ambientLight[] = { 0.0f, 0.0f, 0.0f, 1.0f}; GLfloat diffuseLight[] = { 0.4f, 0.4f, 0.4f, 1.0f}; GLfloat specular[] = {1.0f, 1.0f, 1.0f, 1.0f}; GLfloat specref[] = {1.0f, 1.0f, 1.0f, 1.0f}; GLfloat shinnyness[] ={128.0f, 128.0f, 128.0f}; //enable color tracking // glEnable(GL_COLOR_MATERIAL); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight); //set up material properties to follow glColor values glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); glMaterialfv(GL_FRONT, GL_SHININESS, shinnyness); //enable lighting glEnable(GL_LIGHTING); //Setup and enable light 0 // glLightfv(GL_LIGHT0,GL_AMBIENT, ambientLight); //glLightfv(GL_LIGHT0,GL_DIFFUSE, diffuseLight); //glLightfv(GL_LIGHT0,GL_SPECULAR, specular); // Lighting code goes here. glEnable(GL_LIGHT0); glEnable(GL_NORMALIZE); glEnable(GL_TEXTURE_2D); glGenTextures(NUM_TEXTURES, textureObjects); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // Load textures for planets for(int i = 0; i < 12; i++) { //Load this texture map //glBindTexture(GL_TEXTURE_2D, textureObjects[i]); pBytes = gltLoadTGA(szTextureFiles[i], &iWidth, &iHeight, &iComponents, &eFormat); //gluBuild2DMipmaps(cube[i], iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); glTexImage2D(textureObjects[i], 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); } glBindTexture(GL_TEXTURE_2D, textureObjects[CUBE_MAP_TEX]); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_GENERATE_MIPMAP, GL_TRUE); // Load Cube Map images for(int i = 0; i < 6; i++) { // Load this texture map pBytes = gltLoadTGA(szCubeFaces[i], &iWidth, &iHeight, &iComponents, &eFormat); //gluBuild2DMipmaps(cube[i], iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); glTexImage2D(cube[i], 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); } // Set up texture maps // glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); //glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); /* //load sphere texture // glBindTexture(GL_TEXTURE_2D, textureObjects[sphere_map_tex]); // glTexParameteri(GL_, GL_GENERATE_MIPMAP, GL_TRUE); // Load Cube Map images /* for(int i = 0; i < 10; i++)//FIXED FOR LOOP { //Load this texture map glBindTexture(GL_TEXTURE_2D, textureObjects[i]); pBytes = gltLoadTGA(szTextureFiles[i], &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); } // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); */ //glBindTexture(GL_TEXTURE_2D, textureObjects[CLOUDS]); glBindTexture(GL_TEXTURE_2D, textureObjects[EARTH]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/earth.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[MARS]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/mars.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[MERCURY]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/mercury.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[VENUS]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/venus.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[MOON]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/moon.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[SATURN]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/saturn.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[URANUS]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/uranus.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[NEPTUNE]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/neptune.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[SUN]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/sun.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[JUPITER]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/jupiter.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[CLOUDS]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/clouds.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glBindTexture(GL_TEXTURE_2D, textureObjects[ASTERIODS]); // Set up texture maps glTexParameteri(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_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); pBytes = gltLoadTGA("textures/Asteriod-Belt.tga", &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); }
int main() { int width = 640; int height = 480; if(glfwInit() == GL_FALSE) { std::cerr << "failed to init GLFW" << std::endl; return 1; } // select opengl version glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // create a window GLFWwindow *window; if((window = glfwCreateWindow(width, height, "03texture", 0, 0)) == 0) { std::cerr << "failed to open window" << std::endl; glfwTerminate(); return 1; } glfwMakeContextCurrent(window); if(glxwInit()) { std::cerr << "failed to init GL3W" << std::endl; glfwDestroyWindow(window); glfwTerminate(); return 1; } // shader source code std::string vertex_source = "#version 330\n" "layout(location = 0) in vec4 vposition;\n" "layout(location = 1) in vec2 vtexcoord;\n" "out vec2 ftexcoord;\n" "void main() {\n" " ftexcoord = vtexcoord;\n" " gl_Position = vposition;\n" "}\n"; std::string fragment_source = "#version 330\n" "uniform sampler2D tex;\n" // texture uniform "in vec2 ftexcoord;\n" "layout(location = 0) out vec4 FragColor;\n" "void main() {\n" " FragColor = texture(tex, ftexcoord);\n" "}\n"; // program and shader handles GLuint shader_program, vertex_shader, fragment_shader; // we need these to properly pass the strings const char *source; int length; // create and compiler vertex shader vertex_shader = glCreateShader(GL_VERTEX_SHADER); source = vertex_source.c_str(); length = vertex_source.size(); glShaderSource(vertex_shader, 1, &source, &length); glCompileShader(vertex_shader); if(!check_shader_compile_status(vertex_shader)) { glfwDestroyWindow(window); glfwTerminate(); return 1; } // create and compiler fragment shader fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); source = fragment_source.c_str(); length = fragment_source.size(); glShaderSource(fragment_shader, 1, &source, &length); glCompileShader(fragment_shader); if(!check_shader_compile_status(fragment_shader)) { glfwDestroyWindow(window); glfwTerminate(); return 1; } // create program shader_program = glCreateProgram(); // attach shaders glAttachShader(shader_program, vertex_shader); glAttachShader(shader_program, fragment_shader); // link the program and check for errors glLinkProgram(shader_program); check_program_link_status(shader_program); // get texture uniform location GLint texture_location = glGetUniformLocation(shader_program, "tex"); // vao and vbo handle GLuint vao, vbo, ibo; // generate and bind the vao glGenVertexArrays(1, &vao); glBindVertexArray(vao); // generate and bind the vertex buffer object glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); // data for a fullscreen quad (this time with texture coords) GLfloat vertexData[] = { // X Y Z U V 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, // vertex 0 -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, // vertex 1 1.0f,-1.0f, 0.0f, 1.0f, 0.0f, // vertex 2 -1.0f,-1.0f, 0.0f, 0.0f, 0.0f, // vertex 3 }; // 4 vertices with 5 components (floats) each // fill with data glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*4*5, vertexData, GL_STATIC_DRAW); // set up generic attrib pointers glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat)); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), (char*)0 + 3*sizeof(GLfloat)); // generate and bind the index buffer object glGenBuffers(1, &ibo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); GLuint indexData[] = { 0,1,2, // first triangle 2,1,3, // second triangle }; // fill with data glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*2*3, indexData, GL_STATIC_DRAW); // "unbind" vao glBindVertexArray(0); // texture handle GLuint texture; // generate texture glGenTextures(1, &texture); // bind the texture glBindTexture(GL_TEXTURE_2D, texture); // create some image data std::vector<GLubyte> image(4*width*height); for(int j = 0;j<height;++j) { for(int i = 0;i<width;++i) { size_t index = j*width + i; image[4*index + 0] = 0xFF*(j/10%2)*(i/10%2); // R image[4*index + 1] = 0xFF*(j/13%2)*(i/13%2); // G image[4*index + 2] = 0xFF*(j/17%2)*(i/17%2); // B image[4*index + 3] = 0xFF; // A } } // set texture parameters 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); // set texture content glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &image[0]); while(!glfwWindowShouldClose(window)) { glfwPollEvents(); // clear first glClear(GL_COLOR_BUFFER_BIT); // use the shader program glUseProgram(shader_program); // bind texture to texture unit 0 glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture); // set texture uniform glUniform1i(texture_location, 0); // bind the vao glBindVertexArray(vao); // draw glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); // check for errors GLenum error = glGetError(); if(error != GL_NO_ERROR) { std::cerr << error << std::endl; break; } // finally swap buffers glfwSwapBuffers(window); } // delete the created objects glDeleteTextures(1, &texture); glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); glDeleteBuffers(1, &ibo); glDetachShader(shader_program, vertex_shader); glDetachShader(shader_program, fragment_shader); glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); glDeleteProgram(shader_program); glfwDestroyWindow(window); glfwTerminate(); return 0; }
///////////////////////////////// // Initialize function ///////////////////////////////// void init() { /*select clearing (background) color*/ glClearColor(0.0, 0.0, 0.0, 1.0); rotateYEarth = 1; rotateZEarth = 1; //populate our arrays //spherevertcount = generateSphere(2, 30); vec4 sphereverts[2592]; vec2 spheretexcoords[2592]; // 2592 vec3 spherenormals[2592]; vec4 spheretangents[2592]; vec4 cloudverts[2592]; vec2 cloudtexcoords[2592]; // 2592 vec3 cloudnormals[2592]; vec4 cloudtangents[2592]; CreateSphere(sphereverts, spheretexcoords, spherenormals, spheretangents, 2, 0,0,0); // create cloud CreateSphere(cloudverts, cloudtexcoords, cloudnormals, cloudtangents, 2, 0,0,0); ///////////////////////////////////////// // Create a vertex array object spherevao = new GLuint[1]; spherevbo = new GLuint[3]; cloudvao = new GLuint[1]; cloudvbo = new GLuint[3]; ////////////////////////// // earth buffer ////////////////////////// glGenVertexArrays( 1, &spherevao[0] ); // Create and initialize any buffer objects glBindVertexArray( spherevao[0] ); glGenBuffers( 2, &spherevbo[0] ); glBindBuffer( GL_ARRAY_BUFFER, spherevbo[0] ); glBufferData( GL_ARRAY_BUFFER, VertexCount*sizeof(vec4), sphereverts, GL_STATIC_DRAW); glBindBuffer( GL_ARRAY_BUFFER, spherevbo[1] ); glBufferData( GL_ARRAY_BUFFER, VertexCount*sizeof(vec2), spheretexcoords, GL_STATIC_DRAW); glBindBuffer( GL_ARRAY_BUFFER, spherevbo[2] ); glBufferData( GL_ARRAY_BUFFER, VertexCount*sizeof(vec3), spherenormals, GL_STATIC_DRAW); ////////////////////// // Cloud buffer ////////////////////// glGenVertexArrays( 1, &cloudvao[0] ); // Create and initialize any buffer objects glBindVertexArray( cloudvao[0] ); glGenBuffers( 2, &cloudvbo[0] ); glBindBuffer( GL_ARRAY_BUFFER, cloudvbo[0] ); glBufferData( GL_ARRAY_BUFFER, VertexCount*sizeof(vec4), cloudverts, GL_STATIC_DRAW); glBindBuffer( GL_ARRAY_BUFFER, cloudvbo[1] ); glBufferData( GL_ARRAY_BUFFER, VertexCount*sizeof(vec2), cloudtexcoords, GL_STATIC_DRAW); glBindBuffer( GL_ARRAY_BUFFER, cloudvbo[2] ); glBufferData( GL_ARRAY_BUFFER, VertexCount*sizeof(vec3), cloudnormals, GL_STATIC_DRAW); // Load shaders and use the resulting shader program programAllFeatures = InitShader( "vshader-phongshading.glsl", "fshader-phongshading.glsl" ); programColor = InitShader( "vshader-color.glsl", "fshader-color.glsl" ); programCloud = InitShader( "vshader-cloud.glsl", "fshader-cloud.glsl" ); glUseProgram(programAllFeatures); // Create a vertex array object // glGenVertexArrays( 1, &vao[0] ); // // Create and initialize any buffer objects //glBindVertexArray( vao[0] ); //glGenBuffers( 2, &vbo[0] ); // glBindBuffer( GL_ARRAY_BUFFER, vbo[0] ); // glBufferData( GL_ARRAY_BUFFER, spherevertcount*sizeof(vec4), sphere_verts, GL_STATIC_DRAW); // ////and now our colors for each vertex //glBindBuffer( GL_ARRAY_BUFFER, vbo[1] ); //glBufferData( GL_ARRAY_BUFFER, spherevertcount*sizeof(vec3), sphere_normals, GL_STATIC_DRAW ); // setupShader(programAllFeatures); model_view = glGetUniformLocation(programAllFeatures, "model_view"); projection = glGetUniformLocation(programAllFeatures, "projection"); setupEarthShader(programAllFeatures, spherevao, spherevbo); // set up cloud shader // This is where I have error that whenever I use setupearthshader for cloud // I have bad images rendered. // I don't understand and keep looking errors why but give up cloud // setupEarthShader(programCloud, cloudvao, cloudvbo); glUseProgram(programAllFeatures); ILuint ilTexID[5]; /* ILuint is a 32bit unsigned integer. //Variable texid will be used to store image name. */ ilInit(); /* Initialization of OpenIL */ ilGenImages(5, ilTexID); /* Generation of three image names for OpenIL image loading */ glGenTextures(5, texName); //and we eventually want the data in an OpenGL texture ///////////////////////////////////////// // EARTH BUFFERS //////////////////////////////////////////////////// // load color map if ( true ) { ilBindImage(ilTexID[0]); /* Binding of IL image name */ loadTexFile("images/Earth.png"); glBindTexture(GL_TEXTURE_2D, texName[0]); //bind OpenGL texture name glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); //Note how we depend on OpenIL to supply information about the file we just loaded in glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT),0, ilGetInteger(IL_IMAGE_FORMAT), ilGetInteger(IL_IMAGE_TYPE), ilGetData()); glGenerateMipmap(GL_TEXTURE_2D); } // load cloud if (true) { glUseProgram(programCloud); ilBindImage(ilTexID[1]); /* Binding of IL image name */ glBindTexture(GL_TEXTURE_2D, texName[1]); //bind OpenGL texture name loadTexFile("images/earthcloudmap.png"); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); //Note how we depend on OpenIL to supply information about the file we just loaded in glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT),0, ilGetInteger(IL_IMAGE_FORMAT), ilGetInteger(IL_IMAGE_TYPE), ilGetData()); glGenerateMipmap(GL_TEXTURE_2D); } // Spec map if (true) { glUseProgram(programAllFeatures); ilBindImage(ilTexID[2]); /* Binding of IL image name */ glBindTexture(GL_TEXTURE_2D, texName[2]); //bind OpenGL texture name loadTexFile("images/EarthSpec.png"); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); //Note how we depend on OpenIL to supply information about the file we just loaded in glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT),0, ilGetInteger(IL_IMAGE_FORMAT), ilGetInteger(IL_IMAGE_TYPE), ilGetData()); glGenerateMipmap(GL_TEXTURE_2D); } // Normal map if (true) { ilBindImage(ilTexID[3]); /* Binding of IL image name */ glBindTexture(GL_TEXTURE_2D, texName[3]); //bind OpenGL texture name loadTexFile("images/EarthNormal.png"); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); //Note how we depend on OpenIL to supply information about the file we just loaded in glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT),0, ilGetInteger(IL_IMAGE_FORMAT), ilGetInteger(IL_IMAGE_TYPE), ilGetData()); glGenerateMipmap(GL_TEXTURE_2D); } // Night map if (true) { ilBindImage(ilTexID[4]); /* Binding of IL image name */ glBindTexture(GL_TEXTURE_2D, texName[4]); //bind OpenGL texture name loadTexFile("images/EarthNight.png"); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); //GL_NEAREST); //Note how we depend on OpenIL to supply information about the file we just loaded in glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT),0, ilGetInteger(IL_IMAGE_FORMAT), ilGetInteger(IL_IMAGE_TYPE), ilGetData()); glGenerateMipmap(GL_TEXTURE_2D); } //////////////////////////////////////////////// ilDeleteImages(5, ilTexID); //we're done with OpenIL, so free up the memory //////////////////////////////////////////////////// glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); texMap = glGetUniformLocation(programAllFeatures, "texture"); glUniform1i(texMap, 0);//assign this one to texture unit 0 cloudMap = glGetUniformLocation(programCloud, "cloudtexture"); glUniform1i(cloudMap, 1);//assign cloud map to texture unit 1 specMap = glGetUniformLocation(programAllFeatures, "spectexture"); glUniform1i(specMap, 2);//assign spec map to 2 texture unit normalMap = glGetUniformLocation(programAllFeatures, "normalMap"); glUniform1i(normalMap, 3);//assign normal map to 3 texture unit nightMap = glGetUniformLocation(programAllFeatures, "nighttexture"); glUniform1i(nightMap, 4);//assign spec map to 4 texture unit // setup lightning vAmbientDiffuseColor = glGetAttribLocation(programAllFeatures, "vAmbientDiffuseColor"); vSpecularColor = glGetAttribLocation(programAllFeatures, "vSpecularColor"); vSpecularExponent = glGetAttribLocation(programAllFeatures, "vSpecularExponent"); light_position = glGetUniformLocation(programAllFeatures, "light_position"); light_color = glGetUniformLocation(programAllFeatures, "light_color"); ambient_light = glGetUniformLocation(programAllFeatures, "ambient_light"); //Only draw the things in the front layer glEnable(GL_DEPTH_TEST); }
int main(int argc, char *argv[]) { GstVaapiDisplay *display; GstVaapiWindow *window; GstVaapiWindowGLX *glx_window; GstVaapiSurface *surface; GstVaapiImage *image; GstVaapiTexture *textures[2]; GstVaapiTexture *texture; GLuint texture_id; GstVaapiRectangle src_rect; GstVaapiRectangle dst_rect; guint flags = GST_VAAPI_PICTURE_STRUCTURE_FRAME; static const GstVaapiChromaType chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420; static const guint width = 320; static const guint height = 240; static const guint win_width = 640; static const guint win_height = 480; gst_init(&argc, &argv); display = gst_vaapi_display_glx_new(NULL); if (!display) g_error("could not create VA display"); surface = gst_vaapi_surface_new(display, chroma_type, width, height); if (!surface) g_error("could not create VA surface"); image = image_generate(display, GST_VAAPI_IMAGE_NV12, width, height); if (!image) g_error("could not create VA image"); if (!image_upload(image, surface)) g_error("could not upload VA image to surface"); window = gst_vaapi_window_glx_new(display, win_width, win_height); if (!window) g_error("could not create window"); glx_window = GST_VAAPI_WINDOW_GLX(window); gst_vaapi_window_show(window); if (!gst_vaapi_window_glx_make_current(glx_window)) g_error("coult not bind GL context"); g_print("#\n"); g_print("# Create texture with gst_vaapi_texture_new()\n"); g_print("#\n"); { texture = gst_vaapi_texture_new( display, GL_TEXTURE_2D, GL_RGBA, width, height ); if (!texture) g_error("could not create VA texture"); textures[0] = texture; texture_id = gst_vaapi_texture_get_id(texture); if (!gst_vaapi_texture_put_surface(texture, surface, flags)) g_error("could not transfer VA surface to texture"); if (!gst_vaapi_window_glx_put_texture(glx_window, texture, NULL, NULL)) g_error("could not render texture into the window"); } g_print("#\n"); g_print("# Create texture with gst_vaapi_texture_new_with_texture()\n"); g_print("#\n"); { const GLenum target = GL_TEXTURE_2D; const GLenum format = GL_BGRA; glEnable(target); glGenTextures(1, &texture_id); glBindTexture(target, texture_id); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glTexImage2D( target, 0, GL_RGBA8, width, height, 0, format, GL_UNSIGNED_BYTE, NULL ); glDisable(target); texture = gst_vaapi_texture_new_with_texture( display, texture_id, target, format ); if (!texture) g_error("could not create VA texture"); if (texture_id != gst_vaapi_texture_get_id(texture)) g_error("invalid texture id"); if (gl_get_current_texture_2d() != texture_id) g_error("gst_vaapi_texture_new_with_texture() altered texture bindings"); textures[1] = texture; if (!gst_vaapi_texture_put_surface(texture, surface, flags)) g_error("could not transfer VA surface to texture"); if (gl_get_current_texture_2d() != texture_id) g_error("gst_vaapi_texture_put_surface() altered texture bindings"); src_rect.x = 0; src_rect.y = 0; src_rect.width = width; src_rect.height = height; dst_rect.x = win_width/2; dst_rect.y = win_height/2; dst_rect.width = win_width/2; dst_rect.height = win_height/2; if (!gst_vaapi_window_glx_put_texture(glx_window, texture, &src_rect, &dst_rect)) g_error("could not render texture into the window"); if (gl_get_current_texture_2d() != texture_id) g_error("gst_vaapi_window_glx_put_texture() altered texture bindings"); } gst_vaapi_window_glx_swap_buffers(glx_window); pause(); g_object_unref(textures[0]); g_object_unref(textures[1]); glDeleteTextures(1, &texture_id); g_object_unref(window); g_object_unref(display); gst_deinit(); return 0; }
void base::img_load (int _w, int _h, const char *str, int _n, short t_n, short type) {//t_n - texture's number// type: 0, 1 SDL_Surface *surface; GLenum texture_format; GLint n_of_colors; if ( (surface = IMG_Load(str)) ) //~ if ( (surface = SDL_LoadBMP(str)) ) { n_of_colors = surface->format->BytesPerPixel; //~ texture_format = GL_LUMINANCE; //~ texture_format = GL_LUMINANCE_ALPHA; if (n_of_colors == 4) { // contains an alpha channel if (surface->format->Rmask == 0x000000ff) texture_format = GL_RGBA; else texture_format = GL_BGRA; } else if (n_of_colors == 3) { // no alpha channel if (surface->format->Rmask == 0x000000ff) texture_format = GL_RGB; else texture_format = GL_BGR; } else printf("base:::img_load::warning: the image is not truecolor. this will probably break\n"); // Have OpenGL generate a texture object handle for us glGenTextures( 1, &texture[t_n].texture ); // Bind the texture object glBindTexture( GL_TEXTURE_2D, texture[t_n].texture ); // Set the texture's stretching properties glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); // Edit the texture object's image data using the information SDL_Surface gives us glTexImage2D( GL_TEXTURE_2D, 0, n_of_colors, surface->w, surface->h, 0, //it does not allow color+texture texture_format, GL_UNSIGNED_BYTE, surface->pixels ); switch(type) { //S == x; T == y; case 0: glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); texture[t_n].w=_w; texture[t_n].h=_h; break; case 1: glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP); texture[t_n].w=_w/_n; texture[t_n].h=_h; break; case 2: glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP); texture[t_n].w=_w/_n; texture[t_n].h=_h/_n; break; case 3: glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); texture[t_n].w=_w; texture[t_n].h=_h/_n; break; default: fprintf(stderr, "base:::img_load::warning: unknown img type %i\n", type); break; } texture[t_n].n=_n; texture[t_n].type=type; } else fprintf(stderr,"base:::img_load::error: loading error %s\n %i\n", str); }
//读取一个BMP文件作为纹理.如果失败,返回0;如果成功,返回纹理编号 GLuint load_texture(const char* file_name) { /*如果这里报错:'fopen': This function or variable may be unsafe * 解决办法: * 项目 =》属性 =》c/c++ =》预处理器=》点击预处理器定义,编辑,加入_CRT_SECURE_NO_WARNINGS */ // 打开文件,如果失败,返回 FILE* pFile = fopen(file_name, "rb"); if (pFile == 0) return 0; // 读取文件中图象的宽度和高度 GLint width, height; fseek(pFile, 0x0012, SEEK_SET); fread(&width, 4, 1, pFile);//读取出的值赋给传入的变量 fread(&height, 4, 1, pFile); fseek(pFile, BMP_Header_Length, SEEK_SET); // 计算每行像素所占字节数,并根据此数据计算总像素字节数 GLint total_bytes; { GLint line_bytes = width * 3; while (line_bytes % 4 != 0) ++line_bytes; total_bytes = line_bytes * height; } // 根据总像素字节数分配内存 GLubyte* pixels = 0;//像素数据 pixels = (GLubyte*)malloc(total_bytes); if (pixels == 0) { fclose(pFile); return 0; } // 读取像素数据 if (fread(pixels, total_bytes, 1, pFile) <= 0) { free(pixels); fclose(pFile); return 0; } // 在旧版本的OpenGL中 // 如果图象的宽度和高度不是的整数次方,则需要进行缩放 // 这里并没有检查OpenGL版本,出于对版本兼容性的考虑,按旧版本处理 // 另外,无论是旧版本还是新版本, // 当图象的宽度和高度超过当前OpenGL实现所支持的最大值时,也要进行缩放 { GLint max; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max); if (!power_of_two(width) || !power_of_two(height) || width > max || height > max) { const GLint new_width = 256; const GLint new_height = 256; // 规定缩放后新的大小为边长的正方形 GLint new_line_bytes, new_total_bytes; GLubyte* new_pixels = 0; // 计算每行需要的字节数和总字节数 new_line_bytes = new_width * 3; while (new_line_bytes % 4 != 0) ++new_line_bytes; new_total_bytes = new_line_bytes * new_height; // 分配内存 new_pixels = (GLubyte*)malloc(new_total_bytes); if (new_pixels == 0) { free(pixels); fclose(pFile); return 0; } // 进行像素缩放 gluScaleImage(GL_RGB, width, height, GL_UNSIGNED_BYTE, pixels, new_width, new_height, GL_UNSIGNED_BYTE, new_pixels); // 释放原来的像素数据,把pixels指向新的像素数据,并重新设置width和height free(pixels); pixels = new_pixels; width = new_width; height = new_height; } } // 分配一个新的纹理编号 GLuint texture_ID = 0; glGenTextures(1, &texture_ID);//(个数,给谁) if (texture_ID == 0) { free(pixels); fclose(pFile); return 0; } // 在绑定前,先获得原来绑定的纹理编号,以便在最后进行恢复 GLint last_texture_ID; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture_ID); // 绑定新的纹理,载入纹理并设置纹理参数 glBindTexture(GL_TEXTURE_2D, texture_ID); 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_REPEAT);//纹理坐标的第一维坐标值大于1.0或小于0.0时 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);//纹理坐标的第二维坐标值大于1.0或小于0.0时 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);//像素级别,指定纹理贴图和材质混合的方式 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, pixels);//载入二维纹理 glBindTexture(GL_TEXTURE_2D, last_texture_ID); // 之前为pixels分配的内存可在使用glTexImage2D以后释放.因为此时像素数据已经被OpenGL另行保存了一份(可能被保存到专门的图形硬件中) free(pixels); return texture_ID; }
void TextureAtlas::init_texture() { int max_texture_size; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size); deinit_texture(); if (image.store_width > max_texture_size || image.store_height > max_texture_size) { // Turns out that the atlas is too wide or tall. Reshape it. int texture_count = get_texture_count(); int max_columns = max_texture_size / unit_w; int old_unit_columns = unit_columns; int old_unit_rows = unit_rows; // Naive method for getting a fitting atlas size. if (max_columns >= texture_count) { unit_columns = texture_count; unit_rows = 1; } else { unit_columns = max_columns; // Round up divide. unit_rows = (texture_count + max_columns - 1) / max_columns; } gl_image = Image(unit_w * unit_columns, unit_h * unit_rows, true); LOG(INFO) << "Reshaping: " << this << ": (" << image.width << ", " << image.height << ") -> (" << gl_image.width << ", " << gl_image.height << ")";; LOG(INFO) << " (Units): " << this << ": (" << old_unit_columns << ", " << old_unit_rows << ") -> (" << unit_columns << ", " << unit_rows << ")";; for (int i = 0, end = old_unit_columns * old_unit_rows; i < end; ++i) { int dst_x_offset = (i % unit_columns) * unit_w; int dst_y_offset = (i / unit_columns) * unit_h; int src_x_offset = (i % old_unit_columns) * unit_w; int src_y_offset = (i / old_unit_columns) * unit_h; VLOG(2) << "Moving: " << i << ": (" << src_x_offset << ", " << src_y_offset << ") -> (" << dst_x_offset << ", " << dst_y_offset << ")"; for (int y = 0; y < unit_h; ++y) { for (int x = 0; x < unit_w; ++x) { gl_image.flipped_pixels[dst_y_offset + y][dst_x_offset + x] = image.flipped_pixels[src_y_offset + y][src_x_offset + x]; } } } textures = std::vector<std::weak_ptr<Texture>>(unit_columns * unit_rows); reshaped = true; } glGenTextures(1, &gl_texture); if (gl_texture == 0) { LOG(ERROR) << "Unable to generate GL texture."; throw TextureAtlas::LoadException("Unable to generate GL texture"); } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, gl_texture); glGetError(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, gl_image.store_width, gl_image.store_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, gl_image.pixels); if (int e = glGetError()) { std::stringstream hex_error_code; hex_error_code << std::hex << e; glDeleteTextures(1, &gl_texture); throw TextureAtlas::LoadException("Unable to load texture into GPU: " + hex_error_code.str()); } glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glBindTexture(GL_TEXTURE_2D, 0); }
int APIENTRY pngLoadF(FILE *fp, int mipmap, int trans, pngInfo *pinfo) { GLint pack, unpack; unsigned char header[8]; png_structp png; png_infop info; png_infop endinfo; png_bytep data, data2; png_bytep *row_p; double fileGamma; png_uint_32 width, height, rw, rh; int depth, color; png_uint_32 i; fread(header, 1, 8, fp); if (!png_check_sig(header, 8)) return 0; png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); info = png_create_info_struct(png); endinfo = png_create_info_struct(png); // DH: added following lines if (setjmp(png->jmpbuf)) { png_destroy_read_struct(&png, &info, &endinfo); return 0; } // ~DH png_init_io(png, fp); png_set_sig_bytes(png, 8); png_read_info(png, info); png_get_IHDR(png, info, &width, &height, &depth, &color, NULL, NULL, NULL); if (pinfo != NULL) { pinfo->Width = width; pinfo->Height = height; pinfo->Depth = depth; } if (MaxTextureSize == 0) glGetIntegerv(GL_MAX_TEXTURE_SIZE, &MaxTextureSize); #ifdef SUPPORTS_PALETTE_EXT #ifdef _WIN32 if (PalettedTextures == -1) PalettedTextures = ExtSupported("GL_EXT_paletted_texture") && (strstr((const char *) glGetString(GL_VERSION), "1.1.0 3Dfx Beta") == NULL); if (PalettedTextures) { if (glColorTableEXT == NULL) { glColorTableEXT = (PFNGLCOLORTABLEEXTPROC) wglGetProcAddress("glColorTableEXT"); if (glColorTableEXT == NULL) PalettedTextures = 0; } } #endif #endif if (PalettedTextures == -1) PalettedTextures = 0; if (color == PNG_COLOR_TYPE_GRAY || color == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png); if (color&PNG_COLOR_MASK_ALPHA && trans != PNG_ALPHA) { png_set_strip_alpha(png); color &= ~PNG_COLOR_MASK_ALPHA; } if (!(PalettedTextures && mipmap >= 0 && trans == PNG_SOLID)) if (color == PNG_COLOR_TYPE_PALETTE) png_set_expand(png); /*--GAMMA--*/ checkForGammaEnv(); if (png_get_gAMA(png, info, &fileGamma)) png_set_gamma(png, screenGamma, fileGamma); else png_set_gamma(png, screenGamma, 1.0/2.2); png_read_update_info(png, info); data = (png_bytep) malloc(png_get_rowbytes(png, info)*height); row_p = (png_bytep *) malloc(sizeof(png_bytep)*height); for (i = 0; i < height; i++) { if (StandardOrientation) row_p[height - 1 - i] = &data[png_get_rowbytes(png, info)*i]; else row_p[i] = &data[png_get_rowbytes(png, info)*i]; } png_read_image(png, row_p); free(row_p); rw = SafeSize(width), rh = SafeSize(height); if (rw != width || rh != height) { const int channels = png_get_rowbytes(png, info)/width; data2 = (png_bytep) malloc(rw*rh*channels); /* Doesn't work on certain sizes */ /* if (gluScaleImage(glformat, width, height, GL_UNSIGNED_BYTE, data, rw, rh, GL_UNSIGNED_BYTE, data2) != 0) return 0; */ Resize(channels, data, width, height, data2, rw, rh); width = rw, height = rh; free(data); data = data2; } { /* OpenGL stuff */ glGetIntegerv(GL_PACK_ALIGNMENT, &pack); glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpack); glPixelStorei(GL_PACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); #ifdef SUPPORTS_PALETTE_EXT if (PalettedTextures && mipmap >= 0 && trans == PNG_SOLID && color == PNG_COLOR_TYPE_PALETTE) { png_colorp pal; int cols; GLint intf; if (pinfo != NULL) pinfo->Alpha = 0; png_get_PLTE(png, info, &pal, &cols); switch (cols) { case 1<<1: intf = GL_COLOR_INDEX1_EXT; break; case 1<<2: intf = GL_COLOR_INDEX2_EXT; break; case 1<<4: intf = GL_COLOR_INDEX4_EXT; break; case 1<<8: intf = GL_COLOR_INDEX8_EXT; break; case 1<<12: intf = GL_COLOR_INDEX12_EXT; break; case 1<<16: intf = GL_COLOR_INDEX16_EXT; break; default: /*printf("Warning: Colour depth %i not recognised\n", cols);*/ return 0; } glColorTableEXT(GL_TEXTURE_2D, GL_RGB8, cols, GL_RGB, GL_UNSIGNED_BYTE, pal); glTexImage2D(GL_TEXTURE_2D, mipmap, intf, width, height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, data); } else #endif if (trans == PNG_SOLID || trans == PNG_ALPHA || trans == PNG_LUMINANCEALPHA || color == PNG_COLOR_TYPE_RGB_ALPHA || color == PNG_COLOR_TYPE_GRAY_ALPHA) { GLenum glformat; GLint glcomponent; switch (color) { case PNG_COLOR_TYPE_GRAY: case PNG_COLOR_TYPE_RGB: case PNG_COLOR_TYPE_PALETTE: glformat = GL_RGB; glcomponent = 3; if (pinfo != NULL) pinfo->Alpha = 0; break; case PNG_COLOR_TYPE_GRAY_ALPHA: case PNG_COLOR_TYPE_RGB_ALPHA: glformat = GL_RGBA; glcomponent = 4; if (pinfo != NULL) pinfo->Alpha = 8; break; default: /*puts("glformat not set");*/ return 0; } if (trans == PNG_LUMINANCEALPHA) glformat = GL_LUMINANCE_ALPHA; if (mipmap == PNG_BUILDMIPMAPS) Build2DMipmaps(glcomponent, width, height, glformat, data, 1); else if (mipmap == PNG_SIMPLEMIPMAPS) Build2DMipmaps(glcomponent, width, height, glformat, data, 0); else glTexImage2D(GL_TEXTURE_2D, mipmap, glcomponent, width, height, 0, glformat, GL_UNSIGNED_BYTE, data); } else { png_bytep p, endp, q; int r, g, b, a; p = data, endp = p+width*height*3; q = data2 = (png_bytep) malloc(sizeof(png_byte)*width*height*4); if (pinfo != NULL) pinfo->Alpha = 8; #define FORSTART \ do { \ r = *p++; /*red */ \ g = *p++; /*green*/ \ b = *p++; /*blue */ \ *q++ = r; \ *q++ = g; \ *q++ = b; #define FOREND \ q++; \ } while (p != endp); #define ALPHA *q switch (trans) { case PNG_CALLBACK: FORSTART ALPHA = AlphaCallback((unsigned char) r, (unsigned char) g, (unsigned char) b); FOREND break; case PNG_STENCIL: FORSTART if (r == StencilRed && g == StencilGreen && b == StencilBlue) ALPHA = 0; else ALPHA = 255; FOREND break; case PNG_BLEND1: FORSTART a = r+g+b; if (a > 255) ALPHA = 255; else ALPHA = a; FOREND break; case PNG_BLEND2: FORSTART a = r+g+b; if (a > 255*2) ALPHA = 255; else ALPHA = a/2; FOREND break; case PNG_BLEND3: FORSTART ALPHA = (r+g+b)/3; FOREND break; case PNG_BLEND4: FORSTART a = r*r+g*g+b*b; if (a > 255) ALPHA = 255; else ALPHA = a; FOREND break; case PNG_BLEND5: FORSTART a = r*r+g*g+b*b; if (a > 255*2) ALPHA = 255; else ALPHA = a/2; FOREND break; case PNG_BLEND6: FORSTART a = r*r+g*g+b*b; if (a > 255*3) ALPHA = 255; else ALPHA = a/3; FOREND break; //HACK: disabling this for now /* case PNG_BLEND7: FORSTART a = r*r+g*g+b*b; if (a > 255*255) ALPHA = 255; else ALPHA = (int) (sqrt(float(a))); FOREND */ break; } #undef FORSTART #undef FOREND #undef ALPHA if (mipmap == PNG_BUILDMIPMAPS) Build2DMipmaps(4, width, height, GL_RGBA, data2, 1); else if (mipmap == PNG_SIMPLEMIPMAPS) Build2DMipmaps(4, width, height, GL_RGBA, data2, 0); else glTexImage2D(GL_TEXTURE_2D, mipmap, 4, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data2); free(data2); } glPixelStorei(GL_PACK_ALIGNMENT, pack); glPixelStorei(GL_UNPACK_ALIGNMENT, unpack); } /* OpenGL end */ png_read_end(png, endinfo); png_destroy_read_struct(&png, &info, &endinfo); free(data); return 1; }
static void load_texture(wip24_channel* channel, const char* src, const char* filter, const char* wrap, const char* vflip, const char* srgb) { glDeleteTextures(1, &channel->texture); char cached_file[4096]; snprintf(cached_file, sizeof(cached_file), "%s/.wip24/cache%s", get_home_dir(), src); FILE* cached = fopen(cached_file, "rb"); if (!cached) { char url[2048]; snprintf(url, sizeof(url), "shadertoy.com%s", src); void* img_data; size_t img_data_size; read_data(url, &img_data, &img_data_size); if (!img_data) goto error; cached = fopen(cached_file, "wb"); fwrite(img_data, img_data_size, 1, cached); free(img_data); } fclose(cached); int w, h, comp; stbi_uc* data = stbi_load(cached_file, &w, &h, &comp, 4); if (!data) { log_entry("Unable to load %s: %s\n", cached_file, stbi_failure_reason()); goto error; } if (!strcmp(vflip, "true")) for (unsigned int y = 0; y < h; y++) for (unsigned int x = 0; x < w; x++) { int temp = ((int*)data)[y*w+x]; ((int*)data)[y*w+x] = ((int*)data)[(h-y-1)*w+x]; ((int*)data)[(h-y-1)*w+x] = temp; } GLuint texture; glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); if (!strcmp(filter, "mipmap")) { glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); } else if (strcmp(filter, "linear")) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); } glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, strcmp(wrap, "repeat")?GL_CLAMP_TO_EDGE:GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, strcmp(wrap, "repeat")?GL_CLAMP_TO_EDGE:GL_REPEAT); glTexImage2D(GL_TEXTURE_2D, 0, strcmp(srgb, "true")?GL_RGBA:GL_SRGB8_ALPHA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); stbi_image_free(data); channel->texture = texture; channel->type = channel_image; return; error: channel->texture = 0; channel->type = channel_none; }