/** Initialize the texture */ void initTexture(void) { printf ("\nLoading texture..\n"); // Load a texture object (256x256 true color) bits = LoadDIBitmap("..\\res\\tiledbronze.bmp", &info); if (bits == (GLubyte *)0) { printf ("Error loading texture!\n\n"); return; } // Figure out the type of texture if (info->bmiHeader.biHeight == 1) type = GL_TEXTURE_1D; else type = GL_TEXTURE_2D; // Create and bind a texture object glGenTextures(1, &texture); glBindTexture(type, texture); // Create an RGBA image rgba = (GLubyte *)malloc(info->bmiHeader.biWidth * info->bmiHeader.biHeight * 4); i = info->bmiHeader.biWidth * info->bmiHeader.biHeight; for( rgbaptr = rgba, ptr = bits; i > 0; i--, rgbaptr += 4, ptr += 3) { rgbaptr[0] = ptr[2]; // windows BMP = BGR rgbaptr[1] = ptr[1]; rgbaptr[2] = ptr[0]; rgbaptr[3] = (ptr[0] + ptr[1] + ptr[2]) / 3; } // Set texture parameters glTexParameteri(type, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(type, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(type, GL_TEXTURE_WRAP_S, GL_REPEAT); // why not GL_REPEAT? glTexParameteri(type, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexImage2D(type, 0, 4, info->bmiHeader.biWidth, info->bmiHeader.biHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgba ); printf("Textura %d\n", texture); // Now loads the map: printf ("\nLoading map..\n"); // Load a texture object (256x256 true color) mapbits = LoadDIBitmap("..\\res\\modelmap.bmp", &mapinfo); if (mapbits == (GLubyte *)0) { printf ("Error loading map!\n\n"); return; } int x, z; //printf("Map Height = %d\n", mapinfo->bmiHeader.biHeight); int carFound = 0; for (x = 0; x < mapinfo->bmiHeader.biWidth; x++) { for (z = 0; z < mapinfo->bmiHeader.biHeight; z++) { if (((mapbits + x * z)[0] >= (GLubyte)250) && ((mapbits + x * z)[2] == ((GLubyte)000)) && ((mapbits + x * z)[1] == ((GLubyte)000))) { // Blue car printf("found blue car at (%d, %d)\n", x, z); blueCar_x = (float)x / (float)mapinfo->bmiHeader.biWidth; blueCar_z = (float)z / (float)mapinfo->bmiHeader.biHeight; carFound++; } if (((mapbits + x * z)[2] >= ((GLubyte)1)) && ((mapbits + x * z)[0] == ((GLubyte)000)) && ((mapbits + x * z)[1] == ((GLubyte)000))) { // Red car printf("found red car at (%d, %d)\n", x, z); redCar_x = (float)x / (float)mapinfo->bmiHeader.biWidth; redCar_z = (float)z / (float)mapinfo->bmiHeader.biHeight; carFound++; } } } if (carFound == 2) //found both cars foundCars = true; else { foundCars = false; printf("Error loading map: car(s) not found\n"); } printf("Textures ok.\n\n", texture); }
unsigned int GLES2D_CreateTexturePVRFromPointer( int *w, int *h, const void * const pointer, GLuint * const texName ) { const void * const texPtr = NULL; const unsigned int nLoadFromLevel = 0; const void *psTextureHeader = NULL; PVR_Texture_Header* psPVRHeader = (PVR_Texture_Header*)pointer; *w = (int) psPVRHeader->dwWidth; *h = (int) psPVRHeader->dwHeight; unsigned int u32NumSurfs; // perform checks for old PVR psPVRHeader if(psPVRHeader->dwHeaderSize!=sizeof(PVR_Texture_Header)) { // Header V1 if(psPVRHeader->dwHeaderSize==PVRTEX_V1_HEADER_SIZE) { // react to old psPVRHeader: i.e. fill in numsurfs as this is missing from old header printf("PVRTTexture:PVRTLoadPartialTextureFromPointer warning: this is an old pvr" " - you can use PVRTexTool to update its header.\n"); if(psPVRHeader->dwpfFlags&PVRTEX_CUBEMAP) u32NumSurfs = 6; else u32NumSurfs = 1; } else { // not a pvr at all printf("PVRTTexture:PVRTLoadPartialTextureFromPointer failed: not a valid pvr.\n"); return 0; } } else { // Header V2 if(psPVRHeader->dwNumSurfs<1) { // encoded with old version of PVRTexTool before zero numsurfs bug found. if(psPVRHeader->dwpfFlags & PVRTEX_CUBEMAP) u32NumSurfs = 6; else u32NumSurfs = 1; } else { u32NumSurfs = psPVRHeader->dwNumSurfs; } } GLuint textureName; GLenum textureFormat = 0; GLenum textureType = GL_RGB; int IsPVRTCSupported = 1; int IsBGRA8888Supported = 0; *texName = 0; // install warning value int IsCompressedFormatSupported = 0, IsCompressedFormat = 0; /* Only accept untwiddled data UNLESS texture format is PVRTC */ if ( ((psPVRHeader->dwpfFlags & PVRTEX_TWIDDLE) == PVRTEX_TWIDDLE) && ((psPVRHeader->dwpfFlags & PVRTEX_PIXELTYPE)!=OGL_PVRTC2) && ((psPVRHeader->dwpfFlags & PVRTEX_PIXELTYPE)!=OGL_PVRTC4) ) { // We need to load untwiddled textures -- hw will twiddle for us. printf("PVRTTexture:PVRTLoadPartialTextureFromPointer failed: texture should be untwiddled.\n"); return 0; } switch(psPVRHeader->dwpfFlags & PVRTEX_PIXELTYPE) { case OGL_RGBA_4444: textureFormat = GL_UNSIGNED_SHORT_4_4_4_4; textureType = GL_RGBA; break; case OGL_RGBA_5551: textureFormat = GL_UNSIGNED_SHORT_5_5_5_1; textureType = GL_RGBA; break; case OGL_RGBA_8888: textureFormat = GL_UNSIGNED_BYTE; textureType = GL_RGBA; break; /* New OGL Specific Formats Added */ case OGL_RGB_565: textureFormat = GL_UNSIGNED_SHORT_5_6_5; textureType = GL_RGB; break; case OGL_RGB_555: printf("PVRTTexture:PVRTLoadPartialTextureFromPointer failed: pixel type OGL_RGB_555 not supported.\n"); return 0; // Deal with exceptional case case OGL_RGB_888: textureFormat = GL_UNSIGNED_BYTE; textureType = GL_RGB; break; case OGL_I_8: textureFormat = GL_UNSIGNED_BYTE; textureType = GL_LUMINANCE; break; case OGL_AI_88: textureFormat = GL_UNSIGNED_BYTE; textureType = GL_LUMINANCE_ALPHA; break; case OGL_PVRTC2: if(IsPVRTCSupported) { IsCompressedFormatSupported = IsCompressedFormat = 1; textureFormat = psPVRHeader->dwAlphaBitMask==0 ? GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG : GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG ; // PVRTC2 } else { IsCompressedFormatSupported = 0; IsCompressedFormat = 1; textureFormat = GL_UNSIGNED_BYTE; textureType = GL_RGBA; printf("PVRTTexture:PVRTLoadPartialTextureFromPointer warning: PVRTC2 not supported. Converting to RGBA8888 instead.\n"); } break; case OGL_PVRTC4: if(IsPVRTCSupported) { IsCompressedFormatSupported = IsCompressedFormat = 1; textureFormat = psPVRHeader->dwAlphaBitMask==0 ? GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG : GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG ; // PVRTC4 } else { IsCompressedFormatSupported = 0; IsCompressedFormat = 1; textureFormat = GL_UNSIGNED_BYTE; textureType = GL_RGBA; printf("PVRTTexture:PVRTLoadPartialTextureFromPointer warning: PVRTC4 not supported. Converting to RGBA8888 instead.\n"); } break; case OGL_BGRA_8888: if(IsBGRA8888Supported) { textureFormat = GL_UNSIGNED_BYTE; textureType = GL_BGRA; break; } else { printf("PVRTTexture:PVRTLoadPartialTextureFromPointer failed: Unable to load GL_BGRA texture as extension GL_IMG_texture_format_BGRA8888 is unsupported.\n"); return 0; } default: // NOT SUPPORTED printf("PVRTTexture:PVRTLoadPartialTextureFromPointer failed: pixel type not supported.\n"); return 0; } // load the texture up glPixelStorei(GL_UNPACK_ALIGNMENT,1); // Never have row-aligned in psPVRHeaders glGenTextures(1, &textureName); // check that this data is cube map data or not. if(psPVRHeader->dwpfFlags & PVRTEX_CUBEMAP) { // not in OGLES you don't printf("PVRTTexture:PVRTLoadPartialTextureFromPointer failed: cube map textures are not available in OGLES1.x.\n"); return 0; } else { glBindTexture(GL_TEXTURE_2D, textureName); } if(glGetError()) { printf("PVRTTexture:PVRTLoadPartialTextureFromPointer failed: glBindTexture() failed.\n"); return 0; } int i; for(i=0; i<u32NumSurfs; i++) { char *theTexturePtr = (texPtr? (char*)texPtr : (char*)psPVRHeader + psPVRHeader->dwHeaderSize) + psPVRHeader->dwTextureDataSize * i; char *theTextureToLoad = 0; int nMIPMapLevel; int nTextureLevelsNeeded = (psPVRHeader->dwpfFlags & PVRTEX_MIPMAP)? psPVRHeader->dwMipMapCount : 0; unsigned int nSizeX= psPVRHeader->dwWidth, nSizeY = psPVRHeader->dwHeight; unsigned int CompressedImageSize = 0; for(nMIPMapLevel = 0; nMIPMapLevel <= nTextureLevelsNeeded; nSizeX = PVRT_MAX(nSizeX/2, (unsigned int)1), nSizeY = PVRT_MAX(nSizeY/2, (unsigned int)1), nMIPMapLevel++) { // Do Alpha-swap if needed theTextureToLoad = theTexturePtr; // Load the Texture /* If the texture is PVRTC then use GLCompressedTexImage2D */ if(IsCompressedFormat) { /* Calculate how many bytes this MIP level occupies */ if ((psPVRHeader->dwpfFlags & PVRTEX_PIXELTYPE)==OGL_PVRTC2) { CompressedImageSize = ( PVRT_MAX(nSizeX, PVRTC2_MIN_TEXWIDTH) * PVRT_MAX(nSizeY, PVRTC2_MIN_TEXHEIGHT) * psPVRHeader->dwBitCount + 7) / 8; } else {// PVRTC4 case CompressedImageSize = ( PVRT_MAX(nSizeX, PVRTC4_MIN_TEXWIDTH) * PVRT_MAX(nSizeY, PVRTC4_MIN_TEXHEIGHT) * psPVRHeader->dwBitCount + 7) / 8; } if(((signed int)nMIPMapLevel - (signed int)nLoadFromLevel) >= 0) { if(IsCompressedFormatSupported) { //if(psPVRHeader->dwpfFlags&PVRTEX_CUBEMAP) //{ // /* Load compressed texture data at selected MIP level */ // glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, nMIPMapLevel-nLoadFromLevel, textureFormat, nSizeX, nSizeY, 0, // CompressedImageSize, theTextureToLoad); //} //else { /* Load compressed texture data at selected MIP level */ glCompressedTexImage2D(GL_TEXTURE_2D, nMIPMapLevel-nLoadFromLevel, textureFormat, nSizeX, nSizeY, 0, CompressedImageSize, theTextureToLoad); } } else { // Convert PVRTC to 32-bit unsigned char *u8TempTexture = (unsigned char*)malloc(nSizeX*nSizeY*4); if ((psPVRHeader->dwpfFlags & PVRTEX_PIXELTYPE)==OGL_PVRTC2) { printf("PVRTCDecompress Unsupported\n"); //PVRTCDecompress(theTextureToLoad, 1, nSizeX, nSizeY, u8TempTexture); } else {// PVRTC4 case printf("PVRTCDecompress Unsupported\n"); //PVRTCDecompress(theTextureToLoad, 0, nSizeX, nSizeY, u8TempTexture); } //if(psPVRHeader->dwpfFlags&PVRTEX_CUBEMAP) //{// Load compressed cubemap data at selected MIP level // // Upload the texture as 32-bits // glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+i,nMIPMapLevel-nLoadFromLevel,GL_RGBA, // nSizeX,nSizeY,0, GL_RGBA,GL_UNSIGNED_BYTE,u8TempTexture); // FREE(u8TempTexture); //} //else {// Load compressed 2D data at selected MIP level // Upload the texture as 32-bits glTexImage2D(GL_TEXTURE_2D,nMIPMapLevel-nLoadFromLevel,GL_RGBA, nSizeX,nSizeY,0, GL_RGBA,GL_UNSIGNED_BYTE,u8TempTexture); FREE(u8TempTexture); } } } } else { if(((signed int)nMIPMapLevel - (signed int)nLoadFromLevel) >= 0) { //if(psPVRHeader->dwpfFlags&PVRTEX_CUBEMAP) //{ // /* Load uncompressed texture data at selected MIP level */ // glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+i,nMIPMapLevel-nLoadFromLevel,textureType,nSizeX,nSizeY, // 0, textureType,textureFormat,theTextureToLoad); //} //else { /* Load uncompressed texture data at selected MIP level */ glTexImage2D(GL_TEXTURE_2D,nMIPMapLevel-nLoadFromLevel,textureType,nSizeX,nSizeY,0, textureType,textureFormat,theTextureToLoad); } } } if(glGetError()) { printf("PVRTTexture:PVRTLoadPartialTextureFromPointer failed: glBindTexture() failed.\n"); return 0; } // offset the texture pointer by one mip-map level /* PVRTC case */ if ( IsCompressedFormat ) { theTexturePtr += CompressedImageSize; } else { /* New formula that takes into account bit counts inferior to 8 (e.g. 1 bpp) */ theTexturePtr += (nSizeX * nSizeY * psPVRHeader->dwBitCount + 7) / 8; } } } *texName = textureName; if(psTextureHeader) { *(PVR_Texture_Header*)psTextureHeader = *psPVRHeader; ((PVR_Texture_Header*)psTextureHeader)->dwPVR = PVRTEX_IDENTIFIER; ((PVR_Texture_Header*)psTextureHeader)->dwNumSurfs = u32NumSurfs; } return psPVRHeader->dwpfFlags|0x80000000; // PVR psPVRHeader flags with topmost bit set so that it is non-zero }
void Viewport3D::updateVolumeTexture() { if (!Segmentation::singleton().enabled) { return; } auto& seg = Segmentation::singleton(); int texLen = seg.volume_tex_len; if(seg.volume_tex_id == 0) { glGenTextures(1, &seg.volume_tex_id); glBindTexture(GL_TEXTURE_3D, seg.volume_tex_id); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, texLen, texLen, texLen, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); } static Profiler tex_gen_profiler; static Profiler dcfetch_profiler; static Profiler colorfetch_profiler; static Profiler occlusion_profiler; static Profiler tex_transfer_profiler; tex_gen_profiler.start(); // ----------------------------------------------------------- profiling const auto currentPosDc = state->viewerState->currentPosition.cube(Dataset::current().cubeEdgeLength, Dataset::current().scaleFactor); int cubeLen = Dataset::current().cubeEdgeLength; int M = state->M; int M_radius = (M - 1) / 2; GLubyte* colcube = new GLubyte[4*texLen*texLen*texLen]; std::tuple<uint64_t, std::tuple<uint8_t, uint8_t, uint8_t, uint8_t>> lastIdColor; state->protectCube2Pointer.lock(); dcfetch_profiler.start(); // ----------------------------------------------------------- profiling uint64_t** rawcubes = new uint64_t*[M*M*M]; for(int z = 0; z < M; ++z) for(int y = 0; y < M; ++y) for(int x = 0; x < M; ++x) { auto cubeIndex = z*M*M + y*M + x; const CoordOfCube cubeCoordRelative{x - M_radius, y - M_radius, z - M_radius}; rawcubes[cubeIndex] = reinterpret_cast<uint64_t*>(cubeQuery(state->cube2Pointer , Segmentation::singleton().layerId, Dataset::current().magIndex, currentPosDc + cubeCoordRelative)); } dcfetch_profiler.end(); // ----------------------------------------------------------- profiling colorfetch_profiler.start(); // ----------------------------------------------------------- profiling for(int z = 0; z < texLen; ++z) for(int y = 0; y < texLen; ++y) for(int x = 0; x < texLen; ++x) { Coordinate DcCoord{(x * M)/cubeLen, (y * M)/cubeLen, (z * M)/cubeLen}; auto cubeIndex = DcCoord.z*M*M + DcCoord.y*M + DcCoord.x; auto& rawcube = rawcubes[cubeIndex]; if(rawcube != nullptr) { auto indexInDc = ((z * M)%cubeLen)*cubeLen*cubeLen + ((y * M)%cubeLen)*cubeLen + (x * M)%cubeLen; auto indexInTex = z*texLen*texLen + y*texLen + x; auto subobjectId = rawcube[indexInDc]; if(subobjectId == std::get<0>(lastIdColor)) { auto idColor = std::get<1>(lastIdColor); colcube[4*indexInTex+0] = std::get<0>(idColor); colcube[4*indexInTex+1] = std::get<1>(idColor); colcube[4*indexInTex+2] = std::get<2>(idColor); colcube[4*indexInTex+3] = std::get<3>(idColor); } else if (seg.isSubObjectIdSelected(subobjectId)) { auto idColor = seg.colorObjectFromSubobjectId(subobjectId); std::get<3>(idColor) = 255; // ignore color alpha colcube[4*indexInTex+0] = std::get<0>(idColor); colcube[4*indexInTex+1] = std::get<1>(idColor); colcube[4*indexInTex+2] = std::get<2>(idColor); colcube[4*indexInTex+3] = std::get<3>(idColor); lastIdColor = std::make_tuple(subobjectId, idColor); } else { colcube[4*indexInTex+0] = 0; colcube[4*indexInTex+1] = 0; colcube[4*indexInTex+2] = 0; colcube[4*indexInTex+3] = 0; } } else { auto indexInTex = z*texLen*texLen + y*texLen + x; colcube[4*indexInTex+0] = 0; colcube[4*indexInTex+1] = 0; colcube[4*indexInTex+2] = 0; colcube[4*indexInTex+3] = 0; } } delete[] rawcubes; state->protectCube2Pointer.unlock(); colorfetch_profiler.end(); // ----------------------------------------------------------- profiling occlusion_profiler.start(); // ----------------------------------------------------------- profiling for(int z = 1; z < texLen - 1; ++z) for(int y = 1; y < texLen - 1; ++y) for(int x = 1; x < texLen - 1; ++x) { auto indexInTex = (z)*texLen*texLen + (y)*texLen + x; if(colcube[4*indexInTex+3] != 0) { for(int xi = -1; xi <= 1; ++xi) { auto othrIndexInTex = (z)*texLen*texLen + (y)*texLen + x+xi; if((xi != 0) && colcube[4*othrIndexInTex+3] != 0) { colcube[4*indexInTex+0] *= 0.95f; colcube[4*indexInTex+1] *= 0.95f; colcube[4*indexInTex+2] *= 0.95f; } } } } for(int z = 1; z < texLen - 1; ++z) for(int y = 1; y < texLen - 1; ++y) for(int x = 1; x < texLen - 1; ++x) { auto indexInTex = (z)*texLen*texLen + (y)*texLen + x; if(colcube[4*indexInTex+3] != 0) { for(int yi = -1; yi <= 1; ++yi) { auto othrIndexInTex = (z)*texLen*texLen + (y+yi)*texLen + x; if((yi != 0) && colcube[4*othrIndexInTex+3] != 0) { colcube[4*indexInTex+0] *= 0.95f; colcube[4*indexInTex+1] *= 0.95f; colcube[4*indexInTex+2] *= 0.95f; } } } } for(int z = 1; z < texLen - 1; ++z) for(int y = 1; y < texLen - 1; ++y) for(int x = 1; x < texLen - 1; ++x) { auto indexInTex = (z)*texLen*texLen + (y)*texLen + x; if(colcube[4*indexInTex+3] != 0) { for(int zi = -1; zi <= 1; ++zi) { auto othrIndexInTex = (z+zi)*texLen*texLen + (y)*texLen + x; if((zi != 0) && colcube[4*othrIndexInTex+3] != 0) { colcube[4*indexInTex+0] *= 0.95f; colcube[4*indexInTex+1] *= 0.95f; colcube[4*indexInTex+2] *= 0.95f; } } } } occlusion_profiler.end(); // ----------------------------------------------------------- profiling tex_transfer_profiler.start(); // ----------------------------------------------------------- profiling glBindTexture(GL_TEXTURE_3D, seg.volume_tex_id); glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, texLen, texLen, texLen, 0, GL_RGBA, GL_UNSIGNED_BYTE, colcube); delete[] colcube; tex_transfer_profiler.end(); // ----------------------------------------------------------- profiling tex_gen_profiler.end(); // ----------------------------------------------------------- profiling // --------------------- display some profiling information ------------------------ // qDebug() << "tex gen avg time: " << tex_gen_profiler.average_time()*1000 << "ms"; // qDebug() << " dc fetch : " << dcfetch_profiler.average_time()*1000 << "ms"; // qDebug() << " color fetch : " << colorfetch_profiler.average_time()*1000 << "ms"; // qDebug() << " occlusion : " << occlusion_profiler.average_time()*1000 << "ms"; // qDebug() << " tex transfer: " << tex_transfer_profiler.average_time()*1000 << "ms"; // qDebug() << "---------------------------------------------"; }
static struct ctx* create_context(void) { const char *vert_shader = "#version 100\n" "precision mediump float;\n" "uniform vec2 resolution;\n" "attribute vec4 pos;\n" "attribute vec2 uv;\n" "varying vec2 v_uv;\n" "void main() {\n" " mat4 ortho = mat4(" " 2.0/resolution.x, 0, 0, 0," " 0, -2.0/resolution.y, 0, 0," " 0, 0, -1, 0," " -1, 1, 0, 1" " );\n" " gl_Position = ortho * pos;\n" " v_uv = uv;\n" "}\n"; const char *frag_shader_dummy = "#version 100\n" "precision mediump float;\n" "void main() {\n" " gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" "}\n"; const char *frag_shader_cursor = "#version 100\n" "precision highp float;\n" "uniform sampler2D texture0;\n" "varying vec2 v_uv;\n" "void main() {\n" " vec4 palette[3];\n" " palette[0] = vec4(0.0, 0.0, 0.0, 1.0);\n" " palette[1] = vec4(1.0, 1.0, 1.0, 1.0);\n" " palette[2] = vec4(0.0, 0.0, 0.0, 0.0);\n" " gl_FragColor = palette[int(texture2D(texture0, v_uv).r * 256.0)];\n" "}\n"; const char *frag_shader_rgb = "#version 100\n" "precision mediump float;\n" "uniform sampler2D texture0;\n" "uniform float dim;\n" "varying vec2 v_uv;\n" "void main() {\n" " gl_FragColor = vec4(texture2D(texture0, v_uv).rgb * dim, 1.0);\n" "}\n"; const char *frag_shader_rgba = "#version 100\n" "precision mediump float;\n" "uniform sampler2D texture0;\n" "uniform float dim;\n" "varying vec2 v_uv;\n" "void main() {\n" " vec4 col = texture2D(texture0, v_uv);\n" " gl_FragColor = vec4(col.rgb * dim, col.a);\n" "}\n"; const char *frag_shader_egl = "#version 100\n" "#extension GL_OES_EGL_image_external : require\n" "precision mediump float;\n" "uniform samplerExternalOES texture0;\n" "uniform float dim;\n" "varying vec2 v_uv;\n" "void main()\n" "{\n" " vec4 col = texture2D(texture0, v_uv);\n" " gl_FragColor = vec4(col.rgb * dim, col.a)\n;" "}\n"; #define FRAGMENT_CONVERT_YUV \ " y *= dim;\n" \ " u *= dim;\n" \ " v *= dim;\n" \ " gl_FragColor.r = y + 1.59602678 * v;\n" \ " gl_FragColor.g = y - 0.39176229 * u - 0.81296764 * v;\n" \ " gl_FragColor.b = y + 2.01723214 * u;\n" \ " gl_FragColor.a = 1.0;\n" const char *frag_shader_y_uv = "#version 100\n" "precision mediump float;\n" "uniform sampler2D texture0;\n" "uniform sampler2D texture1;\n" "uniform float dim;\n" "varying vec2 v_uv;\n" "void main() {\n" " float y = 1.16438356 * (texture2D(texture0, v_uv).x - 0.0625);\n" " float u = texture2D(texture1, v_uv).r - 0.5;\n" " float v = texture2D(texture1, v_uv).g - 0.5;\n" FRAGMENT_CONVERT_YUV "}\n"; const char *frag_shader_y_u_v = "#version 100\n" "precision mediump float;\n" "uniform sampler2D texture0;\n" "uniform sampler2D texture1;\n" "uniform sampler2D texture2;\n" "uniform float dim;\n" "varying vec2 v_uv;\n" "void main() {\n" " float y = 1.16438356 * (texture2D(texture0, v_uv).x - 0.0625);\n" " float u = texture2D(texture1, v_uv).x - 0.5;\n" " float v = texture2D(texture2, v_uv).x - 0.5;\n" FRAGMENT_CONVERT_YUV "}\n"; const char *frag_shader_y_xuxv = "#version 100\n" "precision mediump float;\n" "uniform sampler2D texture0;\n" "uniform sampler2D texture1;\n" "uniform float dim;\n" "varying vec2 v_uv;\n" "void main() {\n" " float y = 1.16438356 * (texture2D(texture0, v_uv).x - 0.0625);\n" " float u = texture2D(texture1, v_uv).g - 0.5;\n" " float v = texture2D(texture1, v_uv).a - 0.5;\n" FRAGMENT_CONVERT_YUV "}\n"; struct ctx *context; if (!(context = calloc(1, sizeof(struct ctx)))) return NULL; const char *str; str = (const char*)GL_CALL(glGetString(GL_VERSION)); wlc_log(WLC_LOG_INFO, "GL version: %s", str ? str : "(null)"); str = (const char*)GL_CALL(glGetString(GL_VENDOR)); wlc_log(WLC_LOG_INFO, "GL vendor: %s", str ? str : "(null)"); /** TODO: Should be available in GLES3 */ #if 0 GL_CALL(glGetInternalFormativ(GL_TEXTURE_2D, GL_RGBA, GL_TEXTURE_IMAGE_FORMAT, 1, &context->preferred_format)); GL_CALL(glGetInternalFormativ(GL_TEXTURE_2D, GL_RGBA, GL_TEXTURE_IMAGE_TYPE, 1, &context->preferred_type)); wlc_log(WLC_LOG_INFO, "Preferred texture format: %d", context->preferred_format); wlc_log(WLC_LOG_INFO, "Preferred texture type: %d", context->preferred_type); #endif context->extensions = (const char*)GL_CALL(glGetString(GL_EXTENSIONS)); if (!has_extension(context, "GL_OES_EGL_image_external")) { wlc_log(WLC_LOG_WARN, "gles2: GL_OES_EGL_image_external not available"); frag_shader_egl = frag_shader_dummy; } const struct { const char *vert; const char *frag; } map[PROGRAM_LAST] = { { vert_shader, frag_shader_rgb }, // PROGRAM_RGB { vert_shader, frag_shader_rgba }, // PROGRAM_RGBA { vert_shader, frag_shader_egl }, // PROGRAM_EGL { vert_shader, frag_shader_y_uv }, // PROGRAM_Y_UV { vert_shader, frag_shader_y_u_v }, // PROGRAM_Y_U_V { vert_shader, frag_shader_y_xuxv }, // PROGRAM_Y_XUXV { vert_shader, frag_shader_cursor }, // PROGRAM_CURSOR }; for (GLuint i = 0; i < PROGRAM_LAST; ++i) { GLuint vert = create_shader(map[i].vert, GL_VERTEX_SHADER); GLuint frag = create_shader(map[i].frag, GL_FRAGMENT_SHADER); context->programs[i].obj = glCreateProgram(); GL_CALL(glAttachShader(context->programs[i].obj, vert)); GL_CALL(glAttachShader(context->programs[i].obj, frag)); GL_CALL(glLinkProgram(context->programs[i].obj)); GL_CALL(glDeleteShader(vert)); GL_CALL(glDeleteShader(frag)); GLint status; GL_CALL(glGetProgramiv(context->programs[i].obj, GL_LINK_STATUS, &status)); if (!status) { GLsizei len; char log[1024]; GL_CALL(glGetProgramInfoLog(context->programs[i].obj, sizeof(log), &len, log)); wlc_log(WLC_LOG_ERROR, "Linking:\n%*s\n", len, log); abort(); } set_program(context, i); GL_CALL(glBindAttribLocation(context->programs[i].obj, 0, "pos")); GL_CALL(glBindAttribLocation(context->programs[i].obj, 1, "uv")); for (int u = 0; u < UNIFORM_LAST; ++u) { context->programs[i].uniforms[u] = GL_CALL(glGetUniformLocation(context->programs[i].obj, uniform_names[u])); } GL_CALL(glUniform1i(context->programs[i].uniforms[UNIFORM_TEXTURE0], 0)); GL_CALL(glUniform1i(context->programs[i].uniforms[UNIFORM_TEXTURE1], 1)); GL_CALL(glUniform1i(context->programs[i].uniforms[UNIFORM_TEXTURE2], 2)); } struct { GLenum format; GLuint w, h; GLenum type; const void *data; } images[TEXTURE_LAST] = { { GL_LUMINANCE, 1, 1, GL_UNSIGNED_BYTE, NULL }, // TEXTURE_BLACK { GL_LUMINANCE, 14, 14, GL_UNSIGNED_BYTE, cursor_palette }, // TEXTURE_CURSOR { GL_RGBA, 0, 0, GL_UNSIGNED_BYTE, NULL }, // TEXTURE_FAKEFB }; GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1)); GL_CALL(glGenTextures(TEXTURE_LAST, context->textures)); for (GLuint i = 0; i < TEXTURE_LAST; ++i) { GL_CALL(glBindTexture(GL_TEXTURE_2D, context->textures[i])); GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, images[i].format, images[i].w, images[i].h, 0, images[i].format, images[i].type, images[i].data)); } GL_CALL(glEnableVertexAttribArray(0)); GL_CALL(glEnableVertexAttribArray(1)); GL_CALL(glGenFramebuffers(1, &context->clear_fbo)); GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, context->clear_fbo)); GL_CALL(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, context->textures[TEXTURE_FAKEFB], 0)); GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, 0)); GL_CALL(glEnable(GL_BLEND)); GL_CALL(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA)); GL_CALL(glClearColor(0.0, 0.0, 0.0, 0.0)); return context; }
GPUTexture *GPU_texture_create_3D(int w, int h, int depth, float *fpixels) { GPUTexture *tex; GLenum type, format, internalformat; void *pixels = NULL; float vfBorderColor[4] = {0.0f, 0.0f, 0.0f, 0.0f}; tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture"); tex->w = w; tex->h = h; tex->depth = depth; tex->number = -1; tex->refcount = 1; tex->target = GL_TEXTURE_3D; glGenTextures(1, &tex->bindcode); if (!tex->bindcode) { fprintf(stderr, "GPUTexture: texture create failed: %d\n", (int)glGetError()); GPU_texture_free(tex); return NULL; } if (!GPU_non_power_of_two_support()) { tex->w = larger_pow2(tex->w); tex->h = larger_pow2(tex->h); tex->depth = larger_pow2(tex->depth); } tex->number = 0; glBindTexture(tex->target, tex->bindcode); GPU_print_error("3D glBindTexture"); type = GL_FLOAT; // GL_UNSIGNED_BYTE format = GL_RED; internalformat = GL_INTENSITY; //if (fpixels) // pixels = GPU_texture_convert_pixels(w*h*depth, fpixels); glTexImage3D(tex->target, 0, internalformat, tex->w, tex->h, tex->depth, 0, format, type, 0); GPU_print_error("3D glTexImage3D"); if (fpixels) { glTexSubImage3D(tex->target, 0, 0, 0, 0, w, h, depth, format, type, fpixels); GPU_print_error("3D glTexSubImage3D"); } glTexParameterfv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, vfBorderColor); GPU_print_error("3D GL_TEXTURE_BORDER_COLOR"); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); GPU_print_error("3D GL_LINEAR"); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); GPU_print_error("3D GL_CLAMP_TO_BORDER"); if (pixels) MEM_freeN(pixels); if (tex) GPU_texture_unbind(tex); return tex; }
bool write_quad_model_as_bmp(struct mg_connection *conn, quad_model* model) { int width = 640; int height = 320; HWND hWND = CreateWindow(_T("BUTTON"), NULL, WS_OVERLAPPEDWINDOW /*| WS_VISIBLE*/ | CS_OWNDC, 0, 0, width, height, NULL, NULL, NULL, NULL); HDC hDC = GetDC(hWND); int pixelForamt = ChoosePixelFormatEx(hDC, false); PIXELFORMATDESCRIPTOR pfd = {0}; BOOL bRet = SetPixelFormat(hDC, pixelForamt, &pfd); HGLRC hRC = wglCreateContext(hDC); bRet = wglMakeCurrent(hDC, hRC); GLenum err = glewInit( ); if( GLEW_OK != err ) return false; if( !GLEW_VERSION_2_1 ) // check that the machine supports the 2.1 API. return false; // // if( !GLEW_ARB_framebuffer_object) // check that the machine supports the 2.1 API. // return false; //if( !GLEW_VERSION_3_1 ) // check that the machine supports the 2.1 API. // return false; // create a texture object GLuint textureId = 0; glGenTextures(1, &textureId); glBindTexture(GL_TEXTURE_2D, textureId); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0); // create a renderbuffer object to store depth info GLuint rboId = 0; glGenRenderbuffersEXT(1, &rboId); glBindRenderbufferEXT(GL_RENDERBUFFER, rboId); glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height); glBindRenderbufferEXT(GL_RENDERBUFFER, 0); // create a framebuffer object GLuint fboId = 0; glGenFramebuffersEXT(1, &fboId); glBindFramebufferEXT(GL_FRAMEBUFFER, fboId); // attach the texture to FBO color attachment point glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0); // attach the renderbuffer to depth attachment point glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboId); bool fboUsed = true; // check FBO status GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER); if(status != GL_FRAMEBUFFER_COMPLETE) fboUsed = false; glBindFramebufferEXT(GL_FRAMEBUFFER, fboId); glViewport(0, 0, width, height); glClearColor(1, 1, 0, 1); //glPushAttrib(GL_COLOR_BUFFER_BIT | GL_PIXEL_MODE_BIT); // for GL_DRAW_BUFFER and GL_READ_BUFFER //glDrawBuffer(GL_BACK); //glReadBuffer(GL_BACK); assert(0 == glGetError()); //glClear(GL_FRONT_AND_BACK); assert(0 == glGetError()); glMatrixMode(GL_PROJECTION); glLoadIdentity(); double aspect = width / (double)height; glOrtho(-3, 3, -3/aspect, 3/aspect, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslated(-1.5, 0, 0); //glUseProgram(0); DrawQuad(); glTranslated(1.5, 0, 0); //glPopAttrib(); quad_modelRender qr; qr.Setquad_model(model); char logbuffer[1024] = ""; int loglen = ARRAYSIZE(logbuffer); qr.Initialize(logbuffer, &loglen); assert(0 == glGetError()); qr.Render(); assert(0 == glGetError()); glFinish(); GLenum error = glGetError(); int bits = 24; std::vector<unsigned char> buffer; buffer.resize( width * height * bits / 8 ); glBindTexture(GL_TEXTURE_2D, textureId); glPixelStorei(GL_PACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGetTexImage(GL_TEXTURE_2D, 0, GL_BGR, GL_UNSIGNED_BYTE, &buffer[0]); glBindTexture(GL_TEXTURE_2D, 0); glBindFramebufferEXT(GL_FRAMEBUFFER, 0); wglMakeCurrent(NULL, NULL); wglDeleteContext(hRC); ReleaseDC(hWND, hDC); //CloseWindow(hWND); BITMAPFILEHEADER bfh = {0}; bfh.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + buffer.size(); bfh.bfType = 0x4D42; bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER); BITMAPINFOHEADER bih = {}; bih.biSize = sizeof(BITMAPINFOHEADER); bih.biWidth= width; bih.biHeight= height; bih.biPlanes= 1; bih.biBitCount= bits; // image/bmp mg_write(conn, &bfh, sizeof(bfh)); mg_write(conn, &bih, sizeof(bih)); mg_write(conn, &buffer[0], buffer.size()); }
//Set up variables bool DemoInit() { SetUpARB_multitexture(); SetUpARB_texture_cube_map(); SetUpEXT_compiled_vertex_array(); SetUpEXT_texture_edge_clamp(); SetUpNV_register_combiners(); SetUpNV_vertex_program(); SetUpNV_texture_shader(); if( !GL_ARB_texture_cube_map || !GL_EXT_compiled_vertex_array || !GL_ARB_multitexture || !GL_NV_register_combiners || !GL_NV_vertex_program || !GL_EXT_texture_edge_clamp) return false; //Get some useful info int maxTextureUnitsARB; glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnitsARB); int maxGeneralCombinersNV; glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &maxGeneralCombinersNV); if( GL_NV_texture_shader && maxTextureUnitsARB>=4 && maxGeneralCombinersNV>=4) { Util::log("Higher Quality bump mapping supported"); paths1And2Supported=true; currentTechnique=TEXTURE_LOOKUP; } else Util::log("Higher Quality bump mapping unsupported"); //Load Textures //normal map - put gloss map in alpha normalMapImage.Load("Normal Map.bmp"); normalMapImage.LoadAlphaTGA("gloss.tga"); glGenTextures(1, &normalMapTexture); glBindTexture(GL_TEXTURE_2D, normalMapTexture); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, normalMapImage.width, normalMapImage.height, 0, normalMapImage.format, GL_UNSIGNED_BYTE, normalMapImage.data); 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_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); //decal decalImage.Load("Decal.bmp"); glGenTextures(1, &decalTexture); glBindTexture(GL_TEXTURE_2D, decalTexture); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, decalImage.width, decalImage.height, 0, decalImage.format, GL_UNSIGNED_BYTE, decalImage.data); 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_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); //Create normalisation cube map glGenTextures(1, &normalisationCubeMap); glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap); GenerateNormalisationCubeMap(); glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); if(paths1And2Supported) { //Create signed normap map //Create space for signed data GLbyte * signedData=new GLbyte[normalMapImage.width*normalMapImage.height*3]; if(!signedData) { Util::log("Unable to allocate memory for signed normal map data"); return false; } //Convert unsigned to signed RGB data, ignoring alpha for(unsigned int i=0; i<normalMapImage.width*normalMapImage.height; i++) { for(unsigned int j=0; j<3; j++) { signedData[i*3+j]=normalMapImage.data[i*4+j]-128; } } glGenTextures(1, &signedNormalMap); glBindTexture(GL_TEXTURE_2D, signedNormalMap); glTexImage2D( GL_TEXTURE_2D, 0, GL_SIGNED_RGBA8_NV, normalMapImage.width, normalMapImage.height, 0, GL_RGB, GL_BYTE, signedData); 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_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); if(signedData) delete [] signedData; signedData=NULL; } //make sure texImage2D is finished with normalMapImage before we change the image glFinish(); //Flatten the bumps in the normal map for(unsigned int i=0; i<normalMapImage.width*normalMapImage.height; ++i) { normalMapImage.data[i*4]=128; normalMapImage.data[i*4+1]=128; normalMapImage.data[i*4+2]=255; } //create flat normal map with gloss map in alpha glGenTextures(1, &flatNormalMap); glBindTexture(GL_TEXTURE_2D, flatNormalMap); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, normalMapImage.width, normalMapImage.height, 0, normalMapImage.format, GL_UNSIGNED_BYTE, normalMapImage.data); 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_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); if(paths1And2Supported) { //Create signed flat normap map //Create space for signed data GLbyte * signedData=new GLbyte[normalMapImage.width*normalMapImage.height*3]; if(!signedData) { Util::log("Unable to allocate memory for signed normal map data"); return false; } //Convert unsigned to signed RGB data, ignoring alpha for(unsigned int i=0; i<normalMapImage.width*normalMapImage.height; i++) { for(unsigned int j=0; j<3; j++) { signedData[i*3+j]=normalMapImage.data[i*4+j]-128; } } glGenTextures(1, &signedFlatNormalMap); glBindTexture(GL_TEXTURE_2D, signedFlatNormalMap); glTexImage2D( GL_TEXTURE_2D, 0, GL_SIGNED_RGBA8_NV, normalMapImage.width, normalMapImage.height, 0, GL_RGB, GL_BYTE, signedData); 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_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); if(signedData) delete [] signedData; signedData=NULL; //Create specular ramp texture unsigned char specularRampValues[256]; for(unsigned int i=0; i<256; i++) { double poweredValue=(double)i/255; //raise to 16th power poweredValue= poweredValue*poweredValue*poweredValue*poweredValue* poweredValue*poweredValue*poweredValue*poweredValue* poweredValue*poweredValue*poweredValue*poweredValue* poweredValue*poweredValue*poweredValue*poweredValue; specularRampValues[i] = char(poweredValue*255); } glGenTextures(1, &specularRamp); glBindTexture(GL_TEXTURE_2D, specularRamp); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, 256, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, specularRampValues); 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_REPEAT); } //reset timer for start timer.Reset(); return true; }
GLuint LoadTGA(const char *file_path) // load TGA file to memory { std::ifstream fileStream(file_path, std::ios::binary); if(!fileStream.is_open()) { std::cout << "Impossible to open " << file_path << ". Are you in the right directory ?\n"; return 0; } GLubyte header[ 18 ]; // first 6 useful header bytes GLuint bytesPerPixel; // number of bytes per pixel in TGA gile GLuint imageSize; // for setting memory GLubyte * data; GLuint texture = 0; unsigned width, height; fileStream.read((char*)header, 18); width = header[12] + header[13] * 256; height = header[14] + header[15] * 256; if( width <= 0 || // is width <= 0 height <= 0 || // is height <=0 (header[16] != 24 && header[16] != 32)) // is TGA 24 or 32 Bit { fileStream.close(); // close file on failure std::cout << "File header error.\n"; return 0; } bytesPerPixel = header[16] / 8; //divide by 8 to get bytes per pixel imageSize = width * height * bytesPerPixel; // calculate memory required for TGA data data = new GLubyte[ imageSize ]; fileStream.seekg(18, std::ios::beg); fileStream.read((char *)data, imageSize); fileStream.close(); glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); if(bytesPerPixel == 3) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_BGR, GL_UNSIGNED_BYTE, data); else //bytesPerPixel == 4 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, data); glGenerateMipmap(GL_TEXTURE_2D); float maxAnisotropy = 1.f; glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (GLint)maxAnisotropy); //to do: modify the texture parameters code from here 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); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); //end of modifiable code delete []data; return texture; }
GLTexture::GLTexture() { glGenTextures(1, &id); }
static GLboolean srgb_tex_test(int srgb_format) { GLboolean pass = GL_TRUE; float green[] = {0, 0.3, 0.0, 0}; float expected_green[4]; float expected_srgb_green[4]; GLuint tex; GLboolean have_decode; have_decode = piglit_is_extension_supported("GL_EXT_texture_sRGB_decode"); glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); fill_level(0, green); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glClearColor(0.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glEnable(GL_TEXTURE_2D); piglit_draw_rect_tex(0, 0, 20, 20, 0, 0, 1, 1); if (have_decode) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, GL_SKIP_DECODE_EXT); piglit_draw_rect_tex(20, 0, 20, 20, 0, 0, 1, 1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SRGB_DECODE_EXT, GL_DECODE_EXT); piglit_draw_rect_tex(40, 0, 20, 20, 0, 0, 1, 1); } memcpy(expected_green, green, sizeof(float) * 4); memcpy(expected_srgb_green, green, sizeof(float) * 4); expected_srgb_green[1] = nonlinear_to_linear(255.0*green[1]); if (!piglit_probe_rect_rgb(0, 0, 20, 20, expected_srgb_green)) pass = GL_FALSE; if (have_decode) { if (!piglit_probe_rect_rgb(20, 0, 20, 20, expected_green)) pass = GL_FALSE; if (!piglit_probe_rect_rgb(40, 0, 20, 20, expected_srgb_green)) pass = GL_FALSE; } glDeleteTextures(1, &tex); piglit_present_results(); return pass; }
/** * Function for initialization. */ GLUSboolean init(GLUSvoid) { // Points of a cube. GLfloat points[] = { -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f, -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, -0.5f, -0.5f, -0.5f, 1.0f, -0.5f, -0.5f, +0.5f, 1.0f, -0.5f, +0.5f, +0.5f, 1.0f, -0.5f, +0.5f, -0.5f, 1.0f, +0.5f, -0.5f, -0.5f, 1.0f, +0.5f, -0.5f, +0.5f, 1.0f, +0.5f, +0.5f, +0.5f, 1.0f, +0.5f, +0.5f, -0.5f, 1.0f }; // Normals of a cube. GLfloat normals[] = { +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, -1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f, +1.0f, +0.0f, +0.0f }; // The associated indices. GLuint indices[] = { 0, 2, 1, 0, 3, 2, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 15, 14, 12, 14, 13, 16, 17, 18, 16, 18, 19, 20, 23, 22, 20, 22, 21 }; GLUStgaimage image; GLUStextfile vertexSource; GLUStextfile fragmentSource; // Load the source of the vertex shader. glusLoadTextFile("../src/Example07/Vertex.vs", &vertexSource); // Load the source of the fragment shader. glusLoadTextFile("../src/Example07/Fragment.fs", &fragmentSource); // Build and ... glusBuildProgram(&g_program, (const GLUSchar**) &vertexSource.text, 0, 0, 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); // 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_inverseCameraLocation = glGetUniformLocation(g_program.program, "inverseCameraMatrix"); // http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml g_cubemapLocation = glGetUniformLocation(g_program.program, "cubemap"); // 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/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, 24 * 4 * sizeof(GLfloat), (GLfloat*) points, 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, 24 * 3 * sizeof(GLfloat), (GLfloat*) normals, 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, 6 * 2 * 3 * sizeof(GLuint), (GLuint*) indices, GL_STATIC_DRAW); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/gentextures.html glGenTextures(1, &g_cubemap); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html glBindTexture(GL_TEXTURE_CUBE_MAP, g_cubemap); glusLoadTgaImage("cm_left.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_right.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_top.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_bottom.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_back.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data); glusDestroyTgaImage(&image); glusLoadTgaImage("cm_front.tga", &image); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 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_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT); // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT); // http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml glUseProgram(g_program.program); // 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/glUniform.xml glUniform1i(g_cubemapLocation, 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; }
void CGLTexture::CreateTextureObject() { glGenTextures(1, (GLuint*) &m_texture); }
void loadTexture(){ Image *image1; // allocate space for texture image1 = (Image *) malloc(sizeof(Image)); if (image1 == NULL) { printf("Error allocating space for image"); exit(0); } if (!ImageLoad("media/road1.bmp", image1)) { exit(1); } // if(image1 == NULL){ // printf("Image was not returned from loadTexture\n"); // exit(0); // } makeCheckImage(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Create Texture glGenTextures(1, &texture[0]); glBindTexture(GL_TEXTURE_2D, texture[0]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //scale linearly when image bigger than texture glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //scale linearly when image smalled than texture glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data); if (!ImageLoad("media/grass01.bmp", image1)) { exit(1); } // if(image1 == NULL){ // printf("Image was not returned from loadTexture\n"); // exit(0); // } makeCheckImage(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Create Texture glGenTextures(2, &texture[1]); glBindTexture(GL_TEXTURE_2D, texture[1]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //scale linearly when image bigger than texture glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //scale linearly when image smalled than texture glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data); if (!ImageLoad("media/night-sky.bmp", image1)) { exit(1); } // if(image1 == NULL){ // printf("Image was not returned from loadTexture\n"); // exit(0); // } makeCheckImage(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Create Texture glGenTextures(3, &texture[2]); glBindTexture(GL_TEXTURE_2D, texture[2]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //scale linearly when image bigger than texture glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //scale linearly when image smalled than texture glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data); /* if (!ImageLoad("media/background02.bmp", image1)) { exit(1); } // if(image1 == NULL){ // printf("Image was not returned from loadTexture\n"); // exit(0); // } makeCheckImage(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Create Texture glGenTextures(3, &texture[3]); glBindTexture(GL_TEXTURE_2D, texture[3]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //scale linearly when image bigger than texture glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //scale linearly when image smalled than texture glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data); */ // glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); }
void image_load_from_ressource(image_p image, ressource_p ressource) { int data_size = ressource->buffer_length; char* buffer = ressource->stream; SDL_RWops *container = SDL_RWFromMem(buffer, data_size); SDL_Surface *surface = IMG_Load_RW(container, 1); SDL_Surface *format_surface = 0; if (!surface) { LOGF("Error while loading texture %s", SDL_GetError()); return; } image->width = surface->w; image->height = surface->h; image->storagetype = GL_RGBA; image->minfilter = GL_NEAREST; image->magfilter = GL_NEAREST; image->wrap_s = GL_CLAMP; image->wrap_t = GL_CLAMP; SDL_PixelFormat format; format.palette = 0; format.colorkey = 0; format.alpha = 0; format.BitsPerPixel = 32; format.BytesPerPixel = 4; if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { format.Rmask = 0xFF000000; format.Rshift = 0; format.Rloss = 0; format.Gmask = 0x00FF0000; format.Gshift = 8; format.Gloss = 0; format.Bmask = 0x0000FF00; format.Bshift = 16; format.Bloss = 0; format.Amask = 0x000000FF; format.Ashift = 24; format.Aloss = 0; } else { format.Rmask = 0x000000FF; format.Rshift = 24; format.Rloss = 0; format.Gmask = 0x0000FF00; format.Gshift = 16; format.Gloss = 0; format.Bmask = 0x00FF0000; format.Bshift = 8; format.Bloss = 0; format.Amask = 0xFF000000; format.Ashift = 0; format.Aloss = 0; } format_surface = SDL_ConvertSurface(surface, &format, SDL_SWSURFACE); //destsurf = SDL::fliphorizontal(destsurf); glGenTextures(1, &image->texture); glBindTexture(GL_TEXTURE_2D, image->texture); glTexImage2D( GL_TEXTURE_2D, 0, 4, image->width, image->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, format_surface->pixels ); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, image->wrap_s); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, image->wrap_t); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, image->minfilter); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, image->magfilter); if (image->mipmap) { gluBuild2DMipmaps( GL_TEXTURE_2D, image->storagetype, image->width, image->height, image->storagetype, GL_UNSIGNED_BYTE, format_surface->pixels ); } SDL_FreeSurface(format_surface); SDL_FreeSurface(surface); }
/******************************************************************************* * LoadTGA *******************************************************************************/ int LoadTGA (char *cpFilename, GLuint &uTextureId) { FILE* fpFile; // Input file int iFileLength; // Length of the file byte* bpData; // Buffer int iCurrentByte = 0; // Current byte in the buffer int iWidth; // Image width int iHeight; // Image height byte* bpBits = 0; // Pointer To The Bitmap Bits int iHeaderSize = 18; // Headersize of a targa file // Print status VerbosePrintf ("Reading texture: %s", cpFilename); // Open file if ((fpFile = fopen (cpFilename, "rb" )) == NULL) { // Print error ErrorPrintf ("Input file could not be opened"); // Return error return (-1); } // Get file length fseek (fpFile, 0, SEEK_END); iFileLength = ftell (fpFile); // Reset file pointer to begin fseek (fpFile, 0, SEEK_SET); // Allocate buffer bpData = new byte[iFileLength]; // Read buffer fread (bpData, sizeof (char), iFileLength, fpFile); // Set height and with iWidth = (int)bpData[12] + ((int)bpData[13] * 256); iHeight = (int)bpData[14] + ((int)bpData[15] * 256); VerbosePrintf ("Width, Height, Bpp: %d, %d, %d", iWidth, iHeight, bpData[16]); // Allocate bits bpBits = new byte[iWidth*iHeight*4]; // If targa 32-bits per pixel if ((int)bpData[16] == 32) { for (int iX = 0; iX < iWidth; iX++) { for (int iY = 0; iY < iHeight; iY++) { // Get RGB info bpBits[((iX+(iY*iWidth))*4)+2] = ((int)(bpData[(iX+(iY*iWidth))*4+iHeaderSize])); bpBits[((iX+(iY*iWidth))*4)+1] = ((int)(bpData[(iX+(iY*iWidth))*4+iHeaderSize+1])); bpBits[((iX+(iY*iWidth))*4)] = ((int)(bpData[(iX+(iY*iWidth))*4+iHeaderSize+2])); bpBits[((iX+(iY*iWidth))*4)+3] = ((int)(bpData[(iX+(iY*iWidth))*4+iHeaderSize+3])); } } // Else if targa 24-bits per pixel } else if ((int)bpData[16] == 24) { for (int iX = 0; iX < iWidth; iX++) { for (int iY = 0; iY < iHeight; iY++) { // Get RGB info bpBits[((iX+(iY*iWidth))*4)+2] = ((int)(bpData[(iX+(iY*iWidth))*3+iHeaderSize])); bpBits[((iX+(iY*iWidth))*4)+1] = ((int)(bpData[(iX+(iY*iWidth))*3+iHeaderSize+1])); bpBits[((iX+(iY*iWidth))*4)] = ((int)(bpData[(iX+(iY*iWidth))*3+iHeaderSize+2])); // Check transparency if ((((int)(bpData[(iX+(iY*iWidth))*3+iHeaderSize])) == 0) && (((int)(bpData[(iX+(iY*iWidth))*3+iHeaderSize+1])) == 0) && (((int)(bpData[(iX+(iY*iWidth))*3+iHeaderSize+2])) == 0)) { bpBits[((iX+(iY*iWidth))*4)+3] = 0; } else { bpBits[((iX+(iY*iWidth))*4)+3] = 255; } } } } // Free temporary buffer delete [] bpData; // Create the texture glGenTextures (1, &uTextureId); // Typical Texture Generation Using Data From The Bitmap glBindTexture(GL_TEXTURE_2D, uTextureId); 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, iWidth, iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, bpBits); // Return no error return (0); }
//---------------------------------------------------------- void ofTexture::allocate(int w, int h, int internalGlDataType, bool bUseARBExtention){ //our graphics card might not support arb so we have to see if it is supported. #ifndef TARGET_OPENGLES if (bUseARBExtention && GLEE_ARB_texture_rectangle){ texData.tex_w = w; texData.tex_h = h; texData.tex_t = w; texData.tex_u = h; texData.textureTarget = GL_TEXTURE_RECTANGLE_ARB; } else #endif { //otherwise we need to calculate the next power of 2 for the requested dimensions //ie (320x240) becomes (512x256) texData.tex_w = ofNextPow2(w); texData.tex_h = ofNextPow2(h); texData.tex_t = 1.0f; texData.tex_u = 1.0f; texData.textureTarget = GL_TEXTURE_2D; } texData.glTypeInternal = internalGlDataType; // MEMO: todo, add more types switch(texData.glTypeInternal) { #ifndef TARGET_OPENGLES case GL_RGBA32F_ARB: case GL_RGBA16F_ARB: texData.glType = GL_RGBA; texData.pixelType = GL_FLOAT; break; case GL_RGB32F_ARB: texData.glType = GL_RGB; texData.pixelType = GL_FLOAT; break; case GL_LUMINANCE32F_ARB: texData.glType = GL_LUMINANCE; texData.pixelType = GL_FLOAT; break; #endif default: texData.glType = GL_LUMINANCE; texData.pixelType = GL_UNSIGNED_BYTE; } // attempt to free the previous bound texture, if we can: clear(); glGenTextures(1, (GLuint *)&texData.textureID); // could be more then one, but for now, just one glEnable(texData.textureTarget); glBindTexture(texData.textureTarget, (GLuint)texData.textureID); #ifndef TARGET_OPENGLES // can't do this on OpenGL ES: on full-blown OpenGL, // internalGlDataType and glDataType (GL_LUMINANCE below) // can be different; on ES they must be exactly the same. // glTexImage2D(texData.textureTarget, 0, texData.glTypeInternal, (GLint)texData.tex_w, (GLint)texData.tex_h, 0, GL_LUMINANCE, PIXEL_TYPE, 0); // init to black... glTexImage2D(texData.textureTarget, 0, texData.glTypeInternal, (GLint)texData.tex_w, (GLint)texData.tex_h, 0, texData.glType, texData.pixelType, 0); // init to black... #else glTexImage2D(texData.textureTarget, 0, texData.glTypeInternal, texData.tex_w, texData.tex_h, 0, texData.glTypeInternal, GL_UNSIGNED_BYTE, 0); #endif glTexParameterf(texData.textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(texData.textureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(texData.textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(texData.textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glDisable(texData.textureTarget); texData.width = w; texData.height = h; texData.bFlipTexture = false; texData.bAllocated = true; }
ENTRYPOINT void init_tunnel (ModeInfo *mi) { int i; tunnel_configuration *tc; wire = MI_IS_WIREFRAME(mi); # ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */ wire = 0; # endif if (!tconf) { tconf = (tunnel_configuration *) calloc (MI_NUM_SCREENS(mi), sizeof (tunnel_configuration)); if (!tconf) { fprintf(stderr, "%s: out of memory\n", progname); exit(1); } } tc = &tconf[MI_SCREEN(mi)]; tc->glx_context = init_GL(mi); tc->cyllist = glGenLists(1); tc->diamondlist = glGenLists(1); tc->num_effects = 12; tc->num_texshifts = 3; tc->effect_time = 0.0; tc->effect_maxsecs = 30.00; /* check bounds on cmd line opts */ if (start > tc->effect_maxsecs) start = tc->effect_maxsecs; if (end > tc->effect_maxsecs) end = tc->effect_maxsecs; if (start < tc->effect_time) start = tc->effect_time; if (end < tc->effect_time) end = tc->effect_time; /* set loop times, in seconds */ tc->start_time = start; tc->end_time = end; /* reset animation knots, effect 0 not defined. */ tc->effects = malloc(sizeof(effect_t) * ( tc->num_effects + 1)); for ( i = 1; i <= tc->num_effects ; i++) init_effects(&tc->effects[i], i); if (wire) { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); do_texture = False; } if (do_texture) { /* the following textures are loaded, and possible overridden: tunnel 1, tunnel 2, tunnel 3, marquee, tardis, head */ glGenTextures(MAX_TEXTURE, tc->texture_binds); /*LoadTexture(*mi, **fn, *filename, texbind, bluralpha, bw_color, anegative, onealpha)*/ if (strcasecmp (do_tun1, "(none)")) /* tunnel 1 */ LoadTexture(mi, NULL, do_tun1, tc->texture_binds[0], 0,0.0, False, False); else LoadTexture(mi, timetunnel0_xpm, NULL, tc->texture_binds[0], 0, 0.0, False, False); if (strcasecmp (do_tun2, "(none)")) /* tunnel 2 */ LoadTexture(mi, NULL, do_tun2, tc->texture_binds[2], 0,0.0, False, False); else LoadTexture(mi, timetunnel1_xpm, NULL, tc->texture_binds[2], 0, 0.0, False, False); if (strcasecmp (do_tun3, "(none)")) /* tunnel 3 */ LoadTexture(mi, NULL, do_tun3, tc->texture_binds[5], 0,0.0, False, False); else LoadTexture(mi, timetunnel2_xpm, NULL, tc->texture_binds[5], 0, 0.0, False, False); LoadTexture(mi, tunnelstar_xpm, NULL, tc->texture_binds[4], 0, 0.0, False, False); if (strcasecmp (do_tx1, "(none)")) /* marquee */ LoadTexture(mi, NULL, do_tx1, tc->texture_binds[3], 0,0.0, False, False); #ifndef HAVE_JWZGLES /* logo_180_xpm is 180px which is not a power of 2! */ else LoadTexture(mi, (char **) logo_180_xpm, NULL, tc->texture_binds[3], 0,0.0, False, False); #endif if (strcasecmp (do_tx2, "(none)")) /* tardis */ LoadTexture(mi, NULL, do_tx2, tc->texture_binds[1], 0, 0.0 ,False, False); #ifndef HAVE_JWZGLES /* logo_180_xpm is 180px which is not a power of 2! */ else LoadTexture(mi, (char **) logo_180_xpm, NULL, tc->texture_binds[1], 0,0.0, False, False); #endif if (strcasecmp (do_tx3, "(none)")) { /* head */ LoadTexture(mi, NULL, do_tx3, tc->texture_binds[6], 0, 0.0 ,False, False); /* negative */ LoadTexture(mi, NULL, do_tx3, tc->texture_binds[9], 2,1.0, True, True); #ifndef HAVE_JWZGLES /* logo_180_xpm is 180px which is not a power of 2! */ } else { LoadTexture(mi, (char **) logo_180_xpm, NULL, tc->texture_binds[6], 0,0.0, False, False); /* negative */ LoadTexture(mi, (char **) logo_180_xpm, NULL, tc->texture_binds[9], 2,1.0, True, True); #endif } glEnable(GL_TEXTURE_2D); check_gl_error("tex"); } reshape_tunnel (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); glDisable(GL_DEPTH_TEST); /* who needs it? ;-) */ if (do_fog) glEnable(GL_FOG); if (!wire) { glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5); } tc->trackball = gltrackball_init (); tc->texshift = calloc(tc->num_texshifts, sizeof(GLfloat)); for ( i = 0 ; i < tc->num_texshifts; i++) tc->texshift[i] = 0.0; glNewList(tc->cyllist, GL_COMPILE); makecyl(30, -0.1, CYL_LEN, 1., 10. / 40.0 * CYL_LEN); /*makecyl(30, -0.5, DIAMOND_LEN, 1., 4. / 40 * DIAMOND_LEN); */ glEndList(); glNewList(tc->diamondlist, GL_COMPILE); makecyl(4, -0.5, DIAMOND_LEN, 1., 4. / 40 * DIAMOND_LEN); glEndList(); }
static GLboolean do_row(int srcy, int srcw, int srch, GLenum target) { int srcx = 20; int dstx = 80, dsty = srcy; int dstx2 = 140, dsty2 = srcy; int remain_width; int remain_height; GLuint texname; GLboolean pass = GL_TRUE; /* Rectangle textures use coordinates on the range [0..w]x[0..h], * where as all other textures use coordinates on the range * [0..1]x[0..1]. */ const GLfloat tex_s_max = (target == GL_TEXTURE_RECTANGLE_ARB) ? (float)srcw : 1.0; const GLfloat tex_t_max = (target == GL_TEXTURE_RECTANGLE_ARB) ? (float)srch : 1.0; /* Draw the object we're going to copy */ glColor3f(1.0, 0.0, 0.0); rect(srcx, srcy, srcx + srcw, srcy + srch); glColor3f(0.0, 1.0, 0.0); rect(srcx + 5, srcy + 5, srcx + srcw - 5, srcy + srch/2); glColor3f(0.0, 0.0, 1.0); rect(srcx + 5, srcy + srch/2, srcx + srcw - 5, srcy + srch - 5); /* Create a texture image and copy it in */ glGenTextures(1, &texname); glBindTexture(target, texname); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); /* The default mode is GL_REPEAT, and this mode is invalid for * GL_TEXTURE_RECTANGLE_ARB textures. */ glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glEnable(target); glTexImage2D(target, 0, GL_RGBA8, srcw, srch, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glCopyTexSubImage2D(target, 0, 0, 0, /* offset in image */ srcx, srcy, /* offset in readbuffer */ srcw, srch); /* Draw the texture image out */ glBegin(GL_POLYGON); glTexCoord2f(0.0, 0.0); glVertex2f(dstx, dsty); glTexCoord2f(0.0, tex_t_max); glVertex2f(dstx, dsty + srch); glTexCoord2f(tex_s_max, tex_t_max); glVertex2f(dstx + srcw, dsty + srch); glTexCoord2f(tex_s_max, 0.0); glVertex2f(dstx + srcw, dsty); glEnd(); glTexImage2D(target, 0, GL_RGBA8, srcw, srch, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); remain_width = srcw - (srcw / 2); remain_height = srch - (srch / 2); glCopyTexSubImage2D(target, 0, 0, 0, /* offset in image */ srcx, srcy, /* offset in readbuffer */ srcw / 2, srch / 2); glCopyTexSubImage2D(target, 0, srcw / 2, 0, /* offset in image */ srcx + srcw / 2, srcy, /* offset in readbuffer */ remain_width, srch / 2); glCopyTexSubImage2D(target, 0, 0, srch / 2, /* offset in image */ srcx, srcy + srch / 2, /* offset in readbuffer */ srcw / 2, remain_height); glCopyTexSubImage2D(target, 0, srcw / 2, srch / 2, /* offset in image */ srcx + srcw / 2, srcy + srch / 2, /* offset in readbuffer */ remain_width, remain_height); /* Draw the texture image out */ glBegin(GL_POLYGON); glTexCoord2f(0.0, 0.0); glVertex2f(dstx2, dsty2); glTexCoord2f(0.0, tex_t_max); glVertex2f(dstx2, dsty2 + srch); glTexCoord2f(tex_s_max, tex_t_max); glVertex2f(dstx2 + srcw, dsty2 + srch); glTexCoord2f(tex_s_max, 0.0); glVertex2f(dstx2 + srcw, dsty2); glEnd(); glDisable(target); glDeleteTextures(1, &texname); printf("Checking 0x%04x, rect 1:\n", target); pass &= check_results(dstx, dsty, srcw, srch); printf("Checking 0x%04x, rect 2:\n", target); pass &= check_results(dstx2, dsty2, srcw, srch); return pass; }
/** * @brief Really create the far texture for the given model. */ void CFarTextureHandler::CreateFarTexture(const CSolidObject* obj) { const S3DModel* model = obj->model; //! make space in the std::vectors while (cache.size() <= obj->team) { cache.push_back(std::vector<int>()); } while (cache[obj->team].size() <= model->id) { cache[obj->team].push_back(0); } cache[obj->team][model->id] = -1; //! check if there is enough free space in the atlas, if not try to resize it const int maxSprites = (texSizeX / iconSizeX)*(texSizeY / iconSizeY) / numOrientations - 1; if (usedFarTextures >= maxSprites) { const int oldTexSizeY = texSizeY; if (globalRendering->supportNPOTs) { texSizeY += std::max(iconSizeY, 4 * numOrientations * iconSizeX * iconSizeY / texSizeX); //! minimum additional space for 4 icons } else { texSizeY <<= 1; } if (texSizeY > globalRendering->maxTextureSize) { //logOutput.Print("Out of farTextures"); texSizeY = oldTexSizeY; return; } unsigned char* oldPixels = new unsigned char[texSizeX*texSizeY*4]; glBindTexture(GL_TEXTURE_2D, farTexture); glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, oldPixels); memset(oldPixels + texSizeX*oldTexSizeY*4, 0, texSizeX*(texSizeY - oldTexSizeY)*4); GLuint newFarTexture; glGenTextures(1,&newFarTexture); glBindTexture(GL_TEXTURE_2D, newFarTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texSizeX, texSizeY, 0, GL_RGBA, GL_UNSIGNED_BYTE, oldPixels); delete[] oldPixels; fbo.Bind(); fbo.UnattachAll(); glDeleteTextures(1,&farTexture); farTexture = newFarTexture; fbo.AttachTexture(farTexture); fbo.CheckStatus("FARTEXTURE"); fbo.Unbind(); } if (!fbo.IsValid()) { //logOutput.Print("framebuffer not valid!"); return; } fbo.Bind(); fbo.CreateRenderBuffer(GL_DEPTH_ATTACHMENT_EXT, GL_DEPTH_COMPONENT16, texSizeX, texSizeY); //! delete it after finished rendering to the texture fbo.CheckStatus("FARTEXTURE"); glPushAttrib(GL_ALL_ATTRIB_BITS); glDisable(GL_BLEND); unitDrawer->SetupForUnitDrawing(); unitDrawer->GetOpaqueModelRenderer(model->type)->PushRenderState(); if (model->type == MODELTYPE_S3O || model->type == MODELTYPE_OBJ) { // FIXME for some strange reason we need to invert the culling, why? if (model->type == MODELTYPE_S3O) { glCullFace(GL_FRONT); } texturehandlerS3O->SetS3oTexture(model->textureType); } unitDrawer->SetTeamColour(obj->team); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-model->radius, model->radius, -model->radius, model->radius, -model->radius*1.5f, model->radius*1.5f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glScalef(-1.0f, 1.0f, 1.0f); glRotatef(45.0f, 1.0f, 0.0f, 0.0f); // light the far-textures from straight above, we do // not care much about the actual sun direction here static const float4 sunDir = UpVector; glLightfv(GL_LIGHT1, GL_POSITION, &sunDir.x); //! draw the model in 8 different orientations for (size_t orient = 0; orient < numOrientations; ++orient) { //! setup viewport int2 pos = GetTextureCoordsInt(usedFarTextures, orient); glViewport(pos.x * iconSizeX, pos.y * iconSizeY, iconSizeX, iconSizeY); glClear(GL_DEPTH_BUFFER_BIT); glPushMatrix(); glTranslatef(0, -model->height * 0.5f, 0); //! draw the model to a temporary buffer model->DrawStatic(); glPopMatrix(); //! rotate by 45 degrees for the next orientation glRotatef(-360.0f / numOrientations, 0, 1, 0); } unitDrawer->GetOpaqueModelRenderer(model->type)->PopRenderState(); unitDrawer->CleanUpUnitDrawing(); //glViewport(globalRendering->viewPosX, 0, globalRendering->viewSizeX, globalRendering->viewSizeY); glPopAttrib(); fbo.Unattach(GL_DEPTH_ATTACHMENT_EXT); fbo.Unbind(); usedFarTextures++; cache[obj->team][model->id] = usedFarTextures; }
GLuint createTextureFromTga(const char * path) { long length; char * buffer = getTextFileContent(path, &length); const TgaHeader * header = (TgaHeader *) buffer; GLint format; GLint internalFormat; GLuint texture; const GLvoid * imgData; if (buffer == NULL) { return 0; } if (length <= (signed long) sizeof(TgaHeader)) { fprintf(stderr, "Too small TGA file: %s\n", path); free(buffer); return 0; } if (header->datatype != 2 || (header->bitperpel != 24 && header->bitperpel != 32)) { fprintf(stderr, "Wrong TGA file format: %s\n", path); free(buffer); return 0; } format = (header->bitperpel == 24 ? GL_BGR : GL_BGRA); internalFormat = (format == GL_BGR ? GL_RGB8 : GL_RGBA8); imgData = (const GLvoid *) (buffer + sizeof(TgaHeader) + header->idlength); glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); /* Set 1-byte alignment (for non (2^n)x(2^n) size textures). */ glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, header->width, header->height, 0, format, GL_UNSIGNED_BYTE, imgData); free(buffer); #if 0 /* Linear filtering */ 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_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);*/ #else glGenerateMipmap(GL_TEXTURE_2D); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); #endif #if 0 /* No wrap */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); #else glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); #endif CHECK_OPENGL_ERRORS(__FILE__, __LINE__); return texture; }
///Create a BMP texuture in OpenGL int CreateTexture(unsigned int textureArray[],char *strFileName,int textureID) { SDL_Surface *pBitmap[1]; if( strFileName == NULL ) // Return from the function if no file name return 0; // We need to load the texture data, so we use a cool function that SDL offers. pBitmap[0] = SDL_LoadBMP(strFileName); // Load the bitmap and store the data if(pBitmap[0] == NULL) { fprintf(stderr," Failed loading %s" , SDL_GetError()); return 0; } // Generate a texture with the associative texture ID stored in the array glGenTextures(1, &textureArray[textureID]); // Bind the texture to the texture arrays index and init the texture glBindTexture(GL_TEXTURE_2D, textureArray[textureID]); // Rearrange the pixelData int width = pBitmap[0] -> w; int height = pBitmap[0] -> h; unsigned char * data = (unsigned char *) (pBitmap[0] -> pixels); // the pixel data int BytesPerPixel = pBitmap[0] -> format -> BytesPerPixel; for( int i = 0 ; i < (height / 2) ; ++i ) for( int j = 0 ; j < width * BytesPerPixel; j += BytesPerPixel ) for(int k = 0; k < BytesPerPixel; ++k) swap( data[ (i * width * BytesPerPixel) + j + k], data[ ( (height - i - 1) * width * BytesPerPixel ) + j + k]); unsigned char *pixels = new unsigned char[width * height * 3]; int count = 0; // the following lines extract R,G and B values from any bitmap for(int i = 0; i < (width * height); ++i) { byte r,g,b; // R,G and B that we will put into pImage Uint32 pixel_value = 0; // 32 bit unsigned int (as dictated by SDL) for(int j = BytesPerPixel - 1 ; j >=0; --j) // for each byte in the pixel (from the right) { pixel_value = pixel_value << 8; // left shift pixel value by 8 bits pixel_value = pixel_value | data[ (i * BytesPerPixel) + j ]; // then make the last 8 bits of pixel value = } // the byte that we extract from pBitmap's data SDL_GetRGB(pixel_value, pBitmap[0] -> format, (Uint8 *)&r, (Uint8 *)&g, (Uint8 *)&b); pixels[count++] = r; // in our tImage classes we store r first pixels[count++] = g; // then g pixels[count++] = b; // and finally b (for bmps - three channels only) pixel_value = 0; } gluBuild2DMipmaps(GL_TEXTURE_2D, 3, pBitmap[0]->w, pBitmap[0]->h, GL_RGB, GL_UNSIGNED_BYTE, pixels); // Lastly, we need to tell OpenGL the quality of our texture map. GL_LINEAR is the smoothest. glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); SDL_FreeSurface(pBitmap[0]); return 1; }
CMiniMap::CMiniMap() : CInputReceiver(BACK), fullProxy(false), proxyMode(false), selecting(false), maxspect(false), maximized(false), minimized(false), mouseLook(false), mouseMove(false), mouseResize(false), slaveDrawMode(false), showButtons(false), useIcons(true) { lastWindowSizeX = globalRendering->viewSizeX; lastWindowSizeY = globalRendering->viewSizeY; if (globalRendering->dualScreenMode) { width = globalRendering->viewSizeX; height = globalRendering->viewSizeY; xpos = (globalRendering->viewSizeX - globalRendering->viewPosX); ypos = 0; } else { const std::string geo = configHandler->GetString("MiniMapGeometry"); ParseGeometry(geo); } fullProxy = configHandler->GetBool("MiniMapFullProxy"); buttonSize = configHandler->GetInt("MiniMapButtonSize"); unitBaseSize = configHandler->GetFloat("MiniMapUnitSize"); unitExponent = configHandler->GetFloat("MiniMapUnitExp"); cursorScale = configHandler->GetFloat("MiniMapCursorScale"); useIcons = configHandler->GetBool("MiniMapIcons"); drawCommands = configHandler->GetInt("MiniMapDrawCommands"); drawProjectiles = configHandler->GetBool("MiniMapDrawProjectiles"); simpleColors = configHandler->GetBool("SimpleMiniMapColors"); myColor[0] = (unsigned char)(0.2f * 255); myColor[1] = (unsigned char)(0.9f * 255); myColor[2] = (unsigned char)(0.2f * 255); myColor[3] = (unsigned char)(1.0f * 255); allyColor[0] = (unsigned char)(0.3f * 255); allyColor[1] = (unsigned char)(0.3f * 255); allyColor[2] = (unsigned char)(0.9f * 255); allyColor[3] = (unsigned char)(1.0f * 255); enemyColor[0] = (unsigned char)(0.9f * 255); enemyColor[1] = (unsigned char)(0.2f * 255); enemyColor[2] = (unsigned char)(0.2f * 255); enemyColor[3] = (unsigned char)(1.0f * 255); UpdateGeometry(); circleLists = glGenLists(circleListsCount); for (int cl = 0; cl < circleListsCount; cl++) { glNewList(circleLists + cl, GL_COMPILE); glBegin(GL_LINE_LOOP); const int divs = (1 << (cl + 3)); for (int d = 0; d < divs; d++) { const float rads = float(2.0 * PI) * float(d) / float(divs); glVertex3f(math::sin(rads), 0.0f, math::cos(rads)); } glEnd(); glEndList(); } // setup the buttons' texture and texture coordinates buttonsTexture = 0; CBitmap bitmap; bool unfiltered = false; if (bitmap.Load("bitmaps/minimapbuttons.png")) { if ((bitmap.ysize == buttonSize) && (bitmap.xsize == (buttonSize * 4))) { unfiltered = true; } glGenTextures(1, &buttonsTexture); glBindTexture(GL_TEXTURE_2D, buttonsTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, bitmap.xsize, bitmap.ysize, 0, GL_RGBA, GL_UNSIGNED_BYTE, bitmap.mem); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); if (unfiltered) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } glBindTexture(GL_TEXTURE_2D, 0); } const float xshift = unfiltered ? 0.0f : (0.5f / bitmap.xsize); const float yshift = unfiltered ? 0.0f : (0.5f / bitmap.ysize); moveBox.xminTx = 0.50f + xshift; moveBox.xmaxTx = 0.75f - xshift; resizeBox.xminTx = 0.75f + xshift; resizeBox.xmaxTx = 1.00f - xshift; minimizeBox.xminTx = 0.00f + xshift; minimizeBox.xmaxTx = 0.25f - xshift; maximizeBox.xminTx = 0.25f + xshift; maximizeBox.xmaxTx = 0.50f - xshift; moveBox.yminTx = 1.00f - yshift; resizeBox.yminTx = 1.00f - yshift; minimizeBox.yminTx = 1.00f - yshift; maximizeBox.yminTx = 1.00f - yshift; moveBox.ymaxTx = 0.00f + yshift; resizeBox.ymaxTx = 0.00f + yshift; minimizeBox.ymaxTx = 0.00f + yshift; maximizeBox.ymaxTx = 0.00f + yshift; }
static GPUTexture *GPU_texture_create_nD(int w, int h, int n, float *fpixels, int depth) { GPUTexture *tex; GLenum type, format, internalformat; void *pixels = NULL; if(depth && !GLEW_ARB_depth_texture) return NULL; tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture"); tex->w = w; tex->h = h; tex->number = -1; tex->refcount = 1; tex->target = (n == 1)? GL_TEXTURE_1D: GL_TEXTURE_2D; tex->depth = depth; glGenTextures(1, &tex->bindcode); if (!tex->bindcode) { fprintf(stderr, "GPUTexture: texture create failed: %d\n", (int)glGetError()); GPU_texture_free(tex); return NULL; } if (!GPU_non_power_of_two_support()) { tex->w = larger_pow2(tex->w); tex->h = larger_pow2(tex->h); } tex->number = 0; glBindTexture(tex->target, tex->bindcode); if(depth) { type = GL_UNSIGNED_BYTE; format = GL_DEPTH_COMPONENT; internalformat = GL_DEPTH_COMPONENT; } else { type = GL_UNSIGNED_BYTE; format = GL_RGBA; internalformat = GL_RGBA8; if (fpixels) pixels = GPU_texture_convert_pixels(w*h, fpixels); } if (tex->target == GL_TEXTURE_1D) { glTexImage1D(tex->target, 0, internalformat, tex->w, 0, format, type, 0); if (fpixels) { glTexSubImage1D(tex->target, 0, 0, w, format, type, pixels? pixels: fpixels); if (tex->w > w) GPU_glTexSubImageEmpty(tex->target, format, w, 0, tex->w-w, 1); } } else { glTexImage2D(tex->target, 0, internalformat, tex->w, tex->h, 0, format, type, 0); if (fpixels) { glTexSubImage2D(tex->target, 0, 0, 0, w, h, format, type, pixels? pixels: fpixels); if (tex->w > w) GPU_glTexSubImageEmpty(tex->target, format, w, 0, tex->w-w, tex->h); if (tex->h > h) GPU_glTexSubImageEmpty(tex->target, format, 0, h, w, tex->h-h); } } if (pixels) MEM_freeN(pixels); if(depth) { glTexParameteri(tex->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(tex->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(tex->target, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE); glTexParameteri(tex->target, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL); glTexParameteri(tex->target, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY); } else { glTexParameteri(tex->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(tex->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } if (tex->target != GL_TEXTURE_1D) { /* CLAMP_TO_BORDER is an OpenGL 1.3 core feature */ GLenum wrapmode = (depth)? GL_CLAMP_TO_EDGE: GL_CLAMP_TO_BORDER; glTexParameteri(tex->target, GL_TEXTURE_WRAP_S, wrapmode); glTexParameteri(tex->target, GL_TEXTURE_WRAP_T, wrapmode); #if 0 float borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f }; glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor); #endif } else glTexParameteri(tex->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); return tex; }
void SetupRC() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); //随机获取星星的位置 for (int i = 0; i < SMALL_NUM; ++i) { smallStars[i][0] = (GLfloat)(rand() % SCREEN_X); smallStars[i][1] = (GLfloat)(rand() % SCREEN_Y); } for (int i = 0; i < MEDIUM_NUM; ++i) { mediumStars[i][0] = (GLfloat)(rand() % SCREEN_X); mediumStars[i][1] = (GLfloat)((rand() % SCREEN_Y) + 50); } for (int i = 0; i < LARGE_NUM; ++i) { largeStars[i][0] = (GLfloat)(rand() % SCREEN_X); largeStars[i][1] = (GLfloat)(rand() % SCREEN_Y); } GLint iWidth, iHeight, iComponents; GLenum eFormat; //生成纹理对象 glGenTextures(TEXNUM, textureObj); //加载纹理图片 glBindTexture(GL_TEXTURE_2D, textureObj[STAR]); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); void *pImage = gltLoadTGA("..\\images\\star.tga", &iWidth, &iHeight, &iComponents, &eFormat); if (pImage) { glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pImage); free(pImage); pImage = NULL; } glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glBindTexture(GL_TEXTURE_2D, textureObj[MOON]); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); pImage = gltLoadTGA("..\\images\\moon.tga", &iWidth, &iHeight, &iComponents, &eFormat); if (pImage) { glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pImage); free(pImage); pImage = NULL; } glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); //启用点精灵 glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE); glEnable(GL_POINT_SPRITE); ProcessMenu(3); }
//* Creation / loading methods ******************************************** void GLTexture::createInternalResourcesImpl(void) { // Convert to nearest power-of-two size if required mWidth = GLPixelUtil::optionalPO2(mWidth); mHeight = GLPixelUtil::optionalPO2(mHeight); mDepth = GLPixelUtil::optionalPO2(mDepth); // Adjust format if required mFormat = TextureManager::getSingleton().getNativeFormat(mTextureType, mFormat, mUsage); // Check requested number of mipmaps size_t maxMips = GLPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat); mNumMipmaps = mNumRequestedMipmaps; if(mNumMipmaps>maxMips) mNumMipmaps = maxMips; // Generate texture name glGenTextures( 1, &mTextureID ); // Set texture type glBindTexture( getGLTextureTarget(), mTextureID ); // This needs to be set otherwise the texture doesn't get rendered glTexParameteri( getGLTextureTarget(), GL_TEXTURE_MAX_LEVEL, mNumMipmaps ); // Set some misc default parameters so NVidia won't complain, these can of course be changed later glTexParameteri(getGLTextureTarget(), GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(getGLTextureTarget(), GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(getGLTextureTarget(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(getGLTextureTarget(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // If we can do automip generation and the user desires this, do so mMipmapsHardwareGenerated = Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP); if((mUsage & TU_AUTOMIPMAP) && mNumRequestedMipmaps && mMipmapsHardwareGenerated) { glTexParameteri( getGLTextureTarget(), GL_GENERATE_MIPMAP, GL_TRUE ); } // Allocate internal buffer so that glTexSubImageXD can be used // Internal format GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat); size_t width = mWidth; size_t height = mHeight; size_t depth = mDepth; if(PixelUtil::isCompressed(mFormat)) { // Compressed formats size_t size = PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat); // Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not // accept a 0 pointer like normal glTexImageXD // Run through this process for every mipmap to pregenerate mipmap piramid uint8 *tmpdata = new uint8[size]; memset(tmpdata, 0, size); for(size_t mip=0; mip<=mNumMipmaps; mip++) { size = PixelUtil::getMemorySize(width, height, depth, mFormat); switch(mTextureType) { case TEX_TYPE_1D: glCompressedTexImage1DARB(GL_TEXTURE_1D, mip, format, width, 0, size, tmpdata); break; case TEX_TYPE_2D: glCompressedTexImage2DARB(GL_TEXTURE_2D, mip, format, width, height, 0, size, tmpdata); break; case TEX_TYPE_3D: glCompressedTexImage3DARB(GL_TEXTURE_3D, mip, format, width, height, depth, 0, size, tmpdata); break; case TEX_TYPE_CUBE_MAP: for(int face=0; face<6; face++) { glCompressedTexImage2DARB(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format, width, height, 0, size, tmpdata); } break; }; if(width>1) width = width/2; if(height>1) height = height/2; if(depth>1) depth = depth/2; } delete [] tmpdata; } else { // Run through this process to pregenerate mipmap piramid for(size_t mip=0; mip<=mNumMipmaps; mip++) { // Normal formats switch(mTextureType) { case TEX_TYPE_1D: glTexImage1D(GL_TEXTURE_1D, mip, format, width, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); break; case TEX_TYPE_2D: glTexImage2D(GL_TEXTURE_2D, mip, format, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); break; case TEX_TYPE_3D: glTexImage3D(GL_TEXTURE_3D, mip, format, width, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); break; case TEX_TYPE_CUBE_MAP: for(int face=0; face<6; face++) { glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); } break; }; if(width>1) width = width/2; if(height>1) height = height/2; if(depth>1) depth = depth/2; } } _createSurfaceList(); // Get final internal format mFormat = getBuffer(0,0)->getFormat(); }
int setupTextureShader(GLuint &textureID, const mesh& object) { glewInit(); if(!glewIsSupported("GL_VERSION_2_0 GL_ARB_multitexture GL_EXT_framebuffer_object")) { fprintf(stderr, "Required OpenGL extensions missing\n"); return -1; } /* create texture */ glGenTextures(1, &textureID); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textureID); 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_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); /* load texture file */ int width, height, components; unsigned char *data = stbi_load("static/uv_color_map.png", &width, &height, &components, 0); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data); stbi_image_free(data); /* load UV data from mesh */ std::vector<glm::vec2> texture_uvs = object.getTextureUVs(); unsigned int uvsize = texture_uvs.size(); unsigned int uvmem = 2*uvsize*sizeof(GLfloat); GLfloat *uv_buffer_data = (GLfloat *)malloc(uvmem); for(int i = 0; i < uvsize; i++) { uv_buffer_data[2*i] = texture_uvs.at(i).x; uv_buffer_data[2*i + 1] = texture_uvs.at(i).y; } /* pass data to shader */ GLuint uvBuffer; glGenBuffers(1, &uvBuffer); glBindBuffer(GL_ARRAY_BUFFER, uvBuffer); glBufferData(GL_ARRAY_BUFFER, uvmem, uv_buffer_data, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0); free(uv_buffer_data); glm::ivec2 shaders = loadShaders("src/texture.vert", "src/texture.frag"); GLuint vertexShader = shaders.x; GLuint fragmentShader = shaders.y; /* create and link program */ int program = glCreateProgram(); glBindAttribLocation(program, 0, "vertexUV"); int loc = glGetUniformLocation(program, "texsampler"); glUniform1i(loc, 0); glAttachShader(program, vertexShader); glAttachShader(program, fragmentShader); glLinkProgram(program); GLint pstatus; glGetProgramiv(program, GL_LINK_STATUS, &pstatus); if(pstatus != GL_TRUE) { char log[2048]; int len; glGetProgramInfoLog(program, 2048, (GLsizei*)&len, log); fprintf(stderr, "%s", log); glDeleteProgram(program); return -1; } return program; }
void init() { colorcube(); // Create a checkerboard pattern for ( int i = 0; i < 64; i++ ) { for ( int j = 0; j < 64; j++ ) { GLubyte c = (((i & 0x8) == 0) ^ ((j & 0x8) == 0)) * 255; image[i][j][0] = c; image[i][j][1] = c; image[i][j][2] = c; image2[i][j][0] = c; image2[i][j][1] = 0; image2[i][j][2] = c; } } // Initialize texture objects glGenTextures( 2, textures ); glBindTexture( GL_TEXTURE_2D, textures[0] ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, TextureSize, TextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, image ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glBindTexture( GL_TEXTURE_2D, textures[1] ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, TextureSize, TextureSize, 0, GL_RGB, GL_UNSIGNED_BYTE, image2 ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glActiveTexture( GL_TEXTURE0 ); glBindTexture( GL_TEXTURE_2D, textures[0] ); // Create a vertex array object GLuint vao; glGenVertexArrays( 1, &vao ); glBindVertexArray( vao ); // Create and initialize a buffer object GLuint buffer; glGenBuffers( 1, &buffer ); glBindBuffer( GL_ARRAY_BUFFER, buffer ); glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(quad_colors) + sizeof(tex_coords), NULL, GL_STATIC_DRAW ); // Specify an offset to keep track of where we're placing data in our // vertex array buffer. We'll use the same technique when we // associate the offsets with vertex attribute pointers. GLintptr offset = 0; glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(points), points ); offset += sizeof(points); glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(quad_colors), quad_colors ); offset += sizeof(quad_colors); glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(tex_coords), tex_coords ); // Load shaders and use the resulting shader program GLuint program = InitShader( "vshader71.glsl", "fshader71.glsl" ); glUseProgram( program ); // set up vertex arrays offset = 0; GLuint vPosition = glGetAttribLocation( program, "vPosition" ); glEnableVertexAttribArray( vPosition ); glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset) ); offset += sizeof(points); GLuint vColor = glGetAttribLocation( program, "vColor" ); glEnableVertexAttribArray( vColor ); glVertexAttribPointer( vColor, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset) ); offset += sizeof(quad_colors); GLuint vTexCoord = glGetAttribLocation( program, "vTexCoord" ); glEnableVertexAttribArray( vTexCoord ); glVertexAttribPointer( vTexCoord, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset) ); // Set the value of the fragment shader texture sampler variable // ("texture") to the the appropriate texture unit. In this case, // zero, for GL_TEXTURE0 which was previously set by calling // glActiveTexture(). glUniform1i( glGetUniformLocation(program, "texture"), 0 ); theta = glGetUniformLocation( program, "theta" ); glEnable( GL_DEPTH_TEST ); glClearColor( 1.0, 1.0, 1.0, 1.0 ); }
/******************************************************************************* * LoadAlphaTGA *******************************************************************************/ int LoadAlphaTGA (char *cpFilename, GLuint &uTextureId, LGColor3b cColor) { FILE* fpFile; // Input file int iFileLength; // Length of the file byte* bpData; // Buffer int iCurrentByte = 0; // Current byte in the buffer int iWidth; // Image width int iHeight; // Image height byte* bpBits = 0; // Pointer To The Bitmap Bits int iHeaderSize = 18; // Headersize of a targa file int iR; // Red int iG; // Green int iB; // Blue // Open file if ((fpFile = fopen (cpFilename, "rb" )) == NULL) { // Print error ErrorPrintf ("Input file could not be opened"); // Return error return (-1); } // Get file length fseek (fpFile, 0, SEEK_END); iFileLength = ftell (fpFile); // Reset file pointer to begin fseek (fpFile, 0, SEEK_SET); // Allocate buffer bpData = new byte[iFileLength]; // Read buffer fread (bpData, sizeof (char), iFileLength, fpFile); // Close file fclose (fpFile); // Set height and with iWidth = (int)bpData[12] + ((int)bpData[13] * 256); iHeight = (int)bpData[14] + ((int)bpData[15] * 256); VerbosePrintf ("Width, Height, Bpp: %d, %d, %d", iWidth, iHeight, bpData[16]); // Allocate bits bpBits = new byte[iWidth*iHeight*4]; // If targa 8-bits per pixel if ((int)bpData[16] == 8) { for (int iX = 0; iX < iWidth; iX++) { for (int iY = 0; iY < iHeight; iY++) { // Get factor int iFactor = (int)(bpData[(iX+(iY*iWidth))+iHeaderSize]); if (iFactor <= 127) { iR = (int)(((cColor.bR+1) * (((float)iFactor+1)/128)) -1); iG = (int)(((cColor.bG+1) * (((float)iFactor+1)/128)) -1); iB = (int)(((cColor.bB+1) * (((float)iFactor+1)/128)) -1); } else { iR = (int)(((255 - cColor.bR) * (((float)iFactor-127)/128)) + cColor.bR); iG = (int)(((255 - cColor.bG) * (((float)iFactor-127)/128)) + cColor.bG); iB = (int)(((255 - cColor.bB) * (((float)iFactor-127)/128)) + cColor.bB); } // Get RGB info bpBits[((iX+(iY*iWidth))*4)] = iR; bpBits[((iX+(iY*iWidth))*4)+1] = iG; bpBits[((iX+(iY*iWidth))*4)+2] = iB; bpBits[((iX+(iY*iWidth))*4)+3] = 255; } } } // Free temporary buffer delete [] bpData; // Create the texture glGenTextures (1, &uTextureId); // Typical Texture Generation Using Data From The Bitmap glBindTexture(GL_TEXTURE_2D, uTextureId); 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, iWidth, iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, bpBits); // Return no error return (0); }
// The MAIN function, from here we start the application and run the game loop int main() { // Init GLFW glfwInit(); // Set all the required options for GLFW glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // Create a GLFWwindow object that we can use for GLFW's functions GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr); glfwMakeContextCurrent(window); // Set the required callback functions glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); // GLFW Options glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions glewExperimental = GL_TRUE; // Initialize GLEW to setup the OpenGL Function pointers glewInit(); // Define the viewport dimensions int width, height; glfwGetFramebufferSize(window, &width, &height); glViewport(0, 0, width, height); // OpenGL options glEnable(GL_DEPTH_TEST); // Build and compile our shader program Shader lightingShader("multiple_lights.vs", "multiple_lights.frag"); Shader lampShader("lamp.vs", "lamp.frag"); // Set up vertex data (and buffer(s)) and attribute pointers GLfloat vertices[] = { // Positions // Normals // Texture Coords -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f }; // Positions all containers glm::vec3 cubePositions[] = { 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) }; // Positions of the point lights glm::vec3 pointLightPositions[] = { 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) }; // First, set the container's VAO (and VBO) GLuint VBO, containerVAO; glGenVertexArrays(1, &containerVAO); glGenBuffers(1, &VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBindVertexArray(containerVAO); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glBindVertexArray(0); // Then, we set the light's VAO (VBO stays the same. After all, the vertices are the same for the light object (also a 3D cube)) GLuint lightVAO; glGenVertexArrays(1, &lightVAO); glBindVertexArray(lightVAO); // We only need to bind to the VBO (to link it with glVertexAttribPointer), no need to fill it; the VBO's data already contains all we need. glBindBuffer(GL_ARRAY_BUFFER, VBO); // Set the vertex attributes (only position data for the lamp)) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); // Note that we skip over the other data in our buffer object (we don't need the normals/textures, only positions). glEnableVertexAttribArray(0); glBindVertexArray(0); // Load textures GLuint diffuseMap, specularMap, emissionMap; glGenTextures(1, &diffuseMap); glGenTextures(1, &specularMap); glGenTextures(1, &emissionMap); unsigned char* image; // Diffuse map image = SOIL_load_image(FileSystem::getPath("resources/textures/container2.png").c_str(), &width, &height, 0, SOIL_LOAD_RGB); glBindTexture(GL_TEXTURE_2D, diffuseMap); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); 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_NEAREST_MIPMAP_NEAREST); // Specular map image = SOIL_load_image(FileSystem::getPath("resources/textures/container2_specular.png").c_str(), &width, &height, 0, SOIL_LOAD_RGB); glBindTexture(GL_TEXTURE_2D, specularMap); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); 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_NEAREST_MIPMAP_NEAREST); glBindTexture(GL_TEXTURE_2D, 0); // Set texture units lightingShader.Use(); glUniform1i(glGetUniformLocation(lightingShader.Program, "material.diffuse"), 0); glUniform1i(glGetUniformLocation(lightingShader.Program, "material.specular"), 1); // Game loop while (!glfwWindowShouldClose(window)) { // Calculate deltatime of current frame GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions glfwPollEvents(); do_movement(); // Clear the colorbuffer glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Use cooresponding shader when setting uniforms/drawing objects lightingShader.Use(); GLint viewPosLoc = glGetUniformLocation(lightingShader.Program, "viewPos"); glUniform3f(viewPosLoc, camera.Position.x, camera.Position.y, camera.Position.z); // Set material properties glUniform1f(glGetUniformLocation(lightingShader.Program, "material.shininess"), 32.0f); // == ========================== // Here we set all the uniforms for the 5/6 types of lights we have. We have to set them manually and index // the proper PointLight struct in the array to set each uniform variable. This can be done more code-friendly // by defining light types as classes and set their values in there, or by using a more efficient uniform approach // by using 'Uniform buffer objects', but that is something we discuss in the 'Advanced GLSL' tutorial. // == ========================== // Directional light glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.direction"), -0.2f, -1.0f, -0.3f); glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.ambient"), 0.05f, 0.05f, 0.05f); glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.diffuse"), 0.4f, 0.4f, 0.4f); glUniform3f(glGetUniformLocation(lightingShader.Program, "dirLight.specular"), 0.5f, 0.5f, 0.5f); // Point light 1 glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].position"), pointLightPositions[0].x, pointLightPositions[0].y, pointLightPositions[0].z); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].ambient"), 0.05f, 0.05f, 0.05f); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].diffuse"), 0.8f, 0.8f, 0.8f); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[0].specular"), 1.0f, 1.0f, 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].constant"), 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].linear"), 0.09); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[0].quadratic"), 0.032); // Point light 2 glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].position"), pointLightPositions[1].x, pointLightPositions[1].y, pointLightPositions[1].z); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].ambient"), 0.05f, 0.05f, 0.05f); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].diffuse"), 0.8f, 0.8f, 0.8f); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[1].specular"), 1.0f, 1.0f, 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].constant"), 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].linear"), 0.09); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[1].quadratic"), 0.032); // Point light 3 glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].position"), pointLightPositions[2].x, pointLightPositions[2].y, pointLightPositions[2].z); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].ambient"), 0.05f, 0.05f, 0.05f); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].diffuse"), 0.8f, 0.8f, 0.8f); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[2].specular"), 1.0f, 1.0f, 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].constant"), 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].linear"), 0.09); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[2].quadratic"), 0.032); // Point light 4 glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].position"), pointLightPositions[3].x, pointLightPositions[3].y, pointLightPositions[3].z); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].ambient"), 0.05f, 0.05f, 0.05f); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].diffuse"), 0.8f, 0.8f, 0.8f); glUniform3f(glGetUniformLocation(lightingShader.Program, "pointLights[3].specular"), 1.0f, 1.0f, 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].constant"), 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].linear"), 0.09); glUniform1f(glGetUniformLocation(lightingShader.Program, "pointLights[3].quadratic"), 0.032); // SpotLight glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.position"), camera.Position.x, camera.Position.y, camera.Position.z); glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.direction"), camera.Front.x, camera.Front.y, camera.Front.z); glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.ambient"), 0.0f, 0.0f, 0.0f); glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.diffuse"), 1.0f, 1.0f, 1.0f); glUniform3f(glGetUniformLocation(lightingShader.Program, "spotLight.specular"), 1.0f, 1.0f, 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.constant"), 1.0f); glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.linear"), 0.09); glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.quadratic"), 0.032); glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.cutOff"), glm::cos(glm::radians(12.5f))); glUniform1f(glGetUniformLocation(lightingShader.Program, "spotLight.outerCutOff"), glm::cos(glm::radians(15.0f))); // Create camera transformations glm::mat4 view; view = camera.GetViewMatrix(); glm::mat4 projection = glm::perspective(camera.Zoom, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f); // Get the uniform locations GLint modelLoc = glGetUniformLocation(lightingShader.Program, "model"); GLint viewLoc = glGetUniformLocation(lightingShader.Program, "view"); GLint projLoc = glGetUniformLocation(lightingShader.Program, "projection"); // Pass the matrices to the shader glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); // Bind diffuse map glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, diffuseMap); // Bind specular map glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, specularMap); // Draw 10 containers with the same VAO and VBO information; only their world space coordinates differ glm::mat4 model; glBindVertexArray(containerVAO); for (GLuint i = 0; i < 10; i++) { model = glm::mat4(); model = glm::translate(model, cubePositions[i]); GLfloat angle = 20.0f * i; model = glm::rotate(model, angle, glm::vec3(1.0f, 0.3f, 0.5f)); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); } glBindVertexArray(0); // Also draw the lamp object, again binding the appropriate shader lampShader.Use(); // Get location objects for the matrices on the lamp shader (these could be different on a different shader) modelLoc = glGetUniformLocation(lampShader.Program, "model"); viewLoc = glGetUniformLocation(lampShader.Program, "view"); projLoc = glGetUniformLocation(lampShader.Program, "projection"); // Set matrices glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection)); // We now draw as many light bulbs as we have point lights. glBindVertexArray(lightVAO); for (GLuint i = 0; i < 4; i++) { model = glm::mat4(); model = glm::translate(model, pointLightPositions[i]); model = glm::scale(model, glm::vec3(0.2f)); // Make it a smaller cube glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glDrawArrays(GL_TRIANGLES, 0, 36); } glBindVertexArray(0); // Swap the screen buffers glfwSwapBuffers(window); } // Terminate GLFW, clearing any resources allocated by GLFW. glfwTerminate(); return 0; }
bool GBASDLInit(struct SDLSoftwareRenderer* renderer) { #ifndef COLOR_16_BIT SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); #else SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5); #ifdef COLOR_5_6_5 SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6); #else SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5); #endif SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5); #endif #if SDL_VERSION_ATLEAST(2, 0, 0) renderer->window = SDL_CreateWindow(PROJECT_NAME, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, renderer->viewportWidth, renderer->viewportHeight, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | (SDL_WINDOW_FULLSCREEN_DESKTOP * renderer->events.fullscreen)); SDL_GL_CreateContext(renderer->window); SDL_GL_SetSwapInterval(1); SDL_GetWindowSize(renderer->window, &renderer->viewportWidth, &renderer->viewportHeight); renderer->events.window = renderer->window; #else SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1); #ifdef COLOR_16_BIT SDL_SetVideoMode(renderer->viewportWidth, renderer->viewportHeight, 16, SDL_OPENGL); #else SDL_SetVideoMode(renderer->viewportWidth, renderer->viewportHeight, 32, SDL_OPENGL); #endif #endif renderer->d.outputBuffer = malloc(VIDEO_HORIZONTAL_PIXELS * VIDEO_VERTICAL_PIXELS * BYTES_PER_PIXEL); renderer->d.outputBufferStride = VIDEO_HORIZONTAL_PIXELS; glGenTextures(1, &renderer->tex); glBindTexture(GL_TEXTURE_2D, renderer->tex); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); if (renderer->filter) { glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } else { glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); } #ifndef _WIN32 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); #endif #ifdef COLOR_16_BIT #ifdef COLOR_5_6_5 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0); #else glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 0); #endif #else glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); #endif glViewport(0, 0, renderer->viewportWidth, renderer->viewportHeight); return true; }