mirror of https://github.com/axmolengine/axmol.git
417 lines
15 KiB
C++
417 lines
15 KiB
C++
/****************************************************************************
|
|
Copyright (C) 2013 Henry van Merode. All rights reserved.
|
|
Copyright (c) 2015 Chukong Technologies Inc.
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
|
|
#include "extensions/Particle3D/CCParticleSystem3D.h"
|
|
#include "extensions/Particle3D/ParticleUniverse/ParticleRenders/CCPUParticle3DRibbonTrailRender.h"
|
|
#include "extensions/Particle3D/ParticleUniverse/CCPUParticle3DUtil.h"
|
|
#include "extensions/Particle3D/ParticleUniverse/CCPUParticle3DSimpleSpline.h"
|
|
#include "renderer/CCMeshCommand.h"
|
|
#include "renderer/CCRenderer.h"
|
|
#include "renderer/CCTextureCache.h"
|
|
#include "renderer/CCGLProgramState.h"
|
|
#include "renderer/CCGLProgramCache.h"
|
|
#include "renderer/CCVertexIndexBuffer.h"
|
|
#include "base/CCDirector.h"
|
|
#include "3d/CCSprite3D.h"
|
|
#include "3d/CCMesh.h"
|
|
#include "2d/CCCamera.h"
|
|
#include <sstream>
|
|
|
|
NS_CC_BEGIN
|
|
|
|
// Constants
|
|
const bool PUParticle3DRibbonTrailRender::DEFAULT_USE_VERTEX_COLOURS = true;
|
|
const size_t PUParticle3DRibbonTrailRender::DEFAULT_MAX_ELEMENTS = 10;
|
|
const float PUParticle3DRibbonTrailRender::DEFAULT_LENGTH = 400;
|
|
const float PUParticle3DRibbonTrailRender::DEFAULT_WIDTH = 5;
|
|
const bool PUParticle3DRibbonTrailRender::DEFAULT_RANDOM_INITIAL_COLOUR = true;
|
|
const Vec4 PUParticle3DRibbonTrailRender::DEFAULT_INITIAL_COLOUR(1, 1, 1, 1);
|
|
const Vec4 PUParticle3DRibbonTrailRender::DEFAULT_COLOUR_CHANGE(0.5, 0.5, 0.5, 0.5);
|
|
|
|
PUParticle3DRibbonTrailRender* PUParticle3DRibbonTrailRender::create( const std::string &texFile )
|
|
{
|
|
auto br = new (std::nothrow) PUParticle3DRibbonTrailRender();
|
|
br->autorelease();
|
|
br->_texFile = texFile;
|
|
return br;
|
|
}
|
|
|
|
void PUParticle3DRibbonTrailRender::render( Renderer* renderer, const Mat4 &transform, ParticleSystem3D* particleSystem )
|
|
{
|
|
if (!_isVisible || !_trail)
|
|
return;
|
|
|
|
bool needDraw = false;
|
|
const ParticlePool &particlePool = particleSystem->getParticlePool();
|
|
if (!particlePool.empty()){
|
|
updateParticles(particlePool);
|
|
needDraw = true;
|
|
}
|
|
|
|
const PUParticleSystem3D::ParticlePoolMap &emitterPool = static_cast<PUParticleSystem3D *>(particleSystem)->getEmittedEmitterParticlePool();
|
|
if (!emitterPool.empty()){
|
|
for (auto iter : emitterPool){
|
|
updateParticles(iter.second);
|
|
needDraw = true;
|
|
}
|
|
}
|
|
|
|
const PUParticleSystem3D::ParticlePoolMap &systemPool = static_cast<PUParticleSystem3D *>(particleSystem)->getEmittedSystemParticlePool();
|
|
if (!systemPool.empty()){
|
|
for (auto iter : systemPool){
|
|
updateParticles(iter.second);
|
|
needDraw = true;
|
|
}
|
|
}
|
|
|
|
if (needDraw)
|
|
_trail->render(renderer, transform, particleSystem);
|
|
}
|
|
|
|
PUParticle3DRibbonTrailRender::PUParticle3DRibbonTrailRender() :
|
|
_quota(0),
|
|
_trail(0),
|
|
_useVertexColours(DEFAULT_USE_VERTEX_COLOURS),
|
|
_maxChainElements(DEFAULT_MAX_ELEMENTS),
|
|
_setLength(false),
|
|
_trailLength(DEFAULT_LENGTH),
|
|
_setWidth(false),
|
|
_trailWidth(DEFAULT_WIDTH),
|
|
_randomInitialColor(DEFAULT_RANDOM_INITIAL_COLOUR),
|
|
_initialColor(DEFAULT_INITIAL_COLOUR),
|
|
_colorChange(DEFAULT_COLOUR_CHANGE),
|
|
_childNode(0)
|
|
{
|
|
std::stringstream ss;
|
|
ss << this;
|
|
_ribbonTrailName = "RibbonTrail" + ss.str();
|
|
autoRotate = false;
|
|
}
|
|
|
|
PUParticle3DRibbonTrailRender::~PUParticle3DRibbonTrailRender()
|
|
{
|
|
if (!_particleSystem)
|
|
return;
|
|
|
|
destroyAll();
|
|
}
|
|
|
|
void PUParticle3DRibbonTrailRender::particleEmitted( PUParticleSystem3D* particleSystem, PUParticle3D* particle )
|
|
{
|
|
// Assigning visual data already done in _updateRenderQueue()
|
|
}
|
|
|
|
void PUParticle3DRibbonTrailRender::particleExpired( PUParticleSystem3D* particleSystem, PUParticle3D* particle )
|
|
{
|
|
if (particle->visualData)
|
|
{
|
|
PUParticle3DRibbonTrailVisualData* ribbonTrailRendererVisualData = static_cast<PUParticle3DRibbonTrailVisualData*>(particle->visualData);
|
|
ribbonTrailRendererVisualData->setVisible(false);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
bool PUParticle3DRibbonTrailRender::isUseVertexColors(void) const
|
|
{
|
|
return _useVertexColours;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
void PUParticle3DRibbonTrailRender::setUseVertexColors(bool useVertexColours)
|
|
{
|
|
_useVertexColours = useVertexColours;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
size_t PUParticle3DRibbonTrailRender::getMaxChainElements(void) const
|
|
{
|
|
return _maxChainElements;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
void PUParticle3DRibbonTrailRender::setMaxChainElements(size_t maxChainElements)
|
|
{
|
|
_maxChainElements = maxChainElements;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
float PUParticle3DRibbonTrailRender::getTrailLength(void) const
|
|
{
|
|
return _trailLength;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
void PUParticle3DRibbonTrailRender::setTrailLength(float trailLength)
|
|
{
|
|
_trailLength = trailLength;
|
|
_setLength = true;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
float PUParticle3DRibbonTrailRender::getTrailWidth(void) const
|
|
{
|
|
return _trailWidth;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
void PUParticle3DRibbonTrailRender::setTrailWidth(float trailWidth)
|
|
{
|
|
_trailWidth = trailWidth;
|
|
_setWidth = true;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
bool PUParticle3DRibbonTrailRender::isRandomInitialColor(void) const
|
|
{
|
|
return _randomInitialColor;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
void PUParticle3DRibbonTrailRender::setRandomInitialColor(bool randomInitialColour)
|
|
{
|
|
_randomInitialColor = randomInitialColour;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
const Vec4& PUParticle3DRibbonTrailRender::getInitialColor(void) const
|
|
{
|
|
return _initialColor;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
void PUParticle3DRibbonTrailRender::setInitialColor(const Vec4& initialColour)
|
|
{
|
|
_initialColor = initialColour;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
const Vec4& PUParticle3DRibbonTrailRender::getColorChange(void) const
|
|
{
|
|
return _colorChange;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
void PUParticle3DRibbonTrailRender::setColorChange(const Vec4& colourChange)
|
|
{
|
|
_colorChange = colourChange;
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
|
|
void PUParticle3DRibbonTrailRender::prepare()
|
|
{
|
|
if (!_particleSystem)
|
|
return;
|
|
|
|
// Register itself to the technique
|
|
if (_particleSystem)
|
|
{
|
|
// Although it is safe to assume that technique == mParentTechnique, use the mParentTechnique, because the mParentTechnique is
|
|
// also used for unregistering.
|
|
static_cast<PUParticleSystem3D *>(_particleSystem)->addListener(this);
|
|
}
|
|
|
|
_quota = _particleSystem->getParticleQuota();
|
|
if (!_childNode)
|
|
{
|
|
// Create a childnode if not created earlier
|
|
std::stringstream ss;
|
|
ss << this;
|
|
std::string childNodeNodeName = "ParticleUniverse" + ss.str();
|
|
//_childNode = mParentTechnique->getParentSystem()->getParentSceneNode()->createChildSceneNode(childNodeNodeName);
|
|
//_childNode->setInheritOrientation(false);
|
|
auto parent = _particleSystem->getParent();
|
|
if (parent)
|
|
{
|
|
_childNode = Node::create();
|
|
parent->addChild(_childNode);
|
|
}
|
|
}
|
|
|
|
if (_childNode)
|
|
{
|
|
// Create RibbonTrail
|
|
//Ogre::SceneManager* sceneManager = mParentTechnique->getParentSystem()->getSceneManager();
|
|
_trail = new (std::nothrow) PURibbonTrail(_ribbonTrailName, _texFile);
|
|
_trail->setNumberOfChains(_quota);
|
|
_trail->setMaxChainElements(_maxChainElements);
|
|
if (_setLength)
|
|
{
|
|
_trail->setTrailLength(_rendererScale.y * _trailLength);
|
|
}
|
|
else
|
|
{
|
|
_trail->setTrailLength(_rendererScale.y * static_cast<PUParticleSystem3D *>(_particleSystem)->getDefaultHeight());
|
|
}
|
|
_trail->setUseVertexColours(_useVertexColours);
|
|
|
|
// Create number of VisualData objects
|
|
std::string sceneNodeName;
|
|
std::stringstream ss;
|
|
ss << this;
|
|
for (size_t i = 0; i < _quota; i++)
|
|
{
|
|
//sceneNodeName = "ParticleUniverse" + ss.str() + StringConverter::toString(i);
|
|
//RibbonTrailRendererVisualData* visualData =
|
|
// PU_NEW_T(RibbonTrailRendererVisualData, MEMCATEGORY_SCENE_OBJECTS)(_childNode->createChildSceneNode(sceneNodeName), _trail);
|
|
//visualData->node->setInheritOrientation(false);
|
|
auto node = Node::create();
|
|
_childNode->addChild(node);
|
|
PUParticle3DRibbonTrailVisualData* visualData = new (std::nothrow) PUParticle3DRibbonTrailVisualData(node, _trail);
|
|
visualData->index = i;
|
|
_allVisualData.push_back(visualData); // Managed by this renderer
|
|
_visualData.push_back(visualData); // Used to assign to a particle
|
|
if (_randomInitialColor)
|
|
{
|
|
_trail->setInitialColour(i, CCRANDOM_0_1(), CCRANDOM_0_1(), CCRANDOM_0_1());
|
|
}
|
|
else
|
|
{
|
|
_trail->setInitialColour(i, _initialColor);
|
|
}
|
|
_trail->setColourChange(i, _colorChange);
|
|
if (_setWidth)
|
|
{
|
|
_trail->setInitialWidth(i, _rendererScale.x * _trailWidth);
|
|
}
|
|
else
|
|
{
|
|
_trail->setInitialWidth(i, _rendererScale.x * static_cast<PUParticleSystem3D *>(_particleSystem)->getDefaultWidth());
|
|
}
|
|
}
|
|
//_childNode->attachObject(_trail);
|
|
_trail->setAttachedNode(_childNode);
|
|
_trail->setDepthTest(_depthTest);
|
|
_trail->setDepthWrite(_depthWrite);
|
|
}
|
|
}
|
|
|
|
void PUParticle3DRibbonTrailRender::unPrepare()
|
|
{
|
|
destroyAll();
|
|
}
|
|
|
|
void PUParticle3DRibbonTrailRender::updateRender( PUParticle3D *particle, float deltaTime, bool firstParticle )
|
|
{
|
|
if (_trail)
|
|
_trail->update(deltaTime);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
void PUParticle3DRibbonTrailRender::destroyAll(void)
|
|
{
|
|
if (!_particleSystem || !_trail || !_childNode)
|
|
return;
|
|
|
|
// Remove the listener
|
|
static_cast<PUParticleSystem3D *>(_particleSystem)->removeListener(this);
|
|
|
|
// Detach the Ribbontrail
|
|
if (_childNode && _trail)
|
|
{
|
|
_trail->setAttachedNode(nullptr);
|
|
//_childNode->detachObject(_trail);
|
|
}
|
|
|
|
// Delete the Ribbontrail
|
|
CC_SAFE_DELETE(_trail);
|
|
|
|
// Delete the visual data
|
|
std::vector<PUParticle3DRibbonTrailVisualData*>::const_iterator it;
|
|
std::vector<PUParticle3DRibbonTrailVisualData*>::const_iterator itEnd = _allVisualData.end();
|
|
for (it = _allVisualData.begin(); it != itEnd; ++it)
|
|
{
|
|
delete *it;
|
|
}
|
|
|
|
_allVisualData.clear();
|
|
_visualData.clear();
|
|
|
|
// Destroy the children of the childnode, but not the childnode itself, because this gives a delete-order problem
|
|
if (_childNode)
|
|
{
|
|
//_childNode->removeAndDestroyAllChildren();
|
|
_childNode->removeAllChildren();
|
|
if (_childNode->getParent())
|
|
_childNode->getParent()->removeChild(_childNode);
|
|
_childNode = nullptr;
|
|
}
|
|
}
|
|
|
|
|
|
void PUParticle3DRibbonTrailRender::notifyRescaled( const Vec3& scale )
|
|
{
|
|
PUParticle3DRender::notifyRescaled(scale);
|
|
if (_trail)
|
|
{
|
|
// Use the average length (is there a good alternative?
|
|
_trail->setTrailLength(scale.y * _trailLength);
|
|
size_t numberOfChains = _trail->getNumberOfChains();
|
|
for (size_t i = 0; i < numberOfChains; ++i)
|
|
{
|
|
_trail->setInitialWidth(i, scale.x * _trailWidth);
|
|
}
|
|
}
|
|
}
|
|
|
|
PUParticle3DRibbonTrailRender* PUParticle3DRibbonTrailRender::clone()
|
|
{
|
|
auto tr = PUParticle3DRibbonTrailRender::create(_texFile);
|
|
copyAttributesTo(tr);
|
|
return tr;
|
|
}
|
|
|
|
void PUParticle3DRibbonTrailRender::copyAttributesTo( PUParticle3DRender *render )
|
|
{
|
|
PUParticle3DRender::copyAttributesTo(render);
|
|
PUParticle3DRibbonTrailRender *trailRender = static_cast<PUParticle3DRibbonTrailRender*>(render);
|
|
trailRender->setUseVertexColors(_useVertexColours);
|
|
trailRender->setMaxChainElements(_maxChainElements);
|
|
trailRender->setTrailLength(_trailLength);
|
|
trailRender->setTrailWidth(_trailWidth);
|
|
trailRender->setRandomInitialColor(_randomInitialColor);
|
|
trailRender->setInitialColor(_initialColor);
|
|
trailRender->setColorChange(_colorChange);
|
|
}
|
|
|
|
void PUParticle3DRibbonTrailRender::updateParticles( const ParticlePool &pool )
|
|
{
|
|
PUParticle3DRibbonTrailVisualData* visualData = nullptr;
|
|
Vec3 basePosition = static_cast<PUParticleSystem3D *>(_particleSystem)->getDerivedPosition();
|
|
for (auto iter : pool.getActiveDataList())
|
|
{
|
|
auto particle = static_cast<PUParticle3D *>(iter);
|
|
if (!particle->visualData && !_visualData.empty())
|
|
{
|
|
particle->visualData = _visualData.back();
|
|
_visualData.pop_back();
|
|
}
|
|
visualData = static_cast<PUParticle3DRibbonTrailVisualData*>(particle->visualData);
|
|
if (visualData)
|
|
{
|
|
Node* node = visualData->node;
|
|
node->setPosition3D(particle->position);
|
|
|
|
// Set the width of the trail if required
|
|
if (particle->particleType == PUParticle3D::PT_VISUAL)
|
|
{
|
|
if (particle->ownDimensions)
|
|
{
|
|
_trail->setInitialWidth(visualData->index, particle->width);
|
|
}
|
|
}
|
|
visualData->setVisible(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
NS_CC_END
|