Update the texture parameters {@link GVRTextureParameters} after the
texture has been created.
975366
public void updateTextureParameters(GVRTextureParameters textureParameters)
    {
        mTextureParams = textureParameters;
        long nativePtr = getNative();
        if (nativePtr != 0)
        {
            NativeTexture.updateTextureParameters(nativePtr, textureParameters.getCurrentValuesArray());
        }
    }
221710
public final void loadTexture() {
        texture = null;
        texture = AWTTextureIO.newTexture(GLProfile.get(GLProfile.GL2), img, true);
        if (texture == null) {
            throw new CasmiRuntimeException("Cannot load texture");
        }
    }
1047364
public void bind() {
        program.use();
        if (textures != null) {
            final TIntObjectIterator<Texture> iterator = textures.iterator();
            while (iterator.hasNext()) {
                iterator.advance();
                // Bind the texture to the unit
                final int unit = iterator.key();
                iterator.value().bind(unit);
                // Bind the shader sampler uniform to the unit
                program.bindSampler(unit);
            }
        }
    }
569801
@Override
    public void update(double extrp, int x, int y, double speed)
    {
        data.setOffsetY(y);

        for (int i = 0; i < cloudsNumber; i++)
        {
            this.x[i] += this.speed[i] * extrp;
            this.x[i] = UtilMath.wrapDouble(this.x[i], 0.0, sprite.getWidth());
        }
    }
506667
private function updateParametersInfo(): void
  {
    if (!empty($this->extendedParameters))
    {
      foreach ($this->extendedParameters as $spec_param_name => $spec_param_info)
      {
        $param_not_exist = true;
        foreach ($this->parameters as $key => $param_info)
        {
          if ($param_info['parameter_name']==$spec_param_name)
          {
            $this->parameters[$key] = array_merge($this->parameters[$key], $spec_param_info);
            $param_not_exist        = false;
            break;
          }
        }
        if ($param_not_exist)
        {
          throw new RoutineLoaderException("Specific parameter '%s' does not exist", $spec_param_name);
        }
      }
    }
  }
934937
public void update() {
        if (polygon != null) {
            if (isDeleted()) {
                remove();
            } else {

                List<LatLng> points = converter.getPointsFromMarkers(markers);
                polygon.setPoints(points);

                List<List<LatLng>> holePointList = new ArrayList<List<LatLng>>();
                for (PolygonHoleMarkers hole : holes) {
                    if (!hole.isDeleted()) {
                        List<LatLng> holePoints = converter
                                .getPointsFromMarkers(hole.getMarkers());
                        holePointList.add(holePoints);
                    }
                }
                polygon.setHoles(holePointList);
            }
        }
    }
454912
@Override
	protected void updateValuesFromHSVFields () {
		int[] hsv = ColorUtils.RGBtoHSV(color);
		int h = hsv[0];
		int s = hsv[1];
		int v = hsv[2];

		if (hBar.isInputValid()) h = hBar.getValue();
		if (sBar.isInputValid()) s = sBar.getValue();
		if (vBar.isInputValid()) v = vBar.getValue();

		color = ColorUtils.HSVtoRGB(h, s, v, color.a);

		int cr = MathUtils.round(color.r * 255.0f);
		int cg = MathUtils.round(color.g * 255.0f);
		int cb = MathUtils.round(color.b * 255.0f);

		rBar.setValue(cr);
		gBar.setValue(cg);
		bBar.setValue(cb);
	}
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 );

}
200726
function (src, data, cb) {
    var texture;
    texture = new THREE.CanvasTexture(src);
    setTextureProperties(texture, data);
    cb(texture);
  }
200188
def _update(self):
        

        if self._vertices_buffer is not None:
            self._vertices_buffer.delete()
        self._vertices_buffer = VertexBuffer(self._vertices_list.data)

        if self.itype is not None:
            if self._indices_buffer is not None:
                self._indices_buffer.delete()
            self._indices_buffer = IndexBuffer(self._indices_list.data)

        if self.utype is not None:
            if self._uniforms_texture is not None:
                self._uniforms_texture.delete()

            # We take the whole array (_data), not the data one
            texture = self._uniforms_list._data.view(np.float32)
            size = len(texture) / self._uniforms_float_count
            shape = self._compute_texture_shape(size)

            # shape[2] = float count is only used in vertex shader code
            texture = texture.reshape(shape[0], shape[1], 4)
            self._uniforms_texture = Texture2D(texture)
            self._uniforms_texture.data = texture
            self._uniforms_texture.interpolation = 'nearest'

        if len(self._programs):
            for program in self._programs:
                program.bind(self._vertices_buffer)
                if self._uniforms_list is not None:
                    program["uniforms"] = self._uniforms_texture
                    program["uniforms_shape"] = self._ushape
222491
@Override
	public void updateContext() {

		String newValue = replaceVariables( this.value, this.context, this.instancePath );
		if( newValue != null ) {
			this.context.variables.put( this.key, newValue );
		}

		// When not resolved, we disable it.
		// We also replace it by a mock value so that we can perform
		// validation. It implies populating the context.
		else {
			setDisabled( true );
			this.context.disabledVariables.add( this.key );
			this.context.variables.put( this.key, "fake" );
			String path = "/fake";
			if( this.instancePath != null )
				path = this.instancePath + path;

			this.context.instancePathToComponentName.put( path, FAKE_COMPONENT_NAME );
		}
	}
231129
function getTextureFromData(gl, data, opts) {
  if (data instanceof Texture2D) {
    return data;
  }
  return new Texture2D(gl, Object.assign({data}, opts));
}
217034
protected final void update() {
		BufferedImage image=getImageViewer()==null ? null : getImageViewer().getImage();
		if (image==null || model.isInvalid() || model.getX()>=image.getWidth() || model.getY()>=image.getHeight())
			updateLabelNoData();
		else
			updateLabel(image, model.getX(), model.getY(), statusBar.getWidth()-statusBarInsets.left-statusBarInsets.right);
	}
1181611
public void setTexture(String key, GVRTexture texture)
    {
        checkStringNotNullOrEmpty("key", key);
        synchronized (textures)
        {
            textures.put(key, texture);
            NativeShaderData.setTexture(getNative(), key, texture != null ? texture.getNative() : 0);
        }
    }
937319
protected void updateValuesFromCurrentColor () {
		int[] hsv = ColorUtils.RGBtoHSV(color);
		int ch = hsv[0];
		int cs = hsv[1];
		int cv = hsv[2];

		verticalBar.setValue(ch);
		palette.setValue(cs, cv);
	}
669787
function (oldData) {
    var data = this.data;
    if (!this.shader || data.shader !== oldData.shader) {
      this.updateShader(data.shader);
    }
    this.shader.update(this.data);
    this.updateMaterial(oldData);
  }
998363
@Inject(method = "loadTextureAtlas", at = @At("RETURN"), locals = LocalCapture.CAPTURE_FAILSOFT)
	private void onLoadTextureAtlas(IResourceManager resourceManager, CallbackInfo ci, int i, Stitcher stitcher, int j, int k, ProgressManager.ProgressBar bar)
	{
		Icon.BLOCK_TEXTURE_WIDTH = stitcher.getCurrentWidth();
		Icon.BLOCK_TEXTURE_HEIGHT = stitcher.getCurrentHeight();
	}