If the burst mode is on, emit the particles only once.

@param particlePositions
@param particleVelocities
@param particleTimeStamps
960555
protected  void emitWithBurstCheck(float[] particlePositions, float[] particleVelocities,
                         float[] particleTimeStamps)
    {
        if ( burstMode )
        {
            if ( executeOnce )
            {
                emit(particlePositions, particleVelocities, particleTimeStamps);
                executeOnce = false;
            }
        }
        else
        {
            emit(particlePositions, particleVelocities, particleTimeStamps);
        }

    }
513738
function JssorSliderPositionChangeEventHandler(position, fromPosition, virtualPosition, virtualFromPosition) {
    //fires continuously while carousel sliding
    //position: current position of the carousel
    //fromPosition: previous position of the carousel
    //virtualPosition: current virtual position of the carousel
    //virtualFromPosition: previous virtual position of the carousel

    var args = [position, fromPosition, virtualPosition, virtualFromPosition];
    console.log(" args: " + args.join(","));
}
492733
private void updateRender() {
		if (inherit.isSelected())
		{
			emitter.usePoints = Particle.INHERIT_POINTS;
			oriented.setEnabled( true );
		}
		if (quads.isSelected())
		{
			emitter.usePoints = Particle.USE_QUADS;
			oriented.setEnabled( true );
		}
		if (points.isSelected())
		{
			emitter.usePoints = Particle.USE_POINTS;
			oriented.setEnabled( false );
			oriented.setSelected( false );
		}
		
		// oriented
		if( oriented.isSelected())
			emitter.useOriented= true;
		else
			emitter.useOriented= false;
		
		// additive blending
		if( additive.isSelected())
			emitter.useAdditive= true;
		else
			emitter.useAdditive= false;
	}
672031
public void addEvents(Matrix events) {
		int seriesCount = getSeriesCount();
		for (int r = 0; r < events.getRowCount(); r++) {
			long timestamp = events.getAsLong(r, 0);
			for (int c = 1; c < events.getColumnCount(); c++) {
				double value = events.getAsDouble(r, c);
				addEvent(timestamp, seriesCount + c - 1, value);
			}
		}
	}
530899
public void setPayloads(java.util.Collection<java.nio.ByteBuffer> payloads) {
        if (payloads == null) {
            this.payloads = null;
            return;
        }

        this.payloads = new java.util.ArrayList<java.nio.ByteBuffer>(payloads);
    }
1350393
public void setDeviceEvents(java.util.Collection<DeviceEvent> deviceEvents) {
        if (deviceEvents == null) {
            this.deviceEvents = null;
            return;
        }

        this.deviceEvents = new java.util.ArrayList<DeviceEvent>(deviceEvents);
    }
622959
public void setVelocityPropertiesMap(Map<String, Object> velocityPropertiesMap) {
		if (velocityPropertiesMap != null) {
			this.velocityProperties.putAll(velocityPropertiesMap);
		}
	}
206098
function (positions) {
                var _this = this;
                this._points = positions;
                positions.forEach(function (position) {
                    _this.positionChange(position);
                });
                this.repositionEvent.next(positions);
            }
333458
public void pushMessages(List<byte[]> messages) {
    for (byte[] message: messages) {
      this.futures.offer(producer.send(new ProducerRecord<>(topic, message), (recordMetadata, e) -> {
        if (e != null) {
          log.error("Failed to send message to topic {} due to exception: ", topic, e);
        }
      }));
    }

    //Once the low watermark of numFuturesToBuffer is hit, start flushing messages from the futures
    // buffer. In order to avoid blocking on newest messages added to futures queue, we only invoke future.get() on
    // the oldest messages in the futures buffer. The number of messages to flush is same as the number of messages added
    // in the current call. Note this does not completely avoid calling future.get() on the newer messages e.g. when
    // multiple threads enter the if{} block concurrently, and invoke flush().
    if (this.futures.size() >= this.numFuturesToBuffer) {
      flush(messages.size());
    }
  }
1245847
private float[] generateParticleVelocities()
    {
        float [] particleVelocities = new float[mEmitRate * 3];
        Vector3f temp = new Vector3f(0,0,0);
        for ( int i = 0; i < mEmitRate * 3 ; i +=3 )
        {
            temp.x = mParticlePositions[i];
            temp.y = mParticlePositions[i+1];
            temp.z = mParticlePositions[i+2];


            float velx = mRandom.nextFloat() * (maxVelocity.x- minVelocity.x)
                    + minVelocity.x;

            float vely = mRandom.nextFloat() * (maxVelocity.y - minVelocity.y)
                                + minVelocity.y;
            float velz = mRandom.nextFloat() * (maxVelocity.z - minVelocity.z)
                    + minVelocity.z;

            temp = temp.normalize();
            temp.mul(velx, vely, velz, temp);

            particleVelocities[i] = temp.x;
            particleVelocities[i+1] = temp.y;
            particleVelocities[i+2] = temp.z;
        }

        return particleVelocities;

    }
710790
function on () {
    for ( var i = PARTICLE_COUNT; i--; ) {
      particle = new THREE.Particle( newParticleMat() );
      particle.position.x = Math.random() * 2000 - 1000;
      particle.position.y = Math.random() * 2000 - 1000;
      particle.position.z = Math.random() * 2000 - 1000;
      particle.scale.x = particle.scale.y = Math.random() * 10 + 5;
      group.add( particle );
    }
    scene.add( group );

    // Beam idea from http://www.airtightinteractive.com/demos/js/nebula/
    var
      beamGeometry = new THREE.PlaneGeometry( 5000, 50, 1, 1 ),
      beamMaterial, beam;

    for ( i = BEAM_COUNT; i--; ) {
      beamMaterial = new THREE.MeshBasicMaterial({
        opacity: 0.5,
        blending: THREE.AdditiveBlending,
        depthTest: false,
        color: colors[ ~~( Math.random() * 5 )]
      });
      beam = new THREE.Mesh( beamGeometry, beamMaterial );
      beam.doubleSided = true;
      beam.rotation.x = Math.random() * Math.PI;
      beam.rotation.y = Math.random() * Math.PI;
      beam.rotation.z = Math.random() * Math.PI;
      beamGroup.add( beam );
    }
  }
58477
public void reset() {
		Iterator pools = particlesByEmitter.values().iterator();
		while (pools.hasNext()) {
			ParticlePool pool = (ParticlePool) pools.next();
			pool.reset(this);
		}
		
		for (int i=0;i<emitters.size();i++) {
			ParticleEmitter emitter = (ParticleEmitter) emitters.get(i);
			emitter.resetState();
		}
	}
756133
protected void processVelocityResource(ITemplateSource source, Map<String, Object> params, String target) throws Exception {

		for(ITemplateSourceEntry entry : source.listEntries()) {
			//System.out.println("Wykryto zasób: " + entry.getName());

			if(entry.isFile()) {
//				System.out.println("Element " + entry.getTemplate() + "/" + source.getResource() +
//						"/"+ entry.getName() + " jest plikiem");
				processVelocityFile(entry, source.getResource(), params, target);
			}
		}
	}
598061
public void setSystem(ParticleSystem system) {
		this.system = system;
		emitters.clear();
		system.setRemoveCompletedEmitters(false);
		for (int i = 0; i < system.getEmitterCount(); i++) {
			emitters.add(system.getEmitter(i));
		}
	}
1294670
function (scrollPositions) {
            var containerDiv = this.getContainerDiv();
            if (containerDiv && scrollPositions) {
                if (scrollPositions.hasOwnProperty('scrollLeft') && scrollPositions.scrollLeft != null) {
                    containerDiv.scrollLeft = scrollPositions.scrollLeft;
                }
                if (scrollPositions.hasOwnProperty('scrollTop') && scrollPositions.scrollTop != null) {
                    containerDiv.scrollTop = scrollPositions.scrollTop;
                }
            }
        }
301463
function( bodies, dt ){

            var world = this._world;

            this.integrateVelocities( bodies, dt );

            if ( world ){
                world.emit('integrate:velocities', {
                    bodies: bodies,
                    dt: dt
                });
            }

            this.integratePositions( bodies, dt );

            if ( world ){
                world.emit('integrate:positions', {
                    bodies: bodies,
                    dt: dt
                });
            }

            return this;
        }
878657
@Override
    public void loadCollisions(Media collisionFormulas, Media collisionGroups)
    {
        loader.loadCollisions(this, collisionFormulas, collisionGroups);
    }