openGL es2.0 粒子系统之烟花

淡淡的烟草味﹌ 2022-08-07 00:19 145阅读 0赞

一、Java代码

package com.gzdxid.particles;
    
    import java.nio.ByteBuffer;
    import java.nio.ByteOrder;
    import java.nio.FloatBuffer;
    import android.graphics.Color;
    import android.opengl.GLES20;
    
     public class ParticleSystem {
    
    	private int mProgram;
    	private int muMVPMatrixHandle;
    	private int muTimeHandle;
    	private int maPositionHandle;
    	private int maColorHandle;
    	private int maDirectionVectorHandle;
    	private int maParticleStartTimeHandle;
    	
    	private static final int BYTES_PER_FLOAT = 4;
    	private static final int POSITION_COMPONENT_COUNT = 3;
    	private static final int COLOR_COMPONENT_COUNT = 3;
    	private static final int VECTOR_COMPONENT_COUNT = 3;
    	private static final int PARTICLE_START_TIME_COMPONENT_COUNT = 1;
    	private static final int TOTAL_COMPONENT_COUNT = POSITION_COMPONENT_COUNT + COLOR_COMPONENT_COUNT + VECTOR_COMPONENT_COUNT + PARTICLE_START_TIME_COMPONENT_COUNT;
    	private static final int STRIDE = TOTAL_COMPONENT_COUNT * BYTES_PER_FLOAT;
    	
    	private int maxParticleCount;
    	private float[] particles;
    	private FloatBuffer mVertexArrayBuffer;
    	private int nextParticle=0;
    	private int currentParticleCount;
    	private int[] vboID;
    	
    	public ParticleSystem(int maxParticleCount,int mProgram) {
    		initVertex(maxParticleCount);
    		initShader(mProgram);
    	}
    	
    	private void initVertex(int maxParticleCount) {
    		this.maxParticleCount=maxParticleCount;
    		particles=new float[maxParticleCount*TOTAL_COMPONENT_COUNT];
    		vboID=new int[1];
    		ByteBuffer vbb=ByteBuffer.allocateDirect(maxParticleCount*TOTAL_COMPONENT_COUNT*4);
    		vbb.order(ByteOrder.nativeOrder());
    		mVertexArrayBuffer=vbb.asFloatBuffer();
    	}
    
    	private void initShader(int mProgram) {
    		this.mProgram=mProgram;
    		muMVPMatrixHandle=GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
    		muTimeHandle=GLES20.glGetUniformLocation(mProgram, "uTime");
    		maPositionHandle=GLES20.glGetAttribLocation(mProgram, "aPosition");
    		maColorHandle=GLES20.glGetAttribLocation(mProgram, "aColor");
    		maDirectionVectorHandle=GLES20.glGetAttribLocation(mProgram, "aDirectionVector");
    		maParticleStartTimeHandle=GLES20.glGetAttribLocation(mProgram, "aParticleStartTime");
    	}
    	
    	public void addParticle(Point3 position,int color,Vector3 direction,float particleStartTime){
    		int particleOffset=nextParticle*TOTAL_COMPONENT_COUNT;
    		int currentOffset=particleOffset;
    		nextParticle++;
    		if(currentParticleCount<maxParticleCount){
    			currentParticleCount++;
    		}
    		if(nextParticle==maxParticleCount){
    			nextParticle=0;
    		}
    		particles[currentOffset++]=position.Px;
    		particles[currentOffset++]=position.Py;
    		particles[currentOffset++]=position.Pz;
    		particles[currentOffset++]=Color.red(color)/255f;
    		particles[currentOffset++]=Color.green(color)/255f;
    		particles[currentOffset++]=Color.blue(color)/255f;
    		particles[currentOffset++]=direction.Vx;
    		particles[currentOffset++]=direction.Vy;
    		particles[currentOffset++]=direction.Vz;
    		particles[currentOffset++]=particleStartTime;
    		mVertexArrayBuffer.position(particleOffset);
    		mVertexArrayBuffer.put(particles, particleOffset, TOTAL_COMPONENT_COUNT);
    		mVertexArrayBuffer.position(0);
    	}
    
    	 public void drawSelf(float[] viewProjectionMatrix,float elapsedTime){
    		int dataOffset=0;
    		GLES20.glUseProgram(mProgram);
    		GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, viewProjectionMatrix, 0);
    		GLES20.glUniform1f(muTimeHandle, elapsedTime);
    		
    		GLES20.glGenBuffers(1, vboID,0);
    		
    		GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboID[0]);
    		GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, mVertexArrayBuffer.capacity()*BYTES_PER_FLOAT, mVertexArrayBuffer, GLES20.GL_DYNAMIC_DRAW);
    		GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
    		
    		GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboID[0]);
    		GLES20.glEnableVertexAttribArray(maPositionHandle);
    		GLES20.glVertexAttribPointer(maPositionHandle, POSITION_COMPONENT_COUNT, GLES20.GL_FLOAT, false, STRIDE, dataOffset);
    		dataOffset+=POSITION_COMPONENT_COUNT*BYTES_PER_FLOAT;
    		
    		GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboID[0]);
    		GLES20.glEnableVertexAttribArray(maColorHandle);
    		GLES20.glVertexAttribPointer(maColorHandle, COLOR_COMPONENT_COUNT, GLES20.GL_FLOAT, false, STRIDE, dataOffset);
    		dataOffset+=COLOR_COMPONENT_COUNT*BYTES_PER_FLOAT;
    		
    		GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboID[0]);
    		GLES20.glEnableVertexAttribArray(maDirectionVectorHandle);
    		GLES20.glVertexAttribPointer(maDirectionVectorHandle, VECTOR_COMPONENT_COUNT, GLES20.GL_FLOAT, false, STRIDE, dataOffset);
    		dataOffset+=VECTOR_COMPONENT_COUNT*BYTES_PER_FLOAT;
    		
    		GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboID[0]);
    		GLES20.glEnableVertexAttribArray(maParticleStartTimeHandle);
    		GLES20.glVertexAttribPointer(maParticleStartTimeHandle, PARTICLE_START_TIME_COMPONENT_COUNT, GLES20.GL_FLOAT, false, STRIDE, dataOffset);
    		
    		GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
    		
    		GLES20.glDrawArrays(GLES20.GL_POINTS, 0, currentParticleCount);
    		
    		GLES20.glDeleteBuffers(1, vboID,0);
    		GLES20.glDisableVertexAttribArray(maPositionHandle);
    		GLES20.glDisableVertexAttribArray(maColorHandle);
    		GLES20.glDisableVertexAttribArray(maDirectionVectorHandle);
    		GLES20.glDisableVertexAttribArray(maParticleStartTimeHandle);
    	}
    	
    }

package com.gzdxid.particles;
    
    import java.util.Random;
    
    import android.opengl.Matrix;
    
    public class ParticleShooter {
    
    	private Point3 position;
    	private int color;
    	private float angleVariance;
    	private float speedVariance;
    	private float[] directionVector=new float[4];
    	
    	private final Random random=new Random();
    	private float[] resultVector=new float[4];
    	private float[] rotationMatrix=new float[16];
    	
    	public ParticleShooter(Point3 position,Vector3 direction,int color,float angleVarianceInDegrees,float speedVariance) {
    		this.position=position;
    		this.color=color;
    		this.speedVariance=speedVariance;
    		this.angleVariance=angleVarianceInDegrees;
            directionVector[0]=direction.Vx;
            directionVector[1]=direction.Vy;
            directionVector[2]=direction.Vz;
            directionVector[3]=0;
    	}
    	
    	public void toParticleSystem(ParticleSystem particleSystem,float currentTime,int count){
    		for(int i=0;i<count;i++){
    			Matrix.setRotateEulerM(
    					rotationMatrix, 
    					0, 
    					(random.nextFloat()-0.5f)*angleVariance,
    					(random.nextFloat()-0.5f)*angleVariance, 
    					(random.nextFloat()-0.5f)*angleVariance);
    			Matrix.multiplyMV(resultVector, 0, rotationMatrix, 0, directionVector, 0);
    			float speedAdjustment=1f+random.nextFloat()*speedVariance;
    			Vector3 thisDirection=new Vector3(
    					resultVector[0]*speedAdjustment, 
    					resultVector[1]*speedAdjustment, 
    					resultVector[2]*speedAdjustment);
    			particleSystem.addParticle(position, color, thisDirection, currentTime);
    		}
    	}
    }

package com.gzdxid.particles;
    
    public class Vector3 {
    
    	protected float Vx;
    	protected float Vy;
    	protected float Vz;
    	
    	public Vector3(float x,float y,float z) {
    		Vx=x;
    		Vy=y;
    		Vz=z;
    	}
    }

package com.gzdxid.particles;
    
    public class Point3 {
    
    	protected float Px;
    	protected float Py;
    	protected float Pz;
    	
    	public Point3(float x,float y,float z) {
    		Px=x;
    		Py=y;
    		Pz=z;
    	}
    }

二、顶点着色器：

uniform mat4 uMVPMatrix;
    uniform float uTime;
    
    attribute vec3 aPosition;
    attribute vec3 aColor;
    attribute vec3 aDirectionVector;
    attribute float aParticleStartTime;
    
    varying vec3 vColor;
    varying float vElapsedTime;
    
    void main()
    {
       vColor=aColor;
       vElapsedTime=uTime-aParticleStartTime;
       vec3 currentPosition=aPosition+(aDirectionVector*vElapsedTime);
       float gravityFactor=vElapsedTime*vElapsedTime/10.0;
       currentPosition.y-=gravityFactor;
       gl_Position=uMVPMatrix*vec4(currentPosition,1.0);
       gl_PointSize=25.0;
    }

三、片源着色器：

precision mediump float;
    
    varying vec3 vColor;
    varying float vElapsedTime;
    
    void main()
    {
       float xDistance=0.5-gl_PointCoord.x;
       float yDistance=0.5-gl_PointCoord.y;
       float distanceFromCenter=sqrt(xDistance*xDistance+yDistance*yDistance);
       if(distanceFromCenter>0.5){
       discard;
       }else{
       gl_FragColor=vec4(vColor/vElapsedTime,1.0);
       }
    }

四、使用方法：

public void initParticle(){
    		final Point3 position=new Point3(0, 0, 0);
    		final Vector3 particleDirection=new Vector3(0f, 0.5f, 0);
    		final float angleVarianceInDegrees=10f;
    		final float speedVariance=1f;
    		globalStartTime=System.nanoTime();
    		particleSystem=new ParticleSystem(10000, ShaderManager.getParticleColorShaderProgram());
    		particleShooter=new ParticleShooter(position, particleDirection, Color.rgb(255, 50, 5), angleVarianceInDegrees, speedVariance);
    		grainShooter=new GrainShooter(2, 8000, ShaderManager.getGrainColorShaderProgram());
    		
    	}

private void drawParticle(){
    			
    			float currentTime=(System.nanoTime()-globalStartTime)/1000000000f;
    			GLES20.glEnable(GLES20.GL_BLEND);
    			GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE);
    			MatrixState.pushMatrix();
    			MatrixState.translate(-0.2f, -0.6f, 0);
    			particleShooter.toParticleSystem(particleSystem, currentTime, 5);
    			particleSystem.drawSelf(MatrixState.getFinalMatrix(),currentTime);
    			MatrixState.popMatrix();
    			GLES20.glDisable(GLES20.GL_BLEND);
    			
    			GLES20.glEnable(GLES20.GL_DEPTH_TEST);
    			GLES20.glEnable(GLES20.GL_CULL_FACE);
    			MatrixState.pushMatrix();
    			MatrixState.rotate(-180, 1, 0, 0);
    			MatrixState.translate(-0.2f, 0.2f, 0);
    			grainShooter.drawSelf();
    			MatrixState.popMatrix();
    			GLES20.glDisable(GLES20.GL_DEPTH_TEST);
    			GLES20.glDisable(GLES20.GL_CULL_FACE);
    			
              		}