Uniforms (refresh uniforms objects)
177092
function refreshUniformsCommon ( uniforms, material ) {

		uniforms.opacity.value = material.opacity;

		if ( _this.gammaInput ) {

			uniforms.diffuse.value.copyGammaToLinear( material.color );

		} else {

			uniforms.diffuse.value = material.color;

		}

		uniforms.map.texture = material.map;

		if ( material.map ) {

			uniforms.offsetRepeat.value.set( material.map.offset.x, material.map.offset.y, material.map.repeat.x, material.map.repeat.y );

		}

		uniforms.lightMap.texture = material.lightMap;

		uniforms.envMap.texture = material.envMap;
		uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : -1;

		if ( _this.gammaInput ) {

			//uniforms.reflectivity.value = material.reflectivity * material.reflectivity;
			uniforms.reflectivity.value = material.reflectivity;

		} else {

			uniforms.reflectivity.value = material.reflectivity;

		}

		uniforms.refractionRatio.value = material.refractionRatio;
		uniforms.combine.value = material.combine;
		uniforms.useRefract.value = material.envMap && material.envMap.mapping instanceof THREE.CubeRefractionMapping;

	}
238600
function(){
			var rect, obj, i;
            for (i=0, l=changed_objs.length; i<l; i++){
            	obj = changed_objs[i];
            	rect = obj._mbr || obj;
            	if (obj.staleRect == null)
            			obj.staleRect = {}
        		obj.staleRect._x = rect._x;
				obj.staleRect._y = rect._y;
				obj.staleRect._w = rect._w;
				obj.staleRect._h = rect._h;

				obj._changed = false
            }
            changed_objs.length = 0;
            dirty_rects.length = 0

		}
22347
public void refreshBitmapShader()
	{
		shader = new BitmapShader(Bitmap.createScaledBitmap(image, canvasSize, canvasSize, false), Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
	}
529580
function(force)
	{
		if(this._collectionBinder)
		{
			this._collectionBinder.refreshBinders(force);
		}
		else
		{
			this._refreshOwnBinders(force);
			if(this.subviews !== null)
			{
				for(var i = 0, l = this.subviews.length; i < l; i++) this.subviews[i].refreshBinders(force);
			}
		}
	}
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
286498
function reset() {
         this.sbIndex = 0;
         this.length = 0;
         var samplers = []; // WebGL context

         this.gl = this.renderer.gl;

         for (var i = 0; i < this.maxTextures; i++) {
           this.units[i] = false;
           samplers[i] = i;
         } // set the quad shader as the default program


         this.useShader(this.quadShader);
         this.quadShader.uniforms.uSampler = samplers;
       }
507852
def refresh(self):
        
        j = self.vera_request(id='sdata', output_format='json').json()
        scenes = j.get('scenes')
        for scene_data in scenes:
            if scene_data.get('id') == self.scene_id:
                self.update(scene_data)
484886
private void refresh() {
        if (!refreshCheckStart()) {
            return;
        }
        final TileStates tileStates = mTilesOverlay.getTileStates();
        do {
            mTilesOverlay.drawTiles(null, mProjection, mProjection.getZoomLevel(), mViewPort);
            boolean ready = true;
            if (mIncludeFlags != 0 && mIncludeFlags != INCLUDE_FLAGS_ALL) {
                if (ready && (mIncludeFlags & INCLUDE_FLAG_UPTODATE) == 0 && tileStates.getUpToDate() != 0) {
                    ready = false;
                }
                if (ready && (mIncludeFlags & INCLUDE_FLAG_EXPIRED) == 0 && tileStates.getExpired() != 0) {
                    ready = false;
                }
                if (ready && (mIncludeFlags & INCLUDE_FLAG_SCALED) == 0 && tileStates.getScaled() != 0) {
                    ready = false;
                }
                if (ready && (mIncludeFlags & INCLUDE_FLAG_NOTFOUND) == 0 && tileStates.getNotFound() != 0) {
                    ready = false;
                }
            }
            if (ready) {
                if (mStatus == Status.CANVAS_OK || mStatus == Status.PAINTING) {
                    return;
                }
                if (!refreshCheckFinish()) {
                    return;
                }
                mStatus = Status.PAINTING;
                if (mIsDetached) {
                    return;
                }
                draw();
                mStatus = Status.CANVAS_OK;
                final MapSnapshotable mapSnapshotable = mMapSnapshotable;
                if (mapSnapshotable != null) {
                    mapSnapshotable.callback(MapSnapshot.this);
                }
            }
        } while(refreshCheckEnd());
    }
568633
def refresh(self):
        
        for cbar in self.colorbars:
            cbar.draw_all()
        self.canvas.draw()
315795
def refresh(self):
        
        self._clear()
        for img in self.composed_images:
            self._background_image.paste(img.image(self._device.size),
                                         img.position)
        self._background_image.crop(box=self._device.bounding_box)
600473
def refresh(self):
        
        if not self._client:
            return
        current_images = self._client.images()
        self.clear()
        self._update(current_images)
        for image in current_images:
            tags = image.get('RepoTags')
            if tags:
                self.update({tag: image['Id'] for tag in tags})
1129456
def refresh(cls):
        
        # clear the old values in _flag_map
        try:
            del cls._flag_map["t"]
        except KeyError:
            pass

        try:
            del cls._flag_map["-"]
        except KeyError:
            pass

        # set the value given the git version
        if Git().version_info[:2] >= (2, 10):
            cls._flag_map["t"] = cls.TAG_UPDATE
        else:
            cls._flag_map["-"] = cls.TAG_UPDATE

        return True
427168
def __refresh(self):
        """"""
        raw_values = self.__get_values()
        if not raw_values:
            raise RefreshException('Point has no values')

        # individual templates
        templates = []
        # lookup tables by type and unit of value
        by_type = {}
        by_unit = {}

        for raw_value in raw_values:
            label = raw_value['label']
            if not valid_identifier(label) or label.startswith('__'):
                raise RefreshException('Value "%s" unsuitable for object wrapper' % label)
            value = Value(label, raw_value['type'], raw_value['unit'], raw_value['comment'])
            templates.append(value)
            try:
                by_type[value.type_].add(label)
            except KeyError:
                by_type[value.type_] = {label}
            if value.unit:
                try:
                    by_unit[value.unit].add(label)
                except KeyError:
                    by_unit[value.unit] = {label}

        self.__value_templates = templates
        self.__filter = _ValueFilter(by_type, by_unit)
243287
function markUniformsLightsNeedsUpdate ( uniforms, boolean ) {

		uniforms.ambientLightColor.needsUpdate = boolean;

		uniforms.directionalLightColor.needsUpdate = boolean;
		uniforms.directionalLightDirection.needsUpdate = boolean;

		uniforms.pointLightColor.needsUpdate = boolean;
		uniforms.pointLightPosition.needsUpdate = boolean;
		uniforms.pointLightDistance.needsUpdate = boolean;

		uniforms.spotLightColor.needsUpdate = boolean;
		uniforms.spotLightPosition.needsUpdate = boolean;
		uniforms.spotLightDistance.needsUpdate = boolean;
		uniforms.spotLightDirection.needsUpdate = boolean;
		uniforms.spotLightAngleCos.needsUpdate = boolean;
		uniforms.spotLightExponent.needsUpdate = boolean;

		uniforms.hemisphereLightSkyColor.needsUpdate = boolean;
		uniforms.hemisphereLightGroundColor.needsUpdate = boolean;
		uniforms.hemisphereLightDirection.needsUpdate = boolean;

	}
332907
private synchronized void refresh() {
    pendingRefresh.set(null); // Clear
    if(LOG.isDebuggingFine()) {
      LOG.debugFine("Refresh in thread " + Thread.currentThread().getName());
    }
    boolean updateStyle = false;
    Iterator<Entry<VisualizationTask, Visualization>> it = taskmap.entrySet().stream() //
        .sorted((a, b) -> Integer.compare(a.getKey().level(), b.getKey().level())) //
        .iterator();
    Element insertpos = null;
    while(it.hasNext()) {
      Entry<VisualizationTask, Visualization> ent = it.next();
      VisualizationTask task = ent.getKey();
      Visualization vis = ent.getValue();
      if(!task.isVisible()) {
        if(vis != null) {
          SVGUtil.removeFromParent(vis.getLayer());
        }
        continue;
      }
      if(vis == null) {
        ent.setValue(vis = instantiateVisualization(task));
      }
      Element layer = vis.getLayer();
      if(task.has(RenderFlag.NO_EXPORT)) {
        layer.setAttribute(NO_EXPORT_ATTRIBUTE, NO_EXPORT_ATTRIBUTE);
      }
      // Insert or append
      if(layer.getParentNode() != getRoot()) {
        if(insertpos != null && insertpos.getNextSibling() != null) {
          getRoot().insertBefore(layer, insertpos.getNextSibling());
        }
        else {
          getRoot().appendChild(layer);
        }
      }
      updateStyle = true;
      insertpos = layer;
    }
    if(updateStyle) {
      updateStyleElement();
    }
  }
920593
def set_uniform(self, name, type_, value):
        
        if not self._linked:
            raise RuntimeError('Cannot set uniform when program has no code')
        # Get handle for the uniform, first try cache
        handle = self._handles.get(name, -1)
        count = 1
        if handle < 0:
            if name in self._known_invalid:
                return
            handle = gl.glGetUniformLocation(self._handle, name)
            self._unset_variables.discard(name)  # Mark as set
            # if we set a uniform_array, mark all as set
            if not type_.startswith('mat'):
                count = value.nbytes // (4 * self.ATYPEINFO[type_][0])
            if count > 1:
                for ii in range(count):
                    if '%s[%s]' % (name, ii) in self._unset_variables:
                        self._unset_variables.discard('%s[%s]' % (name, ii))

            self._handles[name] = handle  # Store in cache
            if handle < 0:
                self._known_invalid.add(name)
                logger.info('Variable %s is not an active uniform' % name)
                return
        # Look up function to call
        funcname = self.UTYPEMAP[type_]
        func = getattr(gl, funcname)
        # Program needs to be active in order to set uniforms
        self.activate()
        # Triage depending on type
        if type_.startswith('mat'):
            # Value is matrix, these gl funcs have alternative signature
            transpose = False  # OpenGL ES 2.0 does not support transpose
            func(handle, 1, transpose, value)
        else:
            # Regular uniform
            func(handle, count, value)
619592
function()
	{
		if(this._collectionBinder)
		{
			this._collectionBinder.refreshIndexedBinders();
		}
		else
		{
			if(this._modelBindersMap)
			{
				this._modelBindersMap.refreshIndexedBinders();
			}
			if(this.subviews !== null)
			{
				for(var i = 0, l = this.subviews.length; i < l; i++) this.subviews[i].refreshIndexedBinders();
			}
		}
	}