粒子系统

最新推荐文章于 2020-09-16 22:44:05 发布
原创 最新推荐文章于 2020-09-16 22:44:05 发布 · 1.6k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#游戏引擎

粒子系统
粒子系统本质就是同时渲染很多个quad.它有两种运动模式，一种是重力，一种是旋转。
/********************************************************************
 Copyright(C), 2012-2013,
 FileName:ParticleSystem.h
 Description:
 Author:cloud
 Created:2014/11/07
 history:
7:11:2014 15:41 by
*********************************************************************/
#pragma once
#include "export/Node.h"
#include "base/GameMath.h"
#include "base/Value.h"
#include "base/TextureManager.h"
#include "base/render/Quad.h"
namespace cloud
{
	enum kParticleTypes {
		kParticleTypeGravity,
		kParticleTypeRadial
	};

	// Structure used to hold particle specific information
	typedef struct {
		Vec2 position;
		Vec2 direction;
		Vec2 startPos;
		Color  color;
		Color  deltaColor;
		float rotation;
		float rotationDelta;
		float radialAcceleration;
		float tangentialAcceleration;
		float radius;
		float radiusDelta;
		float angle;
		float degreesPerSecond;
		float particleSize;
		float particleSizeDelta;
		float timeToLive;
	} Particle;

	class ParticleSystem :public Node
	{
	public:
		ParticleSystem(const char* particleList);
		~ParticleSystem();
		void update(float dt);

		//定时喷射粒子和到点结束粒子
		void managerParticleLife( float dt );


		void stopSystem();
		void reset();
		void initParticle(const std::string& dirPath) ;
		bool isAutoRemoveOnFinish() const;
		void setAutoRemoveOnFinish(bool var);
	protected:
		virtual void updateParticleQuads(Particle *currentParticle);
		void initWithDictionary(ValueMap& dictionary);
		// Adds a particle from the particle pool to the emitter
		bool addParticle();
		// Initialises a particle ready for use
		void initParticle(Particle* particle);
		// Set up the arrays that are going to store our particles
		

		
		int _width;
		int _height;
		std::string imgPath;
		std::string imageData;
		bool _isAutoRemoveOnFinish;

		int emitterType;
		//GLKTextureInfo *texture;

		//粒子生命周期
		int _totalParticles;
		int _particleCount;
		float _emissionRate;
		float _emitCounter;	
		float _elapsedTime;
		float _duration;




		Vec2 sourcePosition, sourcePositionVariance;
		float angle, angleVariance;								
		float speed, speedVariance;	
		float radialAcceleration, tangentialAcceleration;
		float radialAccelVariance, tangentialAccelVariance;
		Vec2 gravity;
		float particleLifespan, particleLifespanVariance;			
		Color  startColor, startColorVariance;
		Color  finishColor, finishColorVariance;
		float startParticleSize, startParticleSizeVariance;
		float finishParticleSize, finishParticleSizeVariance;
		
		float rotationStart, rotationStartVariance;
		float rotationEnd, rotationEndVariance;

		int vertexArrayName;

		

		int blendFuncSource, blendFuncDestination; // to _blendFunc

		

		//////////////////// Particle ivars only used when a maxRadius value is provided.  These values are used for
		//////////////////// the special purpose of creating the spinning portal emitter
		float maxRadius;						// Max radius at which particles are drawn when rotating
		float maxRadiusVariance;				// Variance of the maxRadius
		float radiusSpeed;					// The speed at which a particle moves from maxRadius to minRadius
		float minRadius;						// Radius from source below which a particle dies
		float minRadiusVariance;				// Variance of the minRadius
		float rotatePerSecond;				// Numeber of degress to rotate a particle around the source pos per second
		float rotatePerSecondVariance;		// Variance in degrees for rotatePerSecond

		//////////////////// Particle Emitter iVars
		bool  _isActive;
		bool  useTexture;
		int particleIndex;		// Stores the number of particles that are going to be rendered
		int vertexIndex;         // Stores the index of the vertices being used for each particle

		Particle *particles;		// Array of particles that hold the particle emitters particle details
	};
}

/********************************************************************
 Copyright(C), 2012-2013,
 FileName:ParticleSystem.cpp
 Description:
 Author:cloud
 Created:2014/11/07
 history:
7:11:2014 15:42 by
*********************************************************************/
#include "base/fileUtils/FileUtils.h"
#include "base/TextureManager.h"
#include "base/EngineMacro.h"
#include "ParticleSystem.h"
//#define  POSITION_TYPE

namespace cloud
{	
	ParticleSystem::ParticleSystem(const char* particleList):particles(NULL),_isAutoRemoveOnFinish(false)
	{
		ValueMap dictionary = FileUtils::getInstance()->getDictFormFile(particleList);
		
		initWithDictionary(dictionary);
		
		
	}

	bool ParticleSystem::isAutoRemoveOnFinish() const
	{
		return _isAutoRemoveOnFinish;
	}

	void ParticleSystem::setAutoRemoveOnFinish(bool var)
	{
		_isAutoRemoveOnFinish = var;
	}


	void ParticleSystem::initParticle(const std::string& dirPath)
	{
		particles = (Particle*)malloc( sizeof(Particle) * _totalParticles );
		// By default the particle emitter is active when created
		_isActive = true;
		// Set the particle count to zero
		_particleCount = 0;
		// Reset the elapsed time
		_elapsedTime = 0;	
		scheduleUpdate();
	}

	ParticleSystem::~ParticleSystem()
	{
		if(particles)
		{
			free(particles);
			particles = NULL;
		}
		
	}

	void ParticleSystem::initWithDictionary(ValueMap& dictionary)
	{
		
		// Load all of the values from the XML file into the particle emitter.  The functions below are using the
		// TBXMLAdditions category.  This adds convenience methods to TBXML to help cut down on the code in this method.
		_totalParticles                = dictionary["maxParticles"].asInt();
		emitterType                 = dictionary["emitterType"].asInt();
		sourcePosition              = Vec2(dictionary["sourcePositionx"].asFloat(),dictionary["sourcePositiony"].asFloat());
		sourcePositionVariance      = Vec2(dictionary["sourcePositionVariancex"].asFloat(),dictionary["sourcePositionVariancey"].asFloat());
		speed                       = dictionary["speed"].asFloat();
		speedVariance               = dictionary["speedVariance"].asFloat();
		particleLifespan            = dictionary["particleLifeSpan"].asFloat();
		particleLifespanVariance    = dictionary["particleLifespanVariance"].asFloat();
		angle                       = dictionary["angle"].asFloat();
		angleVariance               = dictionary["angleVariance"].asFloat();
		gravity                     = Vec2(dictionary["gravityx"].asFloat(),dictionary["gravityy"].asFloat());
		radialAcceleration          = dictionary["radialAcceleration"].asFloat();
		radialAccelVariance         = dictionary["radialAccelVariance"].asFloat();
		tangentialAcceleration      = dictionary["tangentialAcceleration"].asFloat();
		tangentialAccelVariance     = dictionary["tangentialAccelVariance"].asFloat();
		startColor                  = Color(dictionary["startColorRed"].asFloat(),dictionary["startColorGreen"].asFloat(),dictionary["startColorBlue"].asFloat(),dictionary["startColorAlpha"].asFloat());
		startColorVariance          = Color(dictionary["startColorVarianceRed"].asFloat(),dictionary["startColorVarianceGreen"].asFloat(),dictionary["startColorVarianceBlue"].asFloat(),dictionary["startColorVarianceAlpha"].asFloat());
		finishColor                 = Color(dictionary["finishColorRed"].asFloat(),dictionary["finishColorGreen"].asFloat(),dictionary["finishColorBlue"].asFloat(),dictionary["finishColorAlpha"].asFloat());
		finishColorVariance         = Color(dictionary["finishColorVarianceRed"].asFloat(),dictionary["finishColorVarianceGreen"].asFloat(),dictionary["finishColorVarianceBlue"].asFloat(),dictionary["finishColorVarianceAlpha"].asFloat());
		
		startParticleSize           = dictionary["startParticleSize"].asFloat();
		startParticleSizeVariance   = dictionary["startParticleSizeVariance"].asFloat();
		finishParticleSize          = dictionary["finishParticleSize"].asFloat();
		finishParticleSizeVariance  = dictionary["finishParticleSizeVariance"].asFloat();
		_duration                    = dictionary["duration"].asFloat();
		blendFuncSource             = dictionary["blendFuncSource"].asInt();
		blendFuncDestination        = dictionary["blendFuncDestination"].asInt();

		// These paramters are used when you want to have the particles spinning around the source location
		maxRadius                   = dictionary["maxRadius"].asFloat();
		maxRadiusVariance           = dictionary["maxRadiusVariance"].asFloat();
		minRadius                   = dictionary["minRadius"].asFloat();
		minRadiusVariance           = dictionary["minRadiusVariance"].asFloat();
		rotatePerSecond             = dictionary["rotatePerSecond"].asFloat();
		rotatePerSecondVariance     = dictionary["rotatePerSecondVariance"].asFloat();
		rotationStart               = dictionary["rotationStart"].asFloat();
		rotationStartVariance       = dictionary["rotationStartVariance"].asFloat();
		rotationEnd                 = dictionary["rotationEnd"].asFloat();
		rotationEndVariance         = dictionary["rotationEndVariance"].asFloat();

		// Calculate the emission rate
		_emissionRate                = _totalParticles / particleLifespan;
		_emitCounter                 = 0;

		imgPath = dictionary["textureFileName"].asString();

		//_texture = TextureManager::getInstance()->createTexture(_imgPath.c_str(),_width,_height);
		imageData = dictionary["textureImageData"].asString();

	
	}

	// Adds a particle from the particle pool to the emitter
	bool ParticleSystem::addParticle()
	{
		// If we have already reached the maximum number of particles then do nothing
		if (_particleCount == _totalParticles)
			return false;

		// Take the next particle out of the particle pool we have created and initialize it
		Particle *particle = &particles[_particleCount];
		initParticle(particle);

		// Increment the particle count
		_particleCount++;

		// Return YES to show that a particle has been created
		return true;
	}

	// Initialises a particle ready for use
	void ParticleSystem::initParticle(Particle* particle)
	{
		// Init the position of the particle.  This is based on the source position of the particle emitter
		// plus a configured variance.  The RANDOM_MINUS_1_TO_1 macro allows the number to be both positive
		// and negative

		particle->position.x = sourcePosition.x + sourcePositionVariance.x * RANDOM_MINUS_1_TO_1();
		particle->position.y = sourcePosition.y + sourcePositionVariance.y * RANDOM_MINUS_1_TO_1();
		particle->startPos.x = sourcePosition.x;
		particle->startPos.y = sourcePosition.y;

		// Init the direction of the particle.  The newAngle is calculated using the angle passed in and the
		// angle variance.
		GLfloat newAngle = angleToRadian(angle + angleVariance * RANDOM_MINUS_1_TO_1());

		// Create a new GLKVector2 using the newAngle
		Vec2 vector = Vec2(cosf(newAngle), sinf(newAngle));

		// Calculate the vectorSpeed using the speed and speedVariance which has been passed in
		GLfloat vectorSpeed = speed + speedVariance * RANDOM_MINUS_1_TO_1();

		// The particles direction vector is calculated by taking the vector calculated above and
		// multiplying that by the speed
		particle->direction = vector * vectorSpeed;

		// Calculate the particles life span using the life span and variance passed in
		particle->timeToLive = MAX(0, particleLifespan + particleLifespanVariance * RANDOM_MINUS_1_TO_1());

		float startRadius = maxRadius + maxRadiusVariance * RANDOM_MINUS_1_TO_1();
		float endRadius = minRadius + minRadiusVariance * RANDOM_MINUS_1_TO_1();

		// Set the default diameter of the particle from the source position
		particle->radius = startRadius;
		particle->radiusDelta = (endRadius - startRadius) / particle->timeToLive;
		particle->angle = angleToRadian(angle + angleVariance * RANDOM_MINUS_1_TO_1());
		particle->degreesPerSecond = angleToRadian(rotatePerSecond + rotatePerSecondVariance * RANDOM_MINUS_1_TO_1());

		particle->radialAcceleration = radialAcceleration + radialAccelVariance * RANDOM_MINUS_1_TO_1();
		particle->tangentialAcceleration = tangentialAcceleration + tangentialAccelVariance * RANDOM_MINUS_1_TO_1();

		// Calculate the particle size using the start and finish particle sizes
		GLfloat particleStartSize = startParticleSize + startParticleSizeVariance * RANDOM_MINUS_1_TO_1();
		GLfloat particleFinishSize = finishParticleSize + finishParticleSizeVariance * RANDOM_MINUS_1_TO_1();
		particle->particleSizeDelta = ((particleFinishSize - particleStartSize) / particle->timeToLive);
		particle->particleSize = MAX(0, particleStartSize);

		// Calculate the color the particle should have when it starts its life.  All the elements
		// of the start color passed in along with the variance are used to calculate the star color
		Color start = Color(0, 0, 0, 0);
		start.r = startColor.r + startColorVariance.r * RANDOM_MINUS_1_TO_1();
		start.g = startColor.g + startColorVariance.g * RANDOM_MINUS_1_TO_1();
		start.b = startColor.b + startColorVariance.b * RANDOM_MINUS_1_TO_1();
		start.a = startColor.a + startColorVariance.a * RANDOM_MINUS_1_TO_1();

		// Calculate the color the particle should be when its life is over.  This is done the same
		// way as the start color above
		Color end = Color(0, 0, 0, 0);
		end.r = finishColor.r + finishColorVariance.r * RANDOM_MINUS_1_TO_1();
		end.g = finishColor.g + finishColorVariance.g * RANDOM_MINUS_1_TO_1();
		end.b = finishColor.b + finishColorVariance.b * RANDOM_MINUS_1_TO_1();
		end.a = finishColor.a + finishColorVariance.a * RANDOM_MINUS_1_TO_1();

		// Calculate the delta which is to be applied to the particles color during each cycle of its
		// life.  The delta calculation uses the life span of the particle to make sure that the 
		// particles color will transition from the start to end color during its life time.  As the game
		// loop is using a fixed delta value we can calculate the delta color once saving cycles in the 
		// update method

		particle->color = start;
		particle->deltaColor.r = ((end.r - start.r) / particle->timeToLive);
		particle->deltaColor.g = ((end.g - start.g) / particle->timeToLive);
		particle->deltaColor.b = ((end.b - start.b) / particle->timeToLive);
		particle->deltaColor.a = ((end.a - start.a) / particle->timeToLive);

		// Calculate the rotation
		GLfloat startA = rotationStart + rotationStartVariance * RANDOM_MINUS_1_TO_1();
		GLfloat endA = rotationEnd + rotationEndVariance * RANDOM_MINUS_1_TO_1();
		particle->rotation = startA;
		particle->rotationDelta = (endA - startA) / particle->timeToLive;


	} 

	void ParticleSystem::stopSystem()
	{
		_isActive = false;
		_elapsedTime = 0;
		_emitCounter = 0;
	}	

	void ParticleSystem::reset()
	{
		_isActive = true;
		_elapsedTime = 0;
		for (int i = 0; i < _particleCount; i++) {
			Particle *p = &particles[i];
			p->timeToLive = 0;
		}
		_emitCounter = 0;
		_emissionRate = _totalParticles / particleLifespan;
	}

	void ParticleSystem::update(float dt)
	{
		managerParticleLife(dt);


		// Reset the particle index before updating the particles in this emitter
		particleIndex = 0;
#ifdef POSITION_TYPE
		Vec2 currentPosition = Vec2::ZERO;
		if (_positionType == PositionType::FREE)
		{
			currentPosition = this->convertToWorldSpace(Vec2::ZERO);
		}
		else if (_positionType == PositionType::RELATIVE)
		{
			currentPosition = _position;
		}
#endif
		// Loop through all the particles updating their location and color
		while (particleIndex < _particleCount) {

			// Get the particle for the current particle index
			Particle *currentParticle = &particles[particleIndex];

			// FIX 1
			// Reduce the life span of the particle
			currentParticle->timeToLive -= dt;

			// If the current particle is alive then update it
			if (currentParticle->timeToLive > 0) {

				// If maxRadius is greater than 0 then the particles are going to spin otherwise they are effected by speed and gravity
				if (emitterType == kParticleTypeRadial) {

					// FIX 2
					// Update the angle of the particle from the sourcePosition and the radius.  This is only done of the particles are rotating
					currentParticle->angle += currentParticle->degreesPerSecond * dt;
					currentParticle->radius += currentParticle->radiusDelta * dt;

					Vec2 tmp;
					tmp.x = sourcePosition.x - cosf(currentParticle->angle) * currentParticle->radius;
					tmp.y = sourcePosition.y - sinf(currentParticle->angle) * currentParticle->radius;
					currentParticle->position = tmp;

				} else {
					Vec2 tmp, radial, tangential;

					radial = Vec2(0,0);

					// By default this emitters particles are moved relative to the emitter node position
					Vec2 positionDifference = currentParticle->startPos;
					currentParticle->position = currentParticle->position - positionDifference;

					if (currentParticle->position.x || currentParticle->position.y)
						radial = currentParticle->position.getNormalized();

					tangential = radial;
					radial = radial * currentParticle->radialAcceleration;

					float newy = tangential.x;
					tangential.x = -tangential.y;
					tangential.y = newy;
					tangential = tangential * currentParticle->tangentialAcceleration;

					tmp = radial+tangential + gravity;
					tmp = tmp * dt;
					currentParticle->direction = currentParticle->direction + tmp;
					tmp = currentParticle->direction * dt;
					currentParticle->position = currentParticle->position + tmp;

					// Now apply the difference calculated early causing the particles to be relative in position to the emitter position
					currentParticle->position = currentParticle->position + positionDifference;
				}

				// Update the particles color
				currentParticle->color.r += currentParticle->deltaColor.r * dt;
				currentParticle->color.g += currentParticle->deltaColor.g * dt;
				currentParticle->color.b += currentParticle->deltaColor.b * dt;
				currentParticle->color.a += currentParticle->deltaColor.a * dt;

				// Update the particle size
				currentParticle->particleSize += currentParticle->particleSizeDelta * dt;
				currentParticle->particleSize = MAX(0, currentParticle->particleSize);

				// Update the rotation of the particle
				currentParticle->rotation += currentParticle->rotationDelta * dt;

				// As we are rendering the particles as quads, we need to define 6 vertices for each particle
				

				// If a rotation has been defined for this particle then apply the rotation to the vertices that define
				// the particle
#ifdef POSITION_TYPE
				Vec2    newPos;

				if (_positionType == PositionType::FREE || _positionType == PositionType::RELATIVE)
				{
					Vec2 diff = currentPosition - p->startPos;
					newPos = p->pos - diff;
				} 
				else
				{
					newPos = p->pos;
				}
#endif
				updateParticleQuads(currentParticle);
				

				// Update the particle and vertex counters
				particleIndex++;
			} else {

				// As the particle is not alive anymore replace it with the last active particle 
				// in the array and reduce the count of particles by one.  This causes all active particles
				// to be packed together at the start of the array so that a particle which has run out of
				// life will only drop into this clause once
				if (particleIndex != _particleCount - 1)
					particles[particleIndex] = particles[_particleCount - 1];

				_particleCount--;

				if( _particleCount == 0 && _isAutoRemoveOnFinish )
				{
					this->unscheduleUpdate();
					_parent->removeNodeAndChild(this);
					return;
				}
			}
		}
	}

	void ParticleSystem::updateParticleQuads(Particle *currentParticle)
	{

	}

	void ParticleSystem::managerParticleLife( float dt )
	{
		// If the emitter is active and the emission rate is greater than zero then emit particles
		if (_isActive && _emissionRate)
		{
			GLfloat rate = 1.0f/_emissionRate;//每个粒子的喷射时间

			if (_particleCount < _totalParticles)
				_emitCounter += dt;

			while (_particleCount < _totalParticles && _emitCounter > rate) {
				addParticle();
				_emitCounter -= rate;
			}

			_elapsedTime += dt;

			if (_duration != -1 && _duration < _elapsedTime)
				stopSystem();
		}
	}

}
渲染块
/********************************************************************
 Copyright(C), 2012-2013,
 FileName:ParticleSystem.h
 Description:
 Author:cloud
 Created:2014/11/07
 history:
7:11:2014 15:41 by
*********************************************************************/
#pragma once
#include "export/particle/ParticleSystem.h"
#include "export/Sprite.h"

namespace cloud
{
	class ParticleSystemQuad :public ParticleSystem
	{
	public:
		ParticleSystemQuad(const char* particleList);
		~ParticleSystemQuad();
		void initParticleQuads(const std::string& dirPath) ;
		void render();
	protected:
		void updateParticleQuads(Particle *currentParticle);
		bool  _opacityModifyRGB;
		Quad* _quads;
		GLuint _textureID;
		QuadCommand      _quadCommand; 
		BlendFunc        _blendFunc; 
	};
}

/********************************************************************
 Copyright(C), 2012-2013,
 FileName:ParticleSystem.cpp
 Description:
 Author:cloud
 Created:2014/11/07
 history:
7:11:2014 15:42 by
*********************************************************************/
#include "base/fileUtils/FileUtils.h"
#include "base/TextureManager.h"
#include "base/EngineMacro.h"
#include "export/Particle/ParticleSystemQuad.h"
#include "base/render/Renderer.h"

namespace cloud
{	
	ParticleSystemQuad::ParticleSystemQuad(const char* particleList):ParticleSystem(particleList),_quads(NULL),_textureID(0)
	{
		std::string dirPath = particleList;
		int pos = dirPath.rfind("/");
		if (pos > -1)
		{
			dirPath = dirPath.substr(0,pos+1);
		}
		else
		{
			dirPath = "";
		}
		
		initParticleQuads(dirPath);
	}

	ParticleSystemQuad::~ParticleSystemQuad()
	{
		if(_quads)
		{
			free(_quads);
			_quads = NULL;
		}
	}

	void ParticleSystemQuad::initParticleQuads(const std::string& dirPath)
	{
		_quads = (Quad*)malloc( _totalParticles * sizeof(Quad));
		memset(_quads, 0, _totalParticles * sizeof(Quad));
		for(int i = 0;i < _totalParticles; ++i)
		{
			_quads[i].tl._texCoord = Vec2(0,1);
			_quads[i].bl._texCoord = Vec2(0,0);
			_quads[i].tr._texCoord = Vec2(1,1);
			_quads[i].br._texCoord = Vec2(1,0);	
		}
			

		_opacityModifyRGB = false;
		//TODO:图片alpha是否预处理二进制数据


		if (_textureID == 0 )
		{
			//搜索路径为plist目录下的
			imgPath = dirPath + imgPath;
			_textureID = TextureManager::getInstance()->createTexture(imgPath.c_str(),_width,_height);
			if (_textureID == 0 && imageData.length() > 0)
			{
				//TODO:解析图片二进制数据
			}


		}
		_blendFunc = BlendFunc(blendFuncSource,blendFuncDestination);	

		ParticleSystem::initParticle(dirPath);
	}

	void ParticleSystemQuad::render()
	{
		updateMatrix();
				
		_quadCommand.init(_quads,_textureID,particleIndex,_blendFunc,_model);
		Renderer::getInstance()->addQuadCommand(&_quadCommand);
	}

	void ParticleSystemQuad::updateParticleQuads(Particle *currentParticle)
	{
		float halfSize = currentParticle->particleSize * 0.5f;
		if (currentParticle->rotation) {
			
			float x1 = -halfSize;
			float y1 = -halfSize;
			float x2 = halfSize;
			float y2 = halfSize;
			float x = currentParticle->position.x;
			float y = currentParticle->position.y;
			float r = angleToRadian(currentParticle->rotation);
			float cr = cosf(r);
			float sr = sinf(r);
			float ax = x1 * cr - y1 * sr + x;
			float ay = x1 * sr + y1 * cr + y;
			float bx = x2 * cr - y1 * sr + x;
			float by = x2 * sr + y1 * cr + y;
			float cx = x2 * cr - y2 * sr + x;
			float cy = x2 * sr + y2 * cr + y;
			float dx = x1 * cr - y2 * sr + x;
			float dy = x1 * sr + y2 * cr + y;

			_quads[particleIndex].bl._position.x = ax;
			_quads[particleIndex].bl._position.y = ay;
			_quads[particleIndex].bl._color = currentParticle->color;


			_quads[particleIndex].br._position.x = bx;
			_quads[particleIndex].br._position.y = by;
			_quads[particleIndex].br._color = currentParticle->color;

			_quads[particleIndex].tl._position.x = dx;
			_quads[particleIndex].tl._position.y = dy;
			_quads[particleIndex].tl._color = currentParticle->color;

			_quads[particleIndex].tr._position.x = cx;
			_quads[particleIndex].tr._position.y = cy;
			_quads[particleIndex].tr._color = currentParticle->color;
		} else {
			// Using the position of the particle, work out the four vertices for the quad that will hold the particle
			// and load those into the _quads array.
			_quads[particleIndex].bl._position.x = currentParticle->position.x - halfSize;
			_quads[particleIndex].bl._position.y = currentParticle->position.y - halfSize;
			_quads[particleIndex].bl._color = currentParticle->color;

			_quads[particleIndex].br._position.x = currentParticle->position.x + halfSize;
			_quads[particleIndex].br._position.y = currentParticle->position.y - halfSize;
			_quads[particleIndex].br._color = currentParticle->color;

			_quads[particleIndex].tl._position.x = currentParticle->position.x - halfSize;
			_quads[particleIndex].tl._position.y = currentParticle->position.y + halfSize;
			_quads[particleIndex].tl._color = currentParticle->color;

			_quads[particleIndex].tr._position.x = currentParticle->position.x + halfSize;
			_quads[particleIndex].tr._position.y = currentParticle->position.y + halfSize;
			_quads[particleIndex].tr._color = currentParticle->color;
		}
	}
}



opengl-glEnable和BlendFunc的使用
以爱护甲,爱满枫林。
12-30 541
混合允许新绘制的像素（源像素）与已经存在于帧缓冲中的像素（目标像素）相结合，而不是简单地覆盖它们。具体来说，GL_ONE_MINUS_SRC_ALPHA 表示使用 1 - 源颜色的 Alpha 值 作为混合因子。例如，如果一个像素的 Alpha 值为 0.5，则背景颜色将有 50% 的权重参与最终颜色的计算。GL_ONE_MINUS_SRC_ALPHA：表示1减去源颜色的Alpha通道值将作为目标混合因子。GL_SRC_ALPHA：表示源颜色的Alpha通道值将作为源混合因子。
旧粒子系统转换成新粒子系统.zip
06-24
在Unity引擎中，粒子系统是用于创建各种视觉特效，如火焰、烟雾、水波、火花等的重要工具。旧版的粒子系统（Legacy Particle System）虽然功能强大，但与新版ParticleSystem相比，存在性能消耗大、功能限制多等问题...
cocos2dx粒子引擎的分析-1
bull521的博客
09-16 769
先分析ParticleSystem类的init群代码 bool ParticleSystem::init() { return initWithTotalParticles(150); } 这个是默认的初始化函数，里面调用了initWithTotalParticles()函数。 bool ParticleSystem::initWithFile(const std::strin...
【cocos2D-x学习】10.粒子特效（重力模式）的入门级学习——Read The F**king Code
ronintao的专栏
08-11 6848
【目标】：通过阅读源码，来学习粒子特效的重力模式中的N多参数的意义 一、准备工作——各种工具 1、源码     源码当然是必须的。这里参阅的代码版本是 cocos2d-2.0-x-2.0.4，新版本可能会有一些出入。 2、plist编辑工具     由于粒子特效主要是各种参数的调配，所以可以使用 plist 来通过 initWithFile 加载。plist文件可
CocosCreator之粒子导入
码之有道
09-16 1498
粒子资源（ParticleSystem） 导入粒子资源 将 Cocos2d 支持的粒子.plist文件直接放到工程资源目录下。 在场景中添加粒子系统 方法一，从资源管理器里将粒子资源直接拖到层级管理器： 方法二，从资源管理器里将粒子资源直接拖到场景编辑器： 方法三，在已有节点上添加一个粒子系统（ParticleSystem）组件，从资源管理器里将粒子资源直接赋给组件的File属性： 注意：不支持.plist文件中的 sourcePosition ...
cocos2dx创建粒子的问题
Zszen John 的 Blog
05-26 539
当创建粒子的时候符合以下条件, 可能会导致粒子无效: 1.在同一时刻 2.循环创建 3.同一个粒子 解决方法是将自动移除功能关闭 setAutoRemoveOnFinish(false);
A-Frame引擎开发：A-Frame粒子系统与特效+A-Frame基础与环境搭建+HTML和WebVR入门+A-Frame组件系统深入解析+A-Frame实体-组件架构详解+粒子系统组件介绍等教程
最新发布
09-03
A-Frame引擎开发：A-Frame粒子系统与特效_（1）.A-Frame基础与环境搭建.docx A-Frame引擎开发：A-Frame粒子系统与特效_（2）.HTML和WebVR入门.docx A-Frame引擎开发：A-Frame粒子系统与特效_（3）.A-Frame组件系统...
SDL2粒子：SDL2的粒子系统
02-04
【标题】：“SDL2粒子：SDL2的粒子系统” 【正文】： 在游戏开发中，粒子系统是一个重要的组件，用于创建各种视觉效果，如火焰、烟雾、爆炸、水流等。SDL2（Simple DirectMedia Layer 2）是一个跨平台的开发库，常...
webgl-particles:WebGL粒子系统演示
03-11
WebGL粒子系统是一种在网页上实现动态视觉效果的技术，它利用了WebGL，这是一个JavaScript API，允许在浏览器中进行硬件加速的3D图形渲染。WebGL粒子系统通常用于创建火焰、烟雾、水波、星光等特效，为网页增加丰富...
水花、瀑布等特效，unity自带粒子系统做的
10-03
Unity3D是一款强大的游戏开发引擎，它提供了许多内置工具来帮助开发者创建丰富的视觉效果，其中粒子系统就是其中之一。粒子系统允许开发者模拟各种自然现象，如火焰、烟雾、爆炸，当然也包括水花、水流和瀑布等水体...
cocos2d-x混合BlendFunc的使用
weixin_34291004的博客
04-18 344
1、什么是混合模式 “混合”是指两种颜色的叠加方式。在新图片将要渲染画到屏幕上的时候，将用在新图片中的红、绿、蓝和透明度信息，与屏幕上已经存在的图片颜色信息相融合。 说的具体一点，就是把某一像素位置上原来的颜色和将要画上去的颜色，通过某种方式混在一起，从而实现特殊的效果。 新图片颜色被称作“源颜色”，而屏幕上已存在的图片颜色则被称作“目标颜色”。 OpenGL会把源颜色和目标颜色各自取出，...
BlendFunc()两个参数详解
lizeshi125的博客
08-25 993
//创建一个精灵 var layer_1= new cc.LayerColor(cc.color(255,0,0,255),size.width,size.height); var layer_2= new cc.LayerColor(cc.color(0,255,0,255),200,200); this.addChild(layer_1); this.addChild(layer_
cocos2d制作动态光晕效果基础——blendFunc
yuanlanjun
07-28 538
最近的项目要求动态光晕的效果。 何谓动态光晕？之前不知道别人怎么称呼这个效果， 不过在我看来，“动态光晕”这个名儿起的还是蛮不错的。 动态光晕就是在背景图片的上面蒙上一层光照。。。 但是这个光照比较特别，他能够变换颜色，变换光圈的半径大小，从而制造出类似梦幻迷离的效果~ 新项目中我是负责游戏特效这一块的，操作过程中我觉得这东西蛮不错的，很有感觉。 之前的项目中我是负责整个游戏场景的编码...
在ClanLib中使用blend func
Meuck的专栏
01-04 1424
 本文是对Blend Func完全没有认识的人写的，就好象一天前的我一样。 废话我就留到后面才说吧。在ClanLib库中的CL_Surface与CL_Sprite中都会有这个函数：void set_blend_func(CL_BlendFunc src, CL_BlendFunc dest);其CL_BlendFun可以在源代码是看到定义,如下：enum CL_Blen
AS3 Starling extends Particle System 分析
Jave.Lin 的学习笔记
03-21 2524
Starling extentions Particle System Author : Gamua OG 分析作者：Jave.lin 原文：http://blog.youkuaiyun.com/linjf520/article/details/8701354 这是Starling扩展的粒子系统 下来源码，与DEMO运行后，发现效果很强大，于是开始研究其结构； 1、
Cocos2d-x中自定义粒子系统
weixin_30699955的博客
09-15 100
除了使用Cocos2d-x的11种内置粒子系统外，我们还可以通过创建ParticleSystemQuad对象，并设置属性实现自定义粒子系统，通过这种方式完全可以实现我们说需要的各种效果的粒子系统。使用ParticleSystemQuad自定义粒子系统至少有两种方式可以实现：代码创建和plist文件创建。 代码创建 所谓代码创建就是完全通过代码方式实现，其中所有的属性全部是通过程序代码...
cocos2d-x学习笔记（四）粒子系统使用中多次调用时GL calls不断增加的解决办法...
weixin_33918357的博客
08-27 195
今天在编写一个射击类的游戏时用到粒子系统，点击屏幕发射***打中敌机后产生爆炸的粒子效果，以为快要完工的时候，发现每次产生爆炸效果GL calls（每一帧中openGL指令的调用次数）就增加一次，在手机运行肯定出问题，经过仔细分析发现确实是粒子系统没有被移除的原因。开始的程序如下：//根据plist文件创建粒子系统 ParticleSystem*m_emitter1=...
粒子系统代码示例
boring
10-26 883
在书上看到的粒子系统的示例分享给大家参考，希望可以帮助大家学习安卓！   首先是MyRenderer.java   package com.boring.ParticleActivity; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.FloatBuffer; import j...
cocos2d-x 一些实用的函数
weixin_34309435的博客
01-19 192
1.  自己主动释放粒子内存的函数      setAutoRemoveOnFinish(bool var) 2. 解决使用tiled出现像素线的问题在代码中搜索”CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL“ 将他的宏定义值改成 1 3      重力感应的使用函数  // 设置重力感应加速器开启 setAccel...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值