void CTexture::Init(CPixelBuffer *pBuffer, bool bClamp, bool bMipmap) { Cleanup(); m_nType = (pBuffer->GetHeight() > 1) ? GL_TEXTURE_2D : GL_TEXTURE_1D; glGenTextures(1, &m_nID); Bind(); //glTexParameteri(m_nType, GL_TEXTURE_WRAP_R, bClamp ? GL_CLAMP : GL_REPEAT); glTexParameteri(m_nType, GL_TEXTURE_WRAP_S, bClamp ? GL_CLAMP : GL_REPEAT); glTexParameteri(m_nType, GL_TEXTURE_WRAP_T, bClamp ? GL_CLAMP : GL_REPEAT); glTexParameteri(m_nType, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(m_nType, GL_TEXTURE_MIN_FILTER, bMipmap ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR); switch(m_nType) { case GL_TEXTURE_1D: if(bMipmap) gluBuild1DMipmaps(GL_TEXTURE_1D, pBuffer->GetChannels(), pBuffer->GetWidth(), pBuffer->GetFormat(), pBuffer->GetDataType(), pBuffer->GetBuffer()); else glTexImage1D(GL_TEXTURE_1D, 0, pBuffer->GetChannels(), pBuffer->GetWidth(), 0, pBuffer->GetFormat(), pBuffer->GetDataType(), pBuffer->GetBuffer()); break; case GL_TEXTURE_2D: if(bMipmap) gluBuild2DMipmaps(GL_TEXTURE_2D, pBuffer->GetChannels(), pBuffer->GetWidth(), pBuffer->GetHeight(), pBuffer->GetFormat(), pBuffer->GetDataType(), pBuffer->GetBuffer()); else glTexImage2D(GL_TEXTURE_2D, 0, pBuffer->GetChannels(), pBuffer->GetWidth(), pBuffer->GetHeight(), 0, pBuffer->GetFormat(), pBuffer->GetDataType(), pBuffer->GetBuffer()); break; } }
static int tolua_glu_gluBuild1DMipmaps00(lua_State* tolua_S) { #ifndef TOLUA_RELEASE tolua_Error tolua_err; if ( !tolua_isnumber(tolua_S,1,0,&tolua_err) || !tolua_isnumber(tolua_S,2,0,&tolua_err) || !tolua_isnumber(tolua_S,3,0,&tolua_err) || !tolua_isnumber(tolua_S,4,0,&tolua_err) || !tolua_isnumber(tolua_S,5,0,&tolua_err) || !tolua_isusertype(tolua_S,6,"GLLbuffer",0,&tolua_err) || !tolua_isnoobj(tolua_S,7,&tolua_err) ) goto tolua_lerror; else #endif { int target = (( int) tolua_tonumber(tolua_S,1,0)); int components = (( int) tolua_tonumber(tolua_S,2,0)); int width = (( int) tolua_tonumber(tolua_S,3,0)); int format = (( int) tolua_tonumber(tolua_S,4,0)); int type = (( int) tolua_tonumber(tolua_S,5,0)); GLLbuffer* data = ((GLLbuffer*) tolua_tousertype(tolua_S,6,0)); { int tolua_ret = ( int) gluBuild1DMipmaps(target,components,width,format,type,data); tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); } } return 1; #ifndef TOLUA_RELEASE tolua_lerror: tolua_error(tolua_S,"#ferror in function 'gluBuild1DMipmaps'.",&tolua_err); return 0; #endif }
void GLTexture::refresh() { Bitmap *bitmap = getBitmap(); /* Bind to the texture */ glBindTexture(m_glType, m_id); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); if (m_type == ETexture1D) { Assert((math::isPowerOfTwo(m_size.x) && m_size.y == 1) || (math::isPowerOfTwo(m_size.y) && m_size.x == 1)); if (isMipMapped()) { /* Let GLU generate mipmaps for us */ gluBuild1DMipmaps(m_glType, m_internalFormat, m_size.x == 1 ? m_size.y : m_size.x, m_format, m_dataFormat, bitmap->getData()); } else { } glTexImage1D(m_glType, 0, m_internalFormat, m_size.x == 1 ? m_size.y : m_size.x, 0, m_format, m_dataFormat, bitmap->getData()); } else if (m_type == ETexture2D) { /* Anisotropic texture filtering */ float anisotropy = (float) getMaxAnisotropy(); if (isMipMapped() && m_filterType == EMipMapLinear && anisotropy > 1.0f) glTexParameterf(m_glType, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy); glTexImage2D(m_glType, 0, m_internalFormat, m_size.x, m_size.y, 0, m_format, m_dataFormat, bitmap->getData()); } else if (m_type == ETextureCubeMap) { Assert(bitmap != NULL); Assert(bitmap->getWidth() == bitmap->getHeight()); Assert(math::isPowerOfTwo(bitmap->getWidth())); if (isMipMapped()) glTexParameteri(m_glType, GL_GENERATE_MIPMAP, GL_TRUE); for (int i=0; i<6; i++) { Bitmap *bitmap = getBitmap(i); GLuint pos; switch (i) { case ECubeMapPositiveX: pos = GL_TEXTURE_CUBE_MAP_POSITIVE_X; break; case ECubeMapNegativeX: pos = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; break; case ECubeMapPositiveY: pos = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; break; case ECubeMapNegativeY: pos = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; break; case ECubeMapPositiveZ: pos = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; break; case ECubeMapNegativeZ: pos = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; break; default: Log(EError, "Unknown cube map index"); return; }; glTexImage2D(pos, 0, m_internalFormat, bitmap->getWidth(), bitmap->getHeight(), 0, m_format, m_dataFormat, bitmap->getData()); } } else { Log(EError, "Unknown texture type!"); } if (isMipMapped()) glGenerateMipmapEXT(m_glType); }
void MeshView::generateTexture() { const int size = 1024; QImage image( size, 1, QImage::Format_ARGB32 ); QRgb* line = (QRgb*)image.scanLine( 0 ); DataFunctions::fillGradientCache( m_gradient, line, size ); QImage textureImage = QGLWidget::convertToGLFormat( image ); if ( m_textureId == 0 ) glGenTextures( 1, &m_textureId ); glBindTexture( GL_TEXTURE_1D, m_textureId ); gluBuild1DMipmaps( GL_TEXTURE_1D, 4, size, GL_RGBA, GL_UNSIGNED_BYTE, textureImage.bits() ); glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST ); glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glEnable( GL_TEXTURE_1D ); }
GLuint loadTextureRAW1D(const char * filename, bool wrap, unsigned int width, unsigned int depth) { // // Aufgabe 1.b // GLuint texture; char* data; FILE* file; data = (char*) malloc( width * depth ); file = fopen( filename, "rb" ); if ( file == NULL ) return 0; fread( data, width * depth, 1, file ); fclose( file ); glGenTextures( 1, &texture ); GET_GLERROR(0); glBindTexture( GL_TEXTURE_1D, texture ); GET_GLERROR(0); glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); GET_GLERROR(0); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST ); GET_GLERROR(0); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GET_GLERROR(0); glTexParameteri ( GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, static_cast<GLfloat>(wrap ? GL_REPEAT : GL_CLAMP) ); GET_GLERROR(0); glTexParameteri ( GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, static_cast<GLfloat>(wrap ? GL_REPEAT : GL_CLAMP) ); GET_GLERROR(0); gluBuild1DMipmaps( GL_TEXTURE_1D, depth, width, (depth == 1) ? GL_LUMINANCE : GL_RGB, GL_UNSIGNED_BYTE, data ); free ( data ); return texture; }
bool Texture :: upload ( int target, bool mipmap ) { if ( target == GL_TEXTURE_1D ) { if ( mipmap ) gluBuild1DMipmaps ( target, getNumComponents (), getWidth (), getFormat (), GL_UNSIGNED_BYTE, getData () ); else glTexImage1D ( target, 0, getNumComponents (), getWidth (), 0, getFormat (), GL_UNSIGNED_BYTE, getData () ); } else { if ( mipmap ) gluBuild2DMipmaps ( target, getNumComponents (), getWidth (), getHeight (), getFormat (), GL_UNSIGNED_BYTE, getData () ); else glTexImage2D ( target, 0, getNumComponents (), getWidth (), getHeight (), 0, getFormat (), GL_UNSIGNED_BYTE, getData () ); } return true; }
/*BuildMipmaps(components, format, pixelsArray) -> error */ static int luaglu_build_mipmaps(lua_State *L) { GLubyte *pixels; GLsizei width, height; int components; components = luaL_checkinteger(L, 1); height = luagl_get_array2uc(L, 3, &pixels, &width); if (height != -1) { lua_pushnumber(L, gluBuild2DMipmaps(GL_TEXTURE_2D, components, width/components, height, luagl_get_gl_enum(L, 2), GL_UNSIGNED_BYTE, pixels)); } else { /* if not 2D, get 1D */ width = luagl_get_arrayuc(L, 3, &pixels); lua_pushnumber(L, gluBuild1DMipmaps(GL_TEXTURE_1D, components, width/components, luagl_get_gl_enum(L, 2), GL_UNSIGNED_BYTE, pixels)); } LUAGL_DELETE_ARRAY(pixels); return 1; }
/*Build1DMipmaps(components, width, format, type, pixels) -> error (userdata)*/ static int luaglu_build_1d_mipmaps(lua_State *L) { lua_pushnumber(L, gluBuild1DMipmaps(GL_TEXTURE_1D, (GLint)luaL_checkinteger(L, 1), luaL_checkinteger(L, 2), luagl_get_gl_enum(L, 3), luagl_get_gl_enum(L, 4), luagl_checkuserdata(L, 5))); return 1; }
void CTextureSurfaceList::BuildSurfaceList(const CMemoryBuffer & data, size_t width, size_t height, size_t depth) { if(!width || !height || !depth) throw NOVA_EXP("CTextureSurfaceList::BuildSurfaseList - incorrect input size param.", BAD_OPERATION); GLenum type = CHardwarePixelBuffer::TextureTarget(mType); bool mipmap_hardware_gen = CRenderSystem::GetSingelton().CheckCapabilities(TEXTURE_CATEGORY, CAP_AUTOMIPMAP); COpenGLFormats informat; informat.SetExFormat(mPixelFormat); mMaxMipmaps = GetMaxMipmaps(width, height, depth); glEnable(type); if(mType == CHardwarePixelBuffer::USE_CUBEMAP_TEXTURE && mFace > 0) {} else glGenTextures(1, &mTargetId); glBindTexture(type, mTargetId); if(mMipState == USE_HARDWARE_MIPMAPS) { if(!mipmap_hardware_gen) mMipState = USE_SOFTWARE_MIPMAPS; } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); if(mMipState == DO_NOT_USE_MIPMAPS) { glTexParameteri(type, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(type, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); mMaxMipmaps = 1; switch(mType) { case CHardwarePixelBuffer::USE_TEXTURE_1D: glTexImage1D(GL_TEXTURE_1D, 0, informat.GetInternalChannels(), width, 0, informat.GetFormat(), GL_UNSIGNED_BYTE, data.GetBegin()); break; case CHardwarePixelBuffer::USE_TEXTURE_2D: glTexImage2D(GL_TEXTURE_2D, 0, informat.GetInternalChannels(), width, height, 0, informat.GetFormat(), GL_UNSIGNED_BYTE, data.GetBegin()); break; case CHardwarePixelBuffer::USE_TEXTURE_3D: glTexImage3D(GL_TEXTURE_3D, 0, informat.GetInternalChannels(), width, height, depth, 0, informat.GetFormat(), GL_UNSIGNED_BYTE, data.GetBegin()); break; case CHardwarePixelBuffer::USE_CUBEMAP_TEXTURE: glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + mFace, 0, informat.GetInternalChannels(), width, height, 0, informat.GetFormat(), GL_UNSIGNED_BYTE, data.GetBegin()); break; } } else if(mMipState == USE_SOFTWARE_MIPMAPS) { glTexParameteri(type, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(type, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); switch(mType) { case CHardwarePixelBuffer::USE_TEXTURE_1D: gluBuild1DMipmaps(GL_TEXTURE_1D, informat.GetInternalChannels(), width, informat.GetFormat(), GL_UNSIGNED_BYTE, data.GetBegin()); break; case CHardwarePixelBuffer::USE_TEXTURE_2D: gluBuild2DMipmaps(GL_TEXTURE_2D, informat.GetInternalChannels(), width, height, informat.GetFormat(), GL_UNSIGNED_BYTE, data.GetBegin()); break; case CHardwarePixelBuffer::USE_CUBEMAP_TEXTURE: gluBuild2DMipmaps(GL_TEXTURE_CUBE_MAP_POSITIVE_X + mFace, informat.GetInternalChannels(), width, height, informat.GetFormat(), GL_UNSIGNED_BYTE, data.GetBegin()); break; case CHardwarePixelBuffer::USE_TEXTURE_3D: throw NOVA_EXP("CTextureSurfaceList::BuildSurfaseList - \ OpenGL can not support software 3D mipmaps", BAD_OPERATION); break; } }
void Texture::setup_texture_data( int dim, Image::ColorEncoding encoding_in, Memory::pointer base_mem_in, Texture::FilteringMode mode, int width, int height, int depth) { const int static_buffer_size = 1024*1024 ; static Memory::byte static_buffer[static_buffer_size * 4] ; Memory::pointer dynamic_buffer = nil ; Memory::pointer base_mem = base_mem_in ; Image::ColorEncoding encoding = encoding_in ; mipmap_ = (mode == Texture::MIPMAP) ; linear_filter_ = (mode != Texture::NO_FILTERING) ; if(height == 0) { height++ ; } if(depth == 0) { depth++ ; } int size = width * height * depth ; if(encode_indexed_to_rgb_ && (encoding == Image::GRAY || encoding == Image::INDEXED)) { if(dim == 3 && encoding == Image::GRAY) { } else { encoding = Image::RGBA ; if(size <= static_buffer_size) { base_mem = static_buffer ; } else { dynamic_buffer = new Memory::byte[size*4] ; base_mem = dynamic_buffer ; } indexed_to_rgb(size, base_mem_in, Image::RGBA, base_mem) ; } } switch(dim) { case 1: switch(encoding) { case Image::GRAY : case Image::INDEXED : gluBuild1DMipmaps( GL_TEXTURE_1D, GL_RGBA, width, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, base_mem ) ; break ; case Image::RGB : gluBuild1DMipmaps( GL_TEXTURE_1D, GL_RGB, width, GL_RGB, GL_UNSIGNED_BYTE, base_mem ) ; break ; case Image::RGBA : gluBuild1DMipmaps( GL_TEXTURE_1D, GL_RGBA, width, GL_RGBA, GL_UNSIGNED_BYTE, base_mem ) ; break ; case Image::FLOAT32 : { Memory::pointer colormapped_texture_values = new Memory::byte[4 * width]; float32_to_rgb(size, base_mem_in, Image::RGBA, colormapped_texture_values); gluBuild1DMipmaps( GL_TEXTURE_1D, GL_RGBA, width, GL_RGBA, GL_UNSIGNED_BYTE, colormapped_texture_values ) ; delete[] colormapped_texture_values; break ; } default: { bool implemented = false ; ogf_assert(implemented) ; } } break ; case 2: switch(encoding) { case Image::GRAY : case Image::INDEXED : if(mipmap_) { gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, width, height, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, base_mem ) ; } else { glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, base_mem ) ; } break ; case Image::RGB : if(mipmap_) { gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGB, width, height, GL_RGB, GL_UNSIGNED_BYTE, base_mem ) ; } else { glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, base_mem ) ; } break ; case Image::RGBA : if(mipmap_) { gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, base_mem ) ; } else { glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, base_mem ) ; } break ; case Image::RGB_FLOAT32: glTexImage2D( GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB32_NV, width, height, 0, GL_RGB, GL_FLOAT, base_mem ) ; break ; case Image::RGBA_FLOAT32: glTexImage2D( GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGBA32_NV, width, height, 0, GL_RGBA, GL_FLOAT, base_mem ) ; break ; case Image::FLOAT32 : { Memory::pointer colormapped_texture_values = new Memory::byte[4 * width * height]; float32_to_rgb(size, base_mem_in, Image::RGBA, colormapped_texture_values); if(mipmap_) { gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, colormapped_texture_values ) ; } else { glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, colormapped_texture_values ) ; } delete[] colormapped_texture_values; break ; } default: { bool implemented = false ; ogf_assert(implemented) ; } break ; } break ; case 3: // Note: gluBuild3DMipmaps does not seem to exist under Windows #ifdef WIN32 mipmap_ = false ; #endif switch(encoding) { case Image::GRAY : if(mipmap_) { #ifndef WIN32 gluBuild3DMipmaps( GL_TEXTURE_3D, GL_LUMINANCE, width, height, depth, GL_LUMINANCE, GL_UNSIGNED_BYTE, base_mem ) ; #endif } else { glTexImage3DEXT( GL_TEXTURE_3D, 0, GL_LUMINANCE, width, height, depth, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, base_mem ) ; } break ; case Image::INDEXED : if(mipmap_) { #ifndef WIN32 gluBuild3DMipmaps( GL_TEXTURE_3D, GL_RGBA, width, height, depth, GL_RGB, GL_UNSIGNED_BYTE, base_mem ) ; #endif } else { glTexImage3DEXT( GL_TEXTURE_3D, 0, GL_RGB, width, height, depth, 0, GL_RGB, GL_UNSIGNED_BYTE, base_mem ) ; } break ; case Image::RGB : if(mipmap_) { #ifndef WIN32 gluBuild3DMipmaps( GL_TEXTURE_3D, GL_RGB, width, height, depth, GL_RGB, GL_UNSIGNED_BYTE, base_mem ) ; #endif } else { glTexImage3DEXT( GL_TEXTURE_3D, 0, GL_RGB, width, height, depth, 0, GL_RGB, GL_UNSIGNED_BYTE, base_mem ) ; } break ; case Image::RGBA : if(mipmap_) { #ifndef WIN32 gluBuild3DMipmaps( GL_TEXTURE_3D, GL_RGBA, width, height, depth, GL_RGBA, GL_UNSIGNED_BYTE, base_mem ) ; #endif } else { glTexImage3DEXT( GL_TEXTURE_3D, 0, GL_RGBA, width, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, base_mem ) ; } break ; case Image::FLOAT32 : { Memory::pointer colormapped_texture_values = new Memory::byte[4 * width * height * depth]; float32_to_rgb(size, base_mem_in, Image::RGBA, colormapped_texture_values); if(mipmap_) { #ifndef WIN32 gluBuild3DMipmaps( GL_TEXTURE_3D, GL_RGBA, width, height, depth, GL_RGBA, GL_UNSIGNED_BYTE, colormapped_texture_values ) ; #endif } else { glTexImage3DEXT( GL_TEXTURE_3D, 0, GL_RGBA, width, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, colormapped_texture_values ) ; } delete[] colormapped_texture_values; break ; } default: { bool implemented = false ; ogf_assert(implemented) ; } } break ; } delete[] dynamic_buffer ; }
void DriftingGratingStimulus::load(shared_ptr<StimulusDisplay> display) { if (loaded) return; for(int i = 0; i < display->getNContexts(); ++i) { display->setCurrent(i); GLuint textures[2]; glGenTextures(2, textures); mask_textures.push_back(textures[0]); grating_textures.push_back(textures[1]); glDisable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_1D); // ---------------------------------------- // GRATING // ---------------------------------------- // select our current texture glBindTexture( GL_TEXTURE_1D, grating_textures[i] ); // select modulate to mix texture with color for shading glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE ); // when texture area is small, bilinear filter the closest mipmap glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST ); // when texture area is large, bilinear filter the first mipmap glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); // if wrap is true, the texture wraps over at the edges (repeat) // ... false, the texture ends at the edges (clamp) glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_REPEAT ); gluBuild1DMipmaps(GL_TEXTURE_1D, GL_LUMINANCE, grating->getDataSize(), GL_LUMINANCE, GL_FLOAT, grating->get1DData()); glEnable(GL_TEXTURE_1D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(1,1,1,1); // ---------------------------------------- // MASK // ---------------------------------------- glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); // select our current texture glBindTexture( GL_TEXTURE_2D, mask_textures[i] ); // select modulate to mix texture with color for shading glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); gluBuild2DMipmaps(GL_TEXTURE_2D, 2, mask->getSize(), mask->getSize(), GL_LUMINANCE_ALPHA, GL_FLOAT, mask->get2DData()); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); // Unbind grating texture glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture( GL_TEXTURE_1D, 0 ); glBindTexture( GL_TEXTURE_2D, 0 ); glDisable(GL_TEXTURE_1D); glDisable(GL_TEXTURE_2D); // Unbind mask texture glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture( GL_TEXTURE_1D, 0 ); glBindTexture( GL_TEXTURE_2D, 0 ); glDisable(GL_TEXTURE_1D); glDisable(GL_TEXTURE_2D); glActiveTextureARB(0); } loaded = true; }
void GenerateDisplayLists() { // generowanie identyfikatora listy wyświetlania RECT_LIST = glGenLists(1); // lista wyświetlania - prostokąt glNewList(RECT_LIST, GL_COMPILE); // nałżenie tekstury na prostokąt glBegin(GL_QUADS); glTexCoord1f(1.0); glVertex2f(1.5, 0.7); glTexCoord1f(0.0); glVertex2f(-1.5, 0.7); glTexCoord1f(0.0); glVertex2f(-1.5, -0.7); glTexCoord1f(1.0); glVertex2f(1.5, -0.7); glEnd(); // koniec listy wyświetlania glEndList(); // sprawdzenie czy implementacja biblioteki obsługuje tekstury o wymiarze 256 GLint size; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &size); if (size < 512) { printf("Rozmiar tekstur mniejszy od 512"); exit(0); } // generowanie identyfikatora listy wyświetlania SPECTRUM_1_LIST = glGenLists(1); // lista wyświetlania - pierwsza "tęcza" glNewList(SPECTRUM_1_LIST, GL_COMPILE); // definiowanie tekstury i mipmap glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB, 512, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_512); glTexImage1D(GL_TEXTURE_1D, 1, GL_RGB, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_256); glTexImage1D(GL_TEXTURE_1D, 2, GL_RGB, 128, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_128); glTexImage1D(GL_TEXTURE_1D, 3, GL_RGB, 64, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_64); glTexImage1D(GL_TEXTURE_1D, 4, GL_RGB, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_32); glTexImage1D(GL_TEXTURE_1D, 5, GL_RGB, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_16); glTexImage1D(GL_TEXTURE_1D, 6, GL_RGB, 8, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_8); glTexImage1D(GL_TEXTURE_1D, 7, GL_RGB, 4, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_4); glTexImage1D(GL_TEXTURE_1D, 8, GL_RGB, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_2); glTexImage1D(GL_TEXTURE_1D, 9, GL_RGB, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_1); // odłżenie macierzy modelowania na stos glPushMatrix(); // przesunięcie prostokąta do góry o dwie jednostki glTranslatef(0.0, 2.0, 0.0); // nałżenie tekstury na prostokąt glCallList(RECT_LIST); // zdjęcie macierzy modelowania ze stosu glPopMatrix(); // koniec listy wyświetlania glEndList(); // generowanie identyfikatora listy wyświetlania SPECTRUM_2_LIST = glGenLists(1); // lista wyświetlania - druga "tęcza" glNewList(SPECTRUM_2_LIST, GL_COMPILE); // definiowanie tekstury łącznie z mipmapami gluBuild1DMipmaps(GL_TEXTURE_1D, GL_RGB, 512, GL_RGB, GL_UNSIGNED_BYTE, spectrum_512); // nałżenie tekstury na prostokąt glCallList(RECT_LIST); // koniec listy wyświetlania glEndList(); // generowanie identyfikatora listy wyświetlania SPECTRUM_3_LIST = glGenLists(1); // lista wyświetlania - trzecia "tęcza" glNewList(SPECTRUM_3_LIST, GL_COMPILE); // włączenie automatycznego generowania mipmap glTexParameteri(GL_TEXTURE_1D, GL_GENERATE_MIPMAP, GL_TRUE); // definiowanie tekstury glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB, 512, 0, GL_RGB, GL_UNSIGNED_BYTE, spectrum_512); // wyłączenie automatycznego generowania mipmap glTexParameteri(GL_TEXTURE_1D, GL_GENERATE_MIPMAP, GL_FALSE); // odłżenie macierzy modelowania na stos glPushMatrix(); // przesunięcie prostokąta do dołu o dwie jednostki glTranslatef(0.0, -2.0, 0.0); // nałżenie tekstury na prostokąt glCallList(RECT_LIST); // zdjęcie macierzy modelowania ze stosu glPopMatrix(); // koniec listy wyświetlania glEndList(); }