示例#1
0
void TextureFactory::set_parameters(const TexturePtr &texture, const TextureFormat &format)
{
	for (const ITextureParameterPtr &param : format.get_parameters())
	{
		if (ITextureParameter::is_type<int>(param))
		{
			auto int_param = std::static_pointer_cast<TextureParameter<int>>(param);
			glTexParameteri(format.get_type(), param->get_name(), int_param->get_param());
		}
		else if (ITextureParameter::is_type<float>(param))
		{
			auto float_param = std::static_pointer_cast<TextureParameter<float>>(param);
			glTexParameterf(format.get_type(), param->get_name(), float_param->get_param());
		}
		else if (ITextureParameter::is_type<glm::ivec4>(param))
		{
			auto int_params = std::static_pointer_cast<TextureParameter<glm::ivec4>>(param);
			glTexParameteriv(format.get_type(), param->get_name(), glm::value_ptr(int_params->get_param()));
		}
		else if (ITextureParameter::is_type<glm::vec4>(param))
		{
			auto float_params = std::static_pointer_cast<TextureParameter<glm::vec4>>(param);
			glTexParameterfv(format.get_type(), param->get_name(), glm::value_ptr(float_params->get_param()));
		}
	}
}
示例#2
0
void ImageKnob::onDisplay()
{
    const float normValue = (fValue - fMinimum) / (fMaximum - fMinimum);

    if (fRotationAngle != 0)
    {
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, fTextureId);

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glPixelStorei(GL_PACK_ALIGNMENT, 1);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, getWidth(), getHeight(), 0, fImage.getFormat(), fImage.getType(), fImage.getRawData());

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

        float trans[] = { 0.0f, 0.0f, 0.0f, 0.0f };
        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, trans);

        glPushMatrix();

        const GLint w2 = getWidth()/2;
        const GLint h2 = getHeight()/2;

        glTranslatef(getX()+w2, getY()+h2, 0.f);
        glRotatef(normValue*fRotationAngle, 0.0f, 0.0f, 1.0f);

        glBegin(GL_QUADS);
          glTexCoord2f(0.0f, 1.0f);
          glVertex2i(-w2, -h2);

          glTexCoord2f(1.0f, 1.0f);
          glVertex2i(getWidth()-w2, -h2);

          glTexCoord2f(1.0f, 0.0f);
          glVertex2i(getWidth()-w2, getHeight()-h2);

          glTexCoord2f(0.0f, 0.0f);
          glVertex2i(-w2, getHeight()-h2);
        glEnd();

        glPopMatrix();

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);
    }
    else
    {
        const int layerDataSize   = fImgLayerSize * fImgLayerSize * ((fImage.getFormat() == GL_BGRA || fImage.getFormat() == GL_RGBA) ? 4 : 3);
        const int imageDataSize   = layerDataSize * fImgLayerCount;
        const int imageDataOffset = imageDataSize - layerDataSize - (layerDataSize * int(normValue * float(fImgLayerCount-1)));

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glPixelStorei(GL_PACK_ALIGNMENT, 1);
        glRasterPos2i(getX(), getY()+getHeight());
        glDrawPixels(fImgLayerSize, fImgLayerSize, fImage.getFormat(), fImage.getType(), fImage.getRawData() + imageDataOffset);
    }
}
示例#3
0
QOpenGLFramebufferObject* TextureCache::getShadowFramebufferObject() {
    if (!_shadowFramebufferObject) {
        const int SHADOW_MAP_SIZE = 2048;
        _shadowFramebufferObject = new QOpenGLFramebufferObject(SHADOW_MAP_SIZE, SHADOW_MAP_SIZE,
            QOpenGLFramebufferObject::NoAttachment, GL_TEXTURE_2D, GL_RGB);
        
        glGenTextures(1, &_shadowDepthTextureID);
        glBindTexture(GL_TEXTURE_2D, _shadowDepthTextureID);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE,
            0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
        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_BORDER);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
        const float DISTANT_BORDER[] = { 1.0f, 1.0f, 1.0f, 1.0f };
        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, DISTANT_BORDER);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
        glBindTexture(GL_TEXTURE_2D, 0);
        
        _shadowFramebufferObject->bind();
        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, _shadowDepthTextureID, 0);
        _shadowFramebufferObject->release();
    }
    return _shadowFramebufferObject;
}
示例#4
0
	void FBOTexture::CreateShadowmap(int resolution, int quality)
	{
		if (quality == GFX_SHADOWS_DISABLED)
			return;

		GLenum err;
		//Initialize Shadowmap texture, parameters should be configurable through settings
		glGenTextures(1, &m_textureHandle);
		glBindTexture(GL_TEXTURE_2D, m_textureHandle);

		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_BORDER);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

		// Create 2 channel texture for variance shadowmapping
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RG32F, resolution, resolution, 0, GL_RG, GL_FLOAT, nullptr);
		GLfloat border[4] = { 1.0f, 1.0f, 0.0f, 0.0f };
		glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4);
		glGenerateMipmap(GL_TEXTURE_2D);

		m_width = resolution;
		m_height = resolution;
	}
示例#5
0
文件: Texture.cpp 项目: mutexre/Base
void GL::Texture::setSamplingState(TextureTarget target, const SamplingState& state) {
    if (state.isParameterSet(SamplingState::Parameter::WrapS))
        glTexParameteri(GLenum(target), GL_TEXTURE_WRAP_S, GLint(state.wrap.s));

    if (state.isParameterSet(SamplingState::Parameter::WrapT))
        glTexParameteri(GLenum(target), GL_TEXTURE_WRAP_T, GLint(state.wrap.t));

    if (state.isParameterSet(SamplingState::Parameter::WrapR))
        glTexParameteri(GLenum(target), GL_TEXTURE_WRAP_R, GLint(state.wrap.r));

    if (state.isParameterSet(SamplingState::Parameter::MinFilter))
        glTexParameteri(GLenum(target), GL_TEXTURE_MIN_FILTER, GLint(state.filter.min));

    if (state.isParameterSet(SamplingState::Parameter::MagFilter))
        glTexParameteri(GLenum(target), GL_TEXTURE_MAG_FILTER, GLint(state.filter.mag));

    if (state.isParameterSet(SamplingState::Parameter::BorderColor))
        glTexParameterfv(GLenum(target), GL_TEXTURE_BORDER_COLOR, &(state.borderColor.r));

    if (state.isParameterSet(SamplingState::Parameter::MinLOD))
        glTexParameterf(GLenum(target), GL_TEXTURE_MIN_LOD, state.LOD.min);

    if (state.isParameterSet(SamplingState::Parameter::MaxLOD))
        glTexParameterf(GLenum(target), GL_TEXTURE_MAX_LOD, state.LOD.max);

    if (state.isParameterSet(SamplingState::Parameter::LODbias))
        glTexParameterf(GLenum(target), GL_TEXTURE_LOD_BIAS, state.LOD.bias);

    if (state.isParameterSet(SamplingState::Parameter::CompareMode))
        glTexParameteri(GLenum(target), GL_TEXTURE_COMPARE_MODE, GLint(state.compare.mode));

    if (state.isParameterSet(SamplingState::Parameter::CompareFunc))
        glTexParameteri(GLenum(target), GL_TEXTURE_COMPARE_FUNC, GLint(state.compare.func));
}
示例#6
0
void Texture::CreateDepthBuffer(int width, int height)
{
	this->width = width;
	this->height = height;
	samplerName = "depth_map";

	glGenFramebuffers(1, &frameBufferID);

	glGenTextures(1, &textureID);
	glBindTexture(GL_TEXTURE_2D, textureID);

	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
	GLfloat borderColor[] = { 1.0f, 0.0f, 0.0f, 0.0f };
	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
	
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); 
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
	

	glBindFramebuffer(GL_FRAMEBUFFER, frameBufferID);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, textureID, 0);
	glDrawBuffer(GL_NONE);
	glReadBuffer(GL_NONE);
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

}
void TextureMain::loadLightMapTexture(Model_IMG* model, string file) {

    GLfloat eyePlaneS[] =  {1.0f, 0.0f, 0.0f, 0.0f};
    GLfloat eyePlaneT[] =  {0.0f, 1.0f, 0.0f, 0.0f};
    GLfloat eyePlaneR[] =  {0.0f, 0.0f, 1.0f, 0.0f};
    GLfloat eyePlaneQ[] =  {0.0f, 0.0f, 0.0f, 1.0f};
    GLfloat borderColor[] = {1.f, 1.f, 1.f, 1.0f};

    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);

    glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
    glTexGenfv(GL_S,GL_EYE_PLANE,eyePlaneS);
    glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
    glTexGenfv(GL_T,GL_EYE_PLANE,eyePlaneT);
    glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
    glTexGenfv(GL_R,GL_EYE_PLANE,eyePlaneR);
    glTexGeni(GL_Q,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
    glTexGenfv(GL_Q,GL_EYE_PLANE,eyePlaneQ);

    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
    glEnable(GL_TEXTURE_GEN_R);
    glEnable(GL_TEXTURE_GEN_Q);

    model->Load(file);

    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0x812D);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 0x812D);
    glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_BORDER_COLOR,borderColor);
    gluBuild2DMipmaps(GL_TEXTURE_2D,GL_RGB,model->Width,model->Height,GL_RGB,GL_UNSIGNED_BYTE,model->Pixels);
}
示例#8
0
文件: main.c 项目: boompig/chromium
static void
InitSpecial(void)
{
	GLubyte textureData[32 * 32];
	float testAni = 16;
	int x, y;
	GLint err;

	for (x = 0; x < 32; x++)
	{
		for (y = 0; y < 32; y++)
		{
			if ((x < 16 && y < 16) || (x >= 16 && y >= 16))
				textureData[y * 32 + x] = 0;
			else
				textureData[y * 32 + x] = 255;
		}
	}

	/* Create the tile texture. */
	glGenTextures(4, texture);

#ifdef MULTIPLE_VIEWPORTS

	/* Create Bilinear Filtered Texture */
	glBindTexture(GL_TEXTURE_2D, texture[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 32, 32, 0, GL_LUMINANCE,
		     GL_UNSIGNED_BYTE, textureData);

	/* Create Bilinear MipMapped Texture */
	glBindTexture(GL_TEXTURE_2D, texture[1]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
			GL_LINEAR_MIPMAP_NEAREST);
	err =gluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE, 32, 32, GL_LUMINANCE,
			       GL_UNSIGNED_BYTE, textureData);

	/* Create Trilinear MipMapped Texture */
	glBindTexture(GL_TEXTURE_2D, texture[2]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
			GL_LINEAR_MIPMAP_LINEAR);
	err = gluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE, 32, 32, GL_LUMINANCE,
				GL_UNSIGNED_BYTE, textureData);

#endif

	/* Create Anisotropic Texture */
	glBindTexture(GL_TEXTURE_2D, texture[3]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameterfv(GL_TEXTURE_2D, (GLenum) GL_TEXTURE_MAX_ANISOTROPY_EXT, &testAni);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 32, 32, 0, GL_LUMINANCE,
		     GL_UNSIGNED_BYTE, textureData);

	glGetTexParameterfv(GL_TEXTURE_2D, (GLenum) GL_TEXTURE_MAX_ANISOTROPY_EXT, &testAni);
	printf("Current Anisotropy: %f", testAni);
}
示例#9
0
文件: sphere.c 项目: medusade/mxde
void ReInit(void)
{

    if (genericObject == torus) {
	glEnable(GL_DEPTH_TEST);
    } else  {
	glDisable(GL_DEPTH_TEST);
    }
    if (isFogged) {
	textureEnvironment = modulate;
    }

    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
    glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, textureEnvironment);
}
示例#10
0
GLuint
OpenGLSurface::TextureYUV (int i)
{
	if (!textureYUV[i]) {
		int j;

		GLSurface::TextureYUV (i);

		for (j = 0; j < 3; j++) {
			GLfloat border[][4] = {
				{ 0.0625f, 0.0625f, 0.0625f, 0.0625f },
				{   0.5f ,    0.5f,    0.5f,    0.5f },
				{   0.5f ,    0.5f,    0.5f,    0.5f }
			};

			glBindTexture (GL_TEXTURE_2D, textureYUV[j]);
			glTexParameterfv (GL_TEXTURE_2D,
					  GL_TEXTURE_BORDER_COLOR,
					  border[j]);
		}
		glBindTexture (GL_TEXTURE_2D, 0);
	}

	return textureYUV[i];
}
示例#11
0
void
piglit_init(int argc, char **argv)
{
	GLubyte pixels[TEX_SIZE][TEX_SIZE][4];
	GLuint tex;
	int i, j;

	piglit_require_gl_version(13);

	/* solid red texture */
	for (i = 0; i < TEX_SIZE; i++) {
		for (j = 0; j < TEX_SIZE; j++) {
			pixels[i][j][0] = 255;
			pixels[i][j][1] = 0;
			pixels[i][j][2] = 0;
			pixels[i][j][3] = 255;
		}
	}

	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_3D, tex);
	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	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);
	glTexParameterfv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, green);

	glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 1,
		     0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

	glEnable(GL_TEXTURE_3D);
}
示例#12
0
bool Texture::loadFromFile(const char * filename, bool no_repeat)
{
	glGenTextures(1, &texture);

	glBindTexture(GL_TEXTURE_2D, texture);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, no_repeat ? GL_CLAMP_TO_BORDER : GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, no_repeat ? GL_CLAMP_TO_BORDER : GL_REPEAT);

	if (no_repeat)
	{
		float border_color[] = { 0.0f, 0.0f, 0.0f, 0.0f };
		glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
	}

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	unsigned char* image = SOIL_load_image(filename, &width, &height, 0, SOIL_LOAD_RGBA);

	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
	glGenerateMipmap(GL_TEXTURE_2D);

	SOIL_free_image_data(image);

	glBindTexture(GL_TEXTURE_2D, 0);

	return true;
}
    void render(double t)
    {
        static const GLfloat green[] = { 0.0f, 0.1f, 0.0f, 1.0f };
        static const GLfloat yellow[] = { 0.4f, 0.4f, 0.0f, 1.0f };
        glClearBufferfv(GL_COLOR, 0, green);

        static const GLenum wrapmodes[] = { GL_CLAMP_TO_EDGE, GL_REPEAT, GL_CLAMP_TO_BORDER, GL_MIRRORED_REPEAT };
        static const float offsets[] = { -0.5f, -0.5f,
                                          0.5f, -0.5f,
                                         -0.5f,  0.5f,
                                          0.5f,  0.5f };

        glUseProgram(program);
        glViewport(0, 0, info.windowWidth, info.windowHeight);

        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, yellow);

        for (int i = 0; i < 4; i++)
        {
            glUniform2fv(0, 1, &offsets[i * 2]);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapmodes[i]);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapmodes[i]);

            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
        }
    }
示例#14
0
void Environment::createDL()
{
  if((dlhandle == 0 || !glIsList(dlhandle)) && cubeMap.getUseAsDirectTextures())
  {
    if(dlhandle == 0)
      dlhandle = glGenLists(1);
    glNewList(dlhandle, GL_COMPILE);
    {
      glEnableClientState(GL_VERTEX_ARRAY);
      glVertexPointer(3, GL_FLOAT, 0, environmentCubeVertices);
      if(texIDhandles.empty())
        texIDhandles = cubeMap.getTextureIDs();
      if(texIDhandles.size() > 0)
      {
        if(GLEW_VERSION_1_3)
          glActiveTexture(GL_TEXTURE0);
        glEnable(GL_TEXTURE_2D);
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        glTexCoordPointer(2, GL_FLOAT, 0, environmentCubeTexCoords);

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, nocolor);
        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_WRAP_R, GL_REPEAT);

        if(texIDhandles.size() == 1)
        {
          glBindTexture(GL_TEXTURE_2D, texIDhandles[0]);
          glDrawArrays(GL_QUADS, 0, 24);
        }
        else
        {
          glBindTexture(GL_TEXTURE_2D, texIDhandles[0]);
          glDrawArrays(GL_QUADS, 0, 4);
          glBindTexture(GL_TEXTURE_2D, texIDhandles[1]);
          glDrawArrays(GL_QUADS, 4, 4);
          glBindTexture(GL_TEXTURE_2D, texIDhandles[2]);
          glDrawArrays(GL_QUADS, 8, 4);
          glBindTexture(GL_TEXTURE_2D, texIDhandles[3]);
          glDrawArrays(GL_QUADS, 12, 4);
          glBindTexture(GL_TEXTURE_2D, texIDhandles[4]);
          glDrawArrays(GL_QUADS, 16, 4);
          glBindTexture(GL_TEXTURE_2D, texIDhandles[5]);
          glDrawArrays(GL_QUADS, 20, 4);
        }

        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        glDisable(GL_TEXTURE_2D);
      }
      else
        glDrawArrays(GL_QUADS, 0, 24);
      glDisableClientState(GL_VERTEX_ARRAY);
    }
    glEndList();
  }
}
void
SmokeRenderer::setLightColor(vec3f c)
{
    m_lightColor = c;

    // set light texture border color
    GLfloat borderColor[4] = { 1.0 - m_lightColor[0], 1.0 - m_lightColor[1], 1.0 - m_lightColor[2], 0.0 };

    glBindTexture(GL_TEXTURE_2D, m_lightTexture[0]);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);

    glBindTexture(GL_TEXTURE_2D, m_lightTexture[1]);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);

    glBindTexture(GL_TEXTURE_2D, 0);
}
示例#16
0
文件: shPaint.c 项目: Chazzz/pyShiva
void shSetPatternTexGLState(SHPaint *p, VGContext *c)
{
  glBindTexture(GL_TEXTURE_2D, ((SHImage*)p->pattern)->texture);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  
  switch(p->tilingMode) {
  case VG_TILE_FILL:
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR,
                     (GLfloat*)&c->tileFillColor);
    break;
  case VG_TILE_PAD:
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    break;
  case VG_TILE_REPEAT:
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    break;
  case VG_TILE_REFLECT:
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
    break;
  }
  
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glColor4f(1,1,1,1);
}
示例#17
0
文件: g_render.c 项目: aosm/X11
void __glXDisp_TexParameterfv(GLbyte *pc)
{
	glTexParameterfv( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}
void QOpenGLTextureHelper::qt_TextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params)
{
    GLint oldTexture;
    glGetIntegerv(bindingTarget, &oldTexture);
    glBindTexture(target, texture);
    glTexParameterfv(target, pname, params);
    glBindTexture(target, oldTexture);
}
示例#19
0
	void GLtexture::setBorderColor(const Rgba& color)
	{
		glBindTexture(GL_TEXTURE_2D, getObject());

		Vector4 fcolor = color.toVector();

		glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, fcolor);
	}
示例#20
0
	void Texture2D::SetTextureBorderColor( const GLuint color /* = 0x0 */)
	{
		GLfloat colorf[4];
		colorf[0] = (GLfloat)(color >> 24) / 255.0f;
		colorf[1] = (GLfloat)((color >> 16) & 255) / 255.0f; 
		colorf[2] = (GLfloat)((color >> 8) & 255) / 255.0f;
		colorf[3] = 0.0f;
		glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, colorf);
	}
示例#21
0
void Texture::initRGBFile(const char* imgFile)
{
	static GLubyte *texData;
	GLfloat borderColor[4] = { 1.0, 1.0, 1.0, 1.0 };

	int width, height;
	int w, h;
	GLubyte *image, *img, *p;
	int i, j, components;

	image = (GLubyte *)read_rgb_texture(imgFile, &width, &height, &components);
	//w = width + 2 * 2;
	//h = height + 2 * 2;

	w = width;
	h = height;

	img = (GLubyte *)calloc(w * h, 4 * sizeof(unsigned char));

	p = img;
	//    for (j = -2; j < height + 2; ++j) {
	//        for (i = -2; i < width + 2; ++i) {

	for (j = 0; j < height; ++j) {
		for (i = 0; i < width; ++i) {
			if (0 <= j && j <= height - 1 && 0 <= i && i <= width - 1) {
				p[0] = image[4 * (j * width + i) + 0];
				p[1] = image[4 * (j * width + i) + 1];
				p[2] = image[4 * (j * width + i) + 2];
				p[3] = 0xff;
			}
			else {
				p[0] = borderColor[0] * 0xff;
				p[1] = borderColor[1] * 0xff;
				p[2] = borderColor[2] * 0xff;
				p[3] = borderColor[3] * 0xff;
			}
			p += 4;
		}
	}
	free(image);

	glGenTextures(1, texture);
	glBindTexture(GL_TEXTURE_2D, texture[0]);
	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);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
	//gluBuild2DMipmaps(GL_TEXTURE_2D, 4, w, h,
	  //                GL_RGBA, GL_UNSIGNED_BYTE, img);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, img);
	glBindTexture(GL_TEXTURE_2D, 0);

}
示例#22
0
bool ccFrameBufferObject::initDepth(GLint wrapParam /*=GL_CLAMP_TO_BORDER*/,
                                    GLenum internalFormat /*=GL_DEPTH_COMPONENT24*/,
                                    GLint minMagFilter /*= GL_NEAREST*/,
                                    GLenum target/*=GL_TEXTURE_2D*/)
{
    if (fboId==0)
    {
        //ccConsole::Warning("[FBO::initDepth] Internal error: FBO not yet initialized!");
        return false;
    }

    start();

    if (glIsTexture(depthTexture))
        glDeleteTextures(1,&depthTexture);

    glGenTextures(1,&depthTexture);
    glBindTexture(target,depthTexture);

    /* INITIAL VERSION
    glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT24,width,height,0,GL_DEPTH_COMPONENT,GL_UNSIGNED_INT,NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glBindTexture(GL_TEXTURE_2D, 0);
    //*/
	float border[]={1.0,1.0,1.0,1.0};
	glTexParameteri(target, GL_TEXTURE_WRAP_S, wrapParam);
	glTexParameteri(target, GL_TEXTURE_WRAP_T, wrapParam);
	glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, border);
	glTexParameteri(target, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
	glTexParameteri(target, GL_TEXTURE_COMPARE_MODE, GL_NONE);
	glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minMagFilter);
	glTexParameteri(target, GL_TEXTURE_MAG_FILTER, minMagFilter);
	glTexImage2D(target,0,internalFormat,width,height,0,GL_DEPTH_COMPONENT,GL_UNSIGNED_BYTE,0);

    //glFramebufferTextureEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,depthTexture,0);
	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,target,depthTexture,0);

    glBindTexture(target, 0);

    bool success = false;
    GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
	switch (status)
	{
		case GL_FRAMEBUFFER_COMPLETE_EXT:
            //ccConsole::Print("[FBO] Depth init. ok");
            success = true;
			break;
		default:
            //ccConsole::Warning("[FBO] Depth texture init. error: %i",status);
            break;
	}

    stop();

	return success;
}
void RenderSystem::setTextureBorderColor(
    float r,
    float g,
    float b,
    float a
) {
    GLfloat border[] = {r, g, b, a};
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border);
    CROSS_GL_ASSERT();
}
示例#24
0
bool CShadowHandler::InitDepthTarget()
{
	// this can be enabled for debugging
	// it turns the shadow render buffer in a buffer with color
	bool useColorTexture = false;
	if (!fb.IsValid()) {
		LOG_L(L_ERROR, "[%s] framebuffer not valid", __FUNCTION__);
		return false;
	}
	glGenTextures(1, &shadowTexture);

	glBindTexture(GL_TEXTURE_2D, shadowTexture);
	float one[4] = {1.0f, 1.0f, 1.0f, 1.0f};
	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, one);
	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_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	if (useColorTexture) {
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, shadowMapSize, shadowMapSize, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
	} else {
		const GLint texFormat = globalRendering->support24bitDepthBuffers ? GL_DEPTH_COMPONENT24 : GL_DEPTH_COMPONENT16;
		
		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
		glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
		glTexImage2D(GL_TEXTURE_2D, 0, texFormat, shadowMapSize, shadowMapSize, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
	}

	glGenTextures(1, &dummyColorTexture);
	if (globalRendering->atiHacks) {
		// ATI shadows fail without an attached color texture
		glBindTexture(GL_TEXTURE_2D, dummyColorTexture);
		// this dummy should be as small as possible not to waste memory
		glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA4, shadowMapSize, shadowMapSize, 0, GL_ALPHA, GL_UNSIGNED_BYTE, NULL);
	}

	glBindTexture(GL_TEXTURE_2D, 0);
	fb.Bind();

	if (useColorTexture) {
		fb.AttachTexture(shadowTexture);
	} else {
		if (globalRendering->atiHacks)
			fb.AttachTexture(dummyColorTexture);
		fb.AttachTexture(shadowTexture, GL_TEXTURE_2D, GL_DEPTH_ATTACHMENT_EXT);
	}

	const int buffer = (useColorTexture || globalRendering->atiHacks) ? GL_COLOR_ATTACHMENT0_EXT : GL_NONE;
	glDrawBuffer(buffer);
	glReadBuffer(buffer);
	const bool status = fb.CheckStatus("SHADOW");
	fb.Unbind();
	return status;
}
示例#25
0
void ATexture2D::bindTexture()
{
    QImage timage,buf;
    if(!buf.load(m_fileName))
    {
        qWarning("Could not read image file,using single-color instead");
        QImage dummy(128,128,QImage::Format_RGB32);
        buf = dummy;
    }

    timage = QGLWidget::convertToGLFormat(buf);
    m_width = timage.width();
    m_height = timage.height();

    glGenTextures(1, &m_texID);
    //qDebug()<<"m_texID="<<m_texID;
    glBindTexture(GL_TEXTURE_2D, m_texID);
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,timage.width(),timage.height(),0,
            GL_RGBA,GL_UNSIGNED_BYTE,timage.bits());
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

#ifdef GL_ES
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER_NV);
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER_NV);
#elseif
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
#endif
    float color[4] = { 1.0f, 1.0f, 1.0f, 0.0f };
#ifdef GL_ES
    glTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR_NV, color);
#elseif
    glTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, color);
#endif

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);

    //delete(&timage);
    //delete(&buf);
}
EVA::Light::Light(const Type type, const bool shadows, const unsigned int shadowSize)
{
	m_Type = type;
	m_Shadows = shadows;
	m_ShadowMapSize = shadowSize;

	if(!shadows)
		return;;

	if(m_Type == Directional)
	{
		glGenTextures(1, &m_DepthMap);
		glBindTexture(GL_TEXTURE_2D, m_DepthMap);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
			m_ShadowMapSize, m_ShadowMapSize, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

		float borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
		glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);

		glGenFramebuffers(1, &m_DepthMapFb);
		glBindFramebuffer(GL_FRAMEBUFFER, m_DepthMapFb);
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_DepthMap, 0);
		glDrawBuffer(GL_NONE);
		glReadBuffer(GL_NONE);
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}
	else
	{
		glGenTextures(1, &m_DepthMap);
		glBindTexture(GL_TEXTURE_CUBE_MAP, m_DepthMap);

		for (unsigned int i = 0; i < 6; ++i)
			glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_DEPTH_COMPONENT,
				m_ShadowMapSize, m_ShadowMapSize, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);

		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		
		glGenFramebuffers(1, &m_DepthMapFb);
		glBindFramebuffer(GL_FRAMEBUFFER, m_DepthMapFb);
		glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0);
		glDrawBuffer(GL_NONE);
		glReadBuffer(GL_NONE);
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}
}
示例#27
0
void Texture::Parameter::apply() const
{
	for (const auto &pr : m_pari)
	{
		glTexParameteri(GL_TEXTURE_2D, pr.first, pr.second);
	}
	for (const auto &pr : m_parfv)
	{
		glTexParameterfv(GL_TEXTURE_2D, pr.first, pr.second);
	}
}
示例#28
0
static void
_cg_texture_driver_try_setting_gl_border_color(cg_device_t *dev,
                                               GLuint gl_target,
                                               const GLfloat *transparent_color)
{
    /* Use a transparent border color so that we can leave the
       color buffer alone when using texture co-ordinates
       outside of the texture */
    GE(dev,
       glTexParameterfv(gl_target, GL_TEXTURE_BORDER_COLOR, transparent_color));
}
示例#29
0
static void clear(GLuint t)
{
    static const GLfloat p[] = { 0, 0, 0, 0 };
        
    glBindTexture  (GL_TEXTURE_2D, t);
    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);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, p);
    glTexImage2D   (GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_FLOAT, p);
}
示例#30
0
	//----------------------------------------------------
	// Set kardane keyfiyat texture ha va address mode ha.
	//----------------------------------------------------
	void RendererGL::SetTextureParams(TextureParams Params, int TextureStage)
	{
		glActiveTexture(GL_TEXTURE0 + TextureStage);

		switch (Params)
		{
		//*** F I L T E R I N G S
		case gfx::ETP_Point:
			glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_NEAREST );
			glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_NEAREST );
			break;

		case gfx::ETP_Linear:
			glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR );
			glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR );
			break;

		case gfx::ETP_Anisotropic:
			//check for hardware support
			if (!strstr((char*)glGetString(GL_EXTENSIONS),"GL_EXT_texture_filter_anisotropic"))
			{
				//get max ANISOTROPY and set it
				float maximumAnistropy;
				glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maximumAnistropy);
				glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, maximumAnistropy);
			}
			break;

		//*** A D D R E S S I N G
		case gfx::ETP_Wrap:
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
			break;

		case gfx::ETP_BorderColor:
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER_ARB);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER_ARB);
			glTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, 0x00000000 );
			break;

		case gfx::ETP_Clamp:
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
			break;

		case gfx::ETP_Mirror:
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT_ARB);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT_ARB);
			break;
		}

	} // SetTextureFilters