Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner.
765329
def setOverlayTextureBounds(self, ulOverlayHandle):
        """"""

        fn = self.function_table.setOverlayTextureBounds
        pOverlayTextureBounds = VRTextureBounds_t()
        result = fn(ulOverlayHandle, byref(pOverlayTextureBounds))
        return result, pOverlayTextureBounds
1092213
public static JCGLTextureFilterMinification textureFilterMinFromGL(
    final int min_filter)
  {
    switch (min_filter) {
      case GL.GL_LINEAR:
        return JCGLTextureFilterMinification.TEXTURE_FILTER_LINEAR;
      case GL.GL_NEAREST:
        return JCGLTextureFilterMinification.TEXTURE_FILTER_NEAREST;
      case GL.GL_LINEAR_MIPMAP_LINEAR:
        return JCGLTextureFilterMinification
          .TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR;
      case GL.GL_LINEAR_MIPMAP_NEAREST:
        return JCGLTextureFilterMinification
          .TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST;
      case GL.GL_NEAREST_MIPMAP_LINEAR:
        return JCGLTextureFilterMinification
          .TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR;
      case GL.GL_NEAREST_MIPMAP_NEAREST:
        return JCGLTextureFilterMinification
          .TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST;
      default:
        throw new UnreachableCodeException();
    }
  }
386527
def texture_floodfill(x, y, texture)
      target = pixel_color(x, y)
      texture_flood_fill(target, texture, x, y, FloodfillMethod)
    end
924448
function(repeat) {
        if (!this.isActive())
            throw "Trying to set repeat property of texture that isn't active";
        if (repeat && !this.powerOfTwo) {
            throw "Can't create a repeating image whose dimensions aren't a power of 2 in WebGL contexts";
        }
        var gl = this.gl;
        this.repeatMode = repeat ? gl.REPEAT : gl.CLAMP_TO_EDGE;
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this.repeatMode);
        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this.repeatMode);
    }
818888
public static JCGLTextureFilterMinification textureFilterMinFromGL(
    final int min_filter)
  {
    switch (min_filter) {
      case GL11.GL_LINEAR:
        return JCGLTextureFilterMinification.TEXTURE_FILTER_LINEAR;
      case GL11.GL_NEAREST:
        return JCGLTextureFilterMinification.TEXTURE_FILTER_NEAREST;
      case GL11.GL_LINEAR_MIPMAP_LINEAR:
        return JCGLTextureFilterMinification
          .TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR;
      case GL11.GL_LINEAR_MIPMAP_NEAREST:
        return JCGLTextureFilterMinification
          .TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST;
      case GL11.GL_NEAREST_MIPMAP_LINEAR:
        return JCGLTextureFilterMinification
          .TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR;
      case GL11.GL_NEAREST_MIPMAP_NEAREST:
        return JCGLTextureFilterMinification
          .TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST;
      default:
        throw new UnreachableCodeException();
    }
  }
149095
function ( geometry ) {

		var uvSet = geometry.faceVertexUvs[ 0 ];

		for ( var i = 0, il = uvSet.length; i < il; i ++ ) {

			var uvs = uvSet[ i ];

			for ( var j = 0, jl = uvs.length; j < jl; j ++ ) {

				// texture repeat

				if( uvs[ j ].u !== 1.0 ) uvs[ j ].u = uvs[ j ].u - Math.floor( uvs[ j ].u );
				if( uvs[ j ].v !== 1.0 ) uvs[ j ].v = uvs[ j ].v - Math.floor( uvs[ j ].v );

			}

		}

	}
276012
def set_border(self, thickness, color="black"):
        
        self._set_tk_config("highlightthickness", thickness)
        self._set_tk_config("highlightbackground", utils.convert_color(color))
1364778
public void setFirstOccurence(int min, int max) throws ParseException {
    if (fullCondition == null) {
      if ((min < 0) || (min > max) || (max < 1)) {
        throw new ParseException("Illegal number {" + min + "," + max + "}");
      }
      if (min == 0) {
        firstOptional = true;
      }
      firstMinimumOccurence = Math.max(1, min);
      firstMaximumOccurence = max;
    } else {
      throw new ParseException("fullCondition already generated");
    }
  }
1366570
function() {
		var gl = this.gl;

		var fragmentShaderSource = [
			"precision mediump float;",
			"uniform sampler2D bgTexture;",
			"uniform sampler2D spriteTexture;",
			"uniform sampler2D prioTexture;",
			"uniform sampler2D paletteTexture;",
			"uniform vec4 bgColor;",
			"varying vec2 texCoord;",

			"void main(void) {",
				"float bgIndex = texture2D(bgTexture, texCoord).r;",
				"float spriteIndex = texture2D(spriteTexture, texCoord).r;",
				"float prioIndex = texture2D(prioTexture, texCoord).r;",
				"float colorIndex = ((spriteIndex > 0.0 && (prioIndex == 0.0 || bgIndex == 0.0)) ? spriteIndex : bgIndex);",
				"vec4 color = texture2D(paletteTexture, vec2( colorIndex * 4.0 + 0.0078, 0.5));", // 0.0078 == ( 0.5 * 3 / 192 ) === ( 0.5 * [RGB colors] / [palette width] )
				"if ( colorIndex > 0.0 ) {",
					"gl_FragColor = color;",
				"} else {",
					"gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);",
					"gl_FragColor = bgColor;",
				"}",
			"}"
		].join("\n");

		var vertexShaderSource = [
			"attribute vec2 vertCoord;",
			"varying vec2 texCoord;",

			"void main() {",
				"gl_Position = vec4(vertCoord, 0, 1);",
				"texCoord = vec2( 0.5 * ( vertCoord.x + 1.0 ), 0.5 * (1.0 - vertCoord.y));",
			"}"
		].join("");

		this.fragmentShader = compileShader( gl.FRAGMENT_SHADER, fragmentShaderSource );
		this.vertexShader = compileShader( gl.VERTEX_SHADER, vertexShaderSource );

		function compileShader( shaderType, shaderSource ) {
			var shader = gl.createShader( shaderType );
			gl.shaderSource( shader, shaderSource );
			gl.compileShader( shader );

			if ( !gl.getShaderParameter( shader, gl.COMPILE_STATUS ) ) {  
				throw ( "An error occurred compiling the shaders: " + gl.getShaderInfoLog( shader ) );
			}

			return shader;
		}
	}
424552
private void overrideMinMaxForXAxis() {

    double overrideXAxisMinValue = xAxis.getMin();
    double overrideXAxisMaxValue = xAxis.getMax();
    // override min and maxValue if specified
    if (chart.getStyler().getXAxisMin() != null) {

      overrideXAxisMinValue = chart.getStyler().getXAxisMin();
    }
    if (chart.getStyler().getXAxisMax() != null) {

      overrideXAxisMaxValue = chart.getStyler().getXAxisMax();
    }
    xAxis.setMin(overrideXAxisMinValue);
    xAxis.setMax(overrideXAxisMaxValue);
  }
1033645
public void setAlpha (float alpha)
    {
        if (alpha < 0.0f) {
            alpha = 0.0f;

        } else if (alpha > 1.0f) {
            alpha = 1.0f;
        }
        if (alpha != _alphaComposite.getAlpha()) {
            _alphaComposite = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);
            if (_mgr != null) {
                _mgr.getRegionManager().invalidateRegion(_bounds);
            }
        }
    }
1234578
function setValueT1( gl, v, renderer ) {

	var cache = this.cache;
	var unit = renderer.allocTextureUnit();

	if ( cache[ 0 ] !== unit ) {

		gl.uniform1i( this.addr, unit );
		cache[ 0 ] = unit;

	}

	renderer.setTexture2D( v || emptyTexture, unit );

}
1128776
@Api
	public void setTargetMaxExtentRectangleStyle(ShapeStyle targetMaxExtentRectangleStyle) {
		this.targetMaxExtentRectangleStyle = targetMaxExtentRectangleStyle;
		if (targetMaxExtentRectangle != null) {
			targetMaxExtentRectangle.setStyle(targetMaxExtentRectangleStyle);
			if (drawTargetMaxExtent) {
				render(targetMaxExtentRectangle, RenderGroup.SCREEN, RenderStatus.UPDATE);
			}
		}
	}
1237639
function setupRenderTarget( renderTarget ) {

		var renderTargetProperties = properties.get( renderTarget );
		var textureProperties = properties.get( renderTarget.texture );

		renderTarget.addEventListener( 'dispose', onRenderTargetDispose );

		textureProperties.__webglTexture = _gl.createTexture();

		info.memory.textures ++;

		var isCube = ( renderTarget.isWebGLRenderTargetCube === true );
		var isTargetPowerOfTwo = isPowerOfTwo( renderTarget );

		// Setup framebuffer

		if ( isCube ) {

			renderTargetProperties.__webglFramebuffer = [];

			for ( var i = 0; i < 6; i ++ ) {

				renderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();

			}

		} else {

			renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();

		}

		// Setup color buffer

		if ( isCube ) {

			state.bindTexture( 34067, textureProperties.__webglTexture );
			setTextureParameters( 34067, renderTarget.texture, isTargetPowerOfTwo );

			for ( var i = 0; i < 6; i ++ ) {

				setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, 36064, 34069 + i );

			}

			if ( textureNeedsGenerateMipmaps( renderTarget.texture, isTargetPowerOfTwo ) ) {

				generateMipmap( 34067, renderTarget.texture, renderTarget.width, renderTarget.height );

			}

			state.bindTexture( 34067, null );

		} else {

			state.bindTexture( 3553, textureProperties.__webglTexture );
			setTextureParameters( 3553, renderTarget.texture, isTargetPowerOfTwo );
			setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, 36064, 3553 );

			if ( textureNeedsGenerateMipmaps( renderTarget.texture, isTargetPowerOfTwo ) ) {

				generateMipmap( 3553, renderTarget.texture, renderTarget.width, renderTarget.height );

			}

			state.bindTexture( 3553, null );

		}

		// Setup depth and stencil buffers

		if ( renderTarget.depthBuffer ) {

			setupDepthRenderbuffer( renderTarget );

		}

	}
196332
public static void boundImage( GrayS64 img , long min , long max ) {
		ImplPixelMath.boundImage(img,min,max);
	}
531987
public void bindTexture(GuiTexture texture)
	{
		//no change needed
		if (texture == currentTexture)
			return;

		next();
		Minecraft.getMinecraft().getTextureManager().bindTexture(texture.getResourceLocation());
		//System.out.println(currentComponent + " // Bound " + texture.getResourceLocation());

		currentTexture = texture;
	}
103116
public void setTextureColor(final Color TEXTURE_COLOR) {
        model.setTextureColor(TEXTURE_COLOR);
        BACKGROUND_FACTORY.recreatePunchedSheetTexture(TEXTURE_COLOR);
        reInitialize();
    }