API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 27th, 2017
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 15.26 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #pragma once
  3. #include "ParticleManager.h"
  4. #include "TextureLoader.h"
  5. ParticleManager::ParticleSettings ParticleManager::_FOOTSTEPS_PRESET;
  6. ParticleManager::ParticleSettings ParticleManager::_ROCKET_THRUSTER_PRESET;
  7. ParticleManager::ParticleSettings ParticleManager::_TRON_PRESET;
  8. ParticleManager::ParticleSettings ParticleManager::_STAR_PRESET;
  9.  
  10. #pragma comment(lib,"SDL2.lib")
  11. #pragma comment(lib, "SDL2_image.lib")
  12. #pragma comment(lib,"SDL2_gfx.dll")
  13. #pragma comment(lib, "SDL2_gfx.lib")
  14.  
  15.  
  16.  
  17. ParticleManager::ParticleManager(ParticleSettings pSettings, SDL_Renderer * pRenderer)
  18.     :_minTTL(pSettings._minTTL),
  19.     _maxTTL(pSettings._maxTTL),
  20.     _particleSize(pSettings._particleSize),
  21.     _colourLerpingList(pSettings._coloursToLerp),
  22.     _particleVelVariation(pSettings._velVariation),
  23.     _startingVelocity(pSettings._startingVelocity),
  24.     _endingVelocity(pSettings._endingVelocity),
  25.     _shapeType(pSettings._shapeType),
  26.     _emissionRate(pSettings._emissionRate),
  27.     _texture(pSettings._texture),
  28.     _shouldSystemEmit(true),
  29.     _particleList(std::vector<ParticleObj *>()),
  30.     _positionToParentTo(pSettings._positionToParentTo),
  31.     _currentVelocity(0, 0),
  32.     _timeSinceEmit(0),
  33.     _renderer(pRenderer),
  34.     _rotationSpeed(pSettings._rotationSpeed),
  35.     _offset(pSettings._offsetFromParent)
  36. {
  37.     float timeToLiveTotal = 0;
  38.  
  39.     if (_positionToParentTo == nullptr)
  40.         _positionToParentTo = new Vector2(300, 300);
  41.  
  42.     if(_colourLerpingList.size() == 0)
  43.     {
  44.         ColourLerper white = ColourLerper();
  45.         white._colour = { 255,255,255,255 };
  46.         white._durationOfColour = 2;
  47.  
  48.         _colourLerpingList.push_back(white);
  49.     }
  50.  
  51.     if (_minTTL == -1 && _maxTTL == -1)
  52.     {
  53.         for (int i = 0; i < _colourLerpingList.size(); ++i)
  54.         {
  55.             timeToLiveTotal += _colourLerpingList.at(i)._durationOfColour;
  56.         }
  57.  
  58.         _minTTL = timeToLiveTotal - pSettings._timeToLiveVariation;
  59.         _maxTTL = timeToLiveTotal;
  60.     }
  61.  
  62.  
  63.  
  64. }
  65.  
  66.  
  67. void ParticleManager::update(float pDT)
  68. {
  69.  
  70.     Vector2 diff = _position - (*_positionToParentTo + _offset);
  71.  
  72.     if (diff.Length() > 1)
  73.     {
  74.         if (_velocityList.size() < 3)
  75.             _velocityList.push_back(diff);
  76.         else
  77.         {
  78.             _velocityList.insert(_velocityList.begin(), diff);
  79.             _velocityList.pop_back();
  80.         }
  81.         Vector2 totalSpeed = Vector2(0, 0);
  82.         for (int i = 0; i < _velocityList.size(); ++i)
  83.         {
  84.             totalSpeed = totalSpeed + _velocityList.at(i);
  85.         }
  86.  
  87.         _currentVelocity = totalSpeed / static_cast<float>(_velocityList.size());
  88.  
  89.         _position = *_positionToParentTo + _offset;
  90.     }
  91.  
  92.  
  93.     if (_shouldSystemEmit == true)
  94.     {
  95.         _timeSinceEmit += pDT;
  96.  
  97.         while (_timeSinceEmit > _emissionRate)
  98.         {
  99.             SpawnParticle(_currentVelocity.Normalize());
  100.             _timeSinceEmit -= _emissionRate;
  101.         }
  102.     }
  103.  
  104.     for (int i = 0; i < _particleList.size(); i++)
  105.     {
  106.         _particleList[i]->update(pDT);
  107.  
  108.         if (_particleList[i]->readyToRespawn())
  109.         {
  110.             delete _particleList.at(i);
  111.             _particleList.erase(_particleList.begin() + i);
  112.         }
  113.     }
  114. }
  115.  
  116. void ParticleManager::LoadPresets(SDL_Renderer * pRenderer)
  117. {
  118.     _FOOTSTEPS_PRESET = ParticleSettings();
  119.     _FOOTSTEPS_PRESET._particleSize = 25;
  120.     _FOOTSTEPS_PRESET._emissionRate = 0.424f;
  121.     _FOOTSTEPS_PRESET._startingVelocity = 0;
  122.     _FOOTSTEPS_PRESET._endingVelocity = 0;
  123.     _FOOTSTEPS_PRESET._shapeType = Shape::Footsteps;
  124.     _FOOTSTEPS_PRESET._texture = TextureLoader::loadTexture("assets/footsteps.png", pRenderer);
  125.  
  126.     _ROCKET_THRUSTER_PRESET = ParticleSettings();
  127.     _ROCKET_THRUSTER_PRESET._particleSize = 3;
  128.     _ROCKET_THRUSTER_PRESET._emissionRate = 0.005f;
  129.     _ROCKET_THRUSTER_PRESET._startingVelocity = 150;
  130.     _ROCKET_THRUSTER_PRESET._endingVelocity = 0;
  131.     _ROCKET_THRUSTER_PRESET._velVariation = 0.3f;
  132.     _ROCKET_THRUSTER_PRESET._shapeType = Shape::RocketThruster;
  133.  
  134.     _ROCKET_THRUSTER_PRESET._coloursToLerp.clear();
  135.  
  136.     ColourLerper firstLerp;
  137.     firstLerp._colour = { 255, 255, 255, 255 };
  138.     firstLerp._durationOfColour = 0.5f;
  139.     _ROCKET_THRUSTER_PRESET._coloursToLerp.push_back(firstLerp);
  140.  
  141.     ColourLerper secondLerp;
  142.     secondLerp._colour = { 255, 160, 37, 255 };
  143.     secondLerp._durationOfColour = 0.8f;
  144.     _ROCKET_THRUSTER_PRESET._coloursToLerp.push_back(secondLerp);
  145.  
  146.     ColourLerper thirdLerp;
  147.     thirdLerp._colour = { 100, 100, 100, 0 };
  148.     thirdLerp._durationOfColour = 1.2f;
  149.     _ROCKET_THRUSTER_PRESET._coloursToLerp.push_back(thirdLerp);
  150.  
  151.  
  152.     _TRON_PRESET = ParticleSettings();
  153.     _TRON_PRESET._particleSize = 6;
  154.     _TRON_PRESET._emissionRate = 0.001f;
  155.     _TRON_PRESET._startingVelocity = 0;
  156.     _TRON_PRESET._endingVelocity = 0;
  157.     _TRON_PRESET._velVariation = 0.0f;
  158.     _TRON_PRESET._minTTL = 4;
  159.     _TRON_PRESET._maxTTL = 4;
  160.     _TRON_PRESET._shapeType = Shape::Tron;
  161.     _TRON_PRESET._texture = TextureLoader::loadTexture("assets/laser.png", pRenderer);
  162.  
  163.     _STAR_PRESET = ParticleSettings();
  164.     _STAR_PRESET._particleSize = 2.5f;
  165.     _STAR_PRESET._emissionRate = 0.005f;
  166.     _STAR_PRESET._startingVelocity = 150;
  167.     _STAR_PRESET._endingVelocity = 0;
  168.     _STAR_PRESET._minTTL = 2;
  169.     _STAR_PRESET._maxTTL = 4;
  170.     _STAR_PRESET._velVariation = 1;
  171.     _STAR_PRESET._shapeType = Shape::StarPreset;
  172. }
  173. void ParticleManager::LoadPresets(SDL_Texture * footstepsTex)
  174. {
  175.     _FOOTSTEPS_PRESET = ParticleSettings();
  176.     _FOOTSTEPS_PRESET._particleSize = 25;
  177.     _FOOTSTEPS_PRESET._emissionRate = 0.424f;
  178.     _FOOTSTEPS_PRESET._startingVelocity = 0;
  179.     _FOOTSTEPS_PRESET._endingVelocity = 0;
  180.     _FOOTSTEPS_PRESET._shapeType = Shape::Footsteps;
  181.     _FOOTSTEPS_PRESET._texture = footstepsTex;
  182.  
  183.     _ROCKET_THRUSTER_PRESET = ParticleSettings();
  184.     _ROCKET_THRUSTER_PRESET._particleSize = 3;
  185.     _ROCKET_THRUSTER_PRESET._emissionRate = 0.005f;
  186.     _ROCKET_THRUSTER_PRESET._startingVelocity = 150;
  187.     _ROCKET_THRUSTER_PRESET._endingVelocity = 0;
  188.     _ROCKET_THRUSTER_PRESET._velVariation = 0.3f;
  189.     _ROCKET_THRUSTER_PRESET._shapeType = Shape::RocketThruster;
  190.  
  191.     _ROCKET_THRUSTER_PRESET._coloursToLerp.clear();
  192.  
  193.     ColourLerper firstLerp;
  194.     firstLerp._colour = { 255, 255, 255, 255 };
  195.     firstLerp._durationOfColour = 0.5f;
  196.     _ROCKET_THRUSTER_PRESET._coloursToLerp.push_back(firstLerp);
  197.  
  198.     ColourLerper secondLerp;
  199.     secondLerp._colour = { 255, 160, 37, 255 };
  200.     secondLerp._durationOfColour = 0.8f;
  201.     _ROCKET_THRUSTER_PRESET._coloursToLerp.push_back(secondLerp);
  202.  
  203.     ColourLerper thirdLerp;
  204.     thirdLerp._colour = { 100, 100, 100, 0 };
  205.     thirdLerp._durationOfColour = 1.2f;
  206.     _ROCKET_THRUSTER_PRESET._coloursToLerp.push_back(thirdLerp);
  207.  
  208.     _STAR_PRESET = ParticleSettings();
  209.     _STAR_PRESET._particleSize = 2.5f;
  210.     _STAR_PRESET._emissionRate = 0.005f;
  211.     _STAR_PRESET._startingVelocity = 150;
  212.     _STAR_PRESET._endingVelocity = 0;
  213.     _STAR_PRESET._minTTL = 2;
  214.     _STAR_PRESET._maxTTL = 4;
  215.     _STAR_PRESET._velVariation = 1;
  216.     _STAR_PRESET._shapeType = Shape::StarPreset;
  217. }
  218.  
  219. SDL_Color ParticleManager::GetColour(float pAliveTime)
  220. {
  221.     if (_colourLerpingList.size() == 1)
  222.         return _colourLerpingList.at(0)._colour;
  223.  
  224.     float totalTime = 0;
  225.     int indexOfColour = 0;
  226.     while (totalTime < pAliveTime && indexOfColour < _colourLerpingList.size())
  227.     {
  228.         totalTime += _colourLerpingList.at(indexOfColour)._durationOfColour;
  229.         indexOfColour++;
  230.     }
  231.  
  232.     if (indexOfColour == _colourLerpingList.size())
  233.         return{ 0, 0, 0, 0 };
  234.  
  235.     indexOfColour -= 1;
  236.     if (indexOfColour < 0)
  237.         indexOfColour = 0;
  238.  
  239.     float percentThroughThisLerp = 1 - ((totalTime - pAliveTime) / _colourLerpingList.at(indexOfColour)._durationOfColour);
  240.  
  241.     float lerpedR = _colourLerpingList.at(indexOfColour)._colour.r + ((_colourLerpingList.at(indexOfColour + 1)._colour.r - _colourLerpingList.at(indexOfColour)._colour.r)) * percentThroughThisLerp;
  242.     float lerpedG = _colourLerpingList.at(indexOfColour)._colour.g + ((_colourLerpingList.at(indexOfColour + 1)._colour.g - _colourLerpingList.at(indexOfColour)._colour.g)) * percentThroughThisLerp;
  243.     float lerpedB = _colourLerpingList.at(indexOfColour)._colour.b + ((_colourLerpingList.at(indexOfColour + 1)._colour.b - _colourLerpingList.at(indexOfColour)._colour.b)) * percentThroughThisLerp;
  244.     float lerpedA = _colourLerpingList.at(indexOfColour)._colour.a + ((_colourLerpingList.at(indexOfColour + 1)._colour.a - _colourLerpingList.at(indexOfColour)._colour.a)) * percentThroughThisLerp;
  245.  
  246.     return{ static_cast<Uint8>(lerpedR), static_cast<Uint8>(lerpedG), static_cast<Uint8>(lerpedB), static_cast<Uint8>(lerpedA) };
  247. }
  248.  
  249.  
  250. void ParticleManager::render(SDL_Renderer * pRenderer)
  251. {
  252.     if (_renderer == nullptr)
  253.         _renderer = pRenderer;
  254.  
  255.     for (int i = 0; i < _particleList.size(); i++)
  256.     {
  257.         _particleList[i]->render(_renderer);
  258.     }
  259. }
  260.  
  261. void ParticleManager::SpawnParticle(Vector2 pDir)
  262. {
  263.     float randX = (static_cast<float>((rand() % 1000) / 1000.0f) * _particleVelVariation) - _particleVelVariation / 2;
  264.     float randY = (static_cast<float>((rand() % 1000) / 1000.0f) * _particleVelVariation) - _particleVelVariation / 2;
  265.  
  266.     float xVel = (pDir.x - randX) * _startingVelocity;
  267.     float yVel = (pDir.y - randY) * _startingVelocity;
  268.     float endingXVel = (pDir.x - randX) * _endingVelocity;
  269.     float endingYVel = (pDir.y - randY) * _endingVelocity;
  270.  
  271.     Vector2 startingVel = Vector2(xVel, yVel);
  272.     Vector2 endingVel = Vector2(endingXVel, endingYVel);
  273.  
  274.     float timeToLive = (static_cast<float>((rand() % 1000) / 1000.0f) * (_maxTTL - _minTTL)) + _minTTL;
  275.     ParticleObj::ParticleObjSettings settings;
  276.  
  277.     settings._position = _position + _offset;
  278.     settings._size = Vector2(_particleSize, _particleSize);
  279.     settings._startingVelocity = startingVel;
  280.     settings._endingVelocity = endingVel;
  281.     settings._timeToLive = timeToLive;
  282.     settings._shape = nullptr;
  283.     settings._texture = _texture;
  284.  
  285.  
  286.     if (_shapeType != Shape::NULL_SHAPE)
  287.     {
  288.         std::vector<Vector2> vertPositions;
  289.         Shape * shape = nullptr;
  290.  
  291.         float rotSpeed = ((rand() % 1000 / 1000.0f) * _rotationSpeed * 2) - _rotationSpeed;
  292.         float sizeModifier;
  293.         int randomScale;
  294.         switch (_shapeType)
  295.         {
  296.  
  297.         case Shape::Triangle:
  298.  
  299.             sizeModifier = 2.5f;
  300.             vertPositions.push_back(Vector2(0 * _particleSize, -sizeModifier * _particleSize));
  301.             vertPositions.push_back(Vector2(sizeModifier * 2 * _particleSize, -sizeModifier * _particleSize));
  302.             vertPositions.push_back(Vector2(0 * _particleSize, sizeModifier * _particleSize));
  303.  
  304.             shape = new Shape(_position, vertPositions, Shape::ShapeType::Triangle, _renderer, rotSpeed);
  305.  
  306.             break;
  307.  
  308.         case Shape::Square:
  309.  
  310.             sizeModifier = 1.5f;
  311.             vertPositions.push_back(Vector2(-sizeModifier       * _particleSize, -sizeModifier * _particleSize));
  312.             vertPositions.push_back(Vector2(sizeModifier        * _particleSize, -sizeModifier * _particleSize));
  313.             vertPositions.push_back(Vector2(sizeModifier        * _particleSize, sizeModifier * _particleSize));
  314.             vertPositions.push_back(Vector2(-sizeModifier       * _particleSize, sizeModifier * _particleSize));
  315.  
  316.             shape = new Shape(_position, vertPositions, Shape::ShapeType::Square, _renderer, rotSpeed);
  317.             break;
  318.  
  319.         case Shape::Pentagon:
  320.  
  321.             sizeModifier = 1.5f;
  322.             vertPositions.push_back(Vector2(sizeModifier * (0       -1.6f) * _particleSize, sizeModifier * (0       -1.6f) * -_particleSize));
  323.             vertPositions.push_back(Vector2(sizeModifier * (2       -1.6f) * _particleSize, sizeModifier * (0       -1.6f) * -_particleSize));
  324.             vertPositions.push_back(Vector2(sizeModifier * (2.6f    -1.6f) * _particleSize, sizeModifier * (2       -1.6f) * -_particleSize));
  325.             vertPositions.push_back(Vector2(sizeModifier * (1       -1.6f) * _particleSize, sizeModifier * (3.1f    -1.6f) * -_particleSize));
  326.             vertPositions.push_back(Vector2(sizeModifier * (-0.64f  -1.6f) * _particleSize, sizeModifier * (2       -1.6f) * -_particleSize));
  327.  
  328.             shape = new Shape(_position, vertPositions, Shape::ShapeType::Pentagon, _renderer, rotSpeed);
  329.             break;
  330.  
  331.         case Shape::Star:
  332.  
  333.             sizeModifier = 0.4f;
  334.             vertPositions.push_back(Vector2(sizeModifier * 6.5      *       _particleSize, sizeModifier * 0 * -_particleSize));
  335.             vertPositions.push_back(Vector2(sizeModifier * 5 * _particleSize, sizeModifier * 5 * -_particleSize));
  336.             vertPositions.push_back(Vector2(sizeModifier * 0 * _particleSize, sizeModifier * 5.5f   *       -_particleSize));
  337.             vertPositions.push_back(Vector2(sizeModifier * 3.5f     *       _particleSize, sizeModifier * 9 * -_particleSize));
  338.             vertPositions.push_back(Vector2(sizeModifier * 2 * _particleSize, sizeModifier * 14 * -_particleSize));
  339.             vertPositions.push_back(Vector2(sizeModifier * 6.5f     *       _particleSize, sizeModifier * 11.5f *       -_particleSize));
  340.             vertPositions.push_back(Vector2(sizeModifier * 12 * _particleSize, sizeModifier * 14 * -_particleSize));
  341.             vertPositions.push_back(Vector2(sizeModifier * 10.5f    *       _particleSize, sizeModifier * 9 * -_particleSize));
  342.             vertPositions.push_back(Vector2(sizeModifier * 14 * _particleSize, sizeModifier * 5.5f  *       -_particleSize));
  343.             vertPositions.push_back(Vector2(sizeModifier * 9 * _particleSize, sizeModifier * 5 * -_particleSize));
  344.  
  345.  
  346.             shape = new Shape(_position, vertPositions, Shape::ShapeType::Star, _renderer, rotSpeed);
  347.             break;
  348.  
  349.         case Shape::NULL_SHAPE:
  350.             delete shape;
  351.             break;
  352.         case Shape::Footsteps:
  353.             delete shape;
  354.             settings._size = Vector2(_FOOTSTEPS_PRESET._particleSize, _FOOTSTEPS_PRESET._particleSize);
  355.             break;
  356.  
  357.         case Shape::RocketThruster:
  358.  
  359.             settings._size = Vector2(_ROCKET_THRUSTER_PRESET._particleSize, _ROCKET_THRUSTER_PRESET._particleSize);
  360.  
  361.             sizeModifier = 1.5f;
  362.             vertPositions.push_back(Vector2(sizeModifier * 0        * _particleSize, sizeModifier * 0 * -_particleSize));
  363.             vertPositions.push_back(Vector2(sizeModifier * 2        * _particleSize, sizeModifier * 0 * -_particleSize));
  364.             vertPositions.push_back(Vector2(sizeModifier * 2.6f     * _particleSize, sizeModifier * 2 * -_particleSize));
  365.             vertPositions.push_back(Vector2(sizeModifier * 1        * _particleSize, sizeModifier * 3.1f *      -_particleSize));
  366.             vertPositions.push_back(Vector2(sizeModifier * -0.64f   * _particleSize, sizeModifier * 2 * -_particleSize));
  367.  
  368.             shape = new Shape(_position, vertPositions, Shape::ShapeType::Pentagon, _renderer, rotSpeed);
  369.  
  370.  
  371.             break;
  372.  
  373.         case Shape::StarPreset:
  374.  
  375.             settings._size = Vector2(_STAR_PRESET._particleSize, _STAR_PRESET._particleSize);
  376.             randomScale = rand() % 10;
  377.  
  378.             sizeModifier = 0.2f + (0.05f * randomScale);
  379.             vertPositions.push_back(Vector2(sizeModifier * 6.5      *       _particleSize, sizeModifier * 0 * -_particleSize));
  380.             vertPositions.push_back(Vector2(sizeModifier * 5 * _particleSize, sizeModifier * 5 * -_particleSize));
  381.             vertPositions.push_back(Vector2(sizeModifier * 0 * _particleSize, sizeModifier * 5.5f   *       -_particleSize));
  382.             vertPositions.push_back(Vector2(sizeModifier * 3.5f     *       _particleSize, sizeModifier * 9 * -_particleSize));
  383.             vertPositions.push_back(Vector2(sizeModifier * 2 * _particleSize, sizeModifier * 14 * -_particleSize));
  384.             vertPositions.push_back(Vector2(sizeModifier * 6.5f     *       _particleSize, sizeModifier * 11.5f *       -_particleSize));
  385.             vertPositions.push_back(Vector2(sizeModifier * 12 * _particleSize, sizeModifier * 14 * -_particleSize));
  386.             vertPositions.push_back(Vector2(sizeModifier * 10.5f    *       _particleSize, sizeModifier * 9 * -_particleSize));
  387.             vertPositions.push_back(Vector2(sizeModifier * 14 * _particleSize, sizeModifier * 5.5f  *       -_particleSize));
  388.             vertPositions.push_back(Vector2(sizeModifier * 9 * _particleSize, sizeModifier * 5 * -_particleSize));
  389.  
  390.             shape = new Shape(_position, vertPositions, Shape::ShapeType::Star, _renderer, rotSpeed);
  391.  
  392.  
  393.             break;
  394.         case Shape::Tron:
  395.             delete shape;
  396.             settings._size = Vector2(_TRON_PRESET._particleSize, _TRON_PRESET._particleSize);
  397.             break;
  398.  
  399.         default:
  400.  
  401.             break;
  402.         }
  403.  
  404.  
  405.         settings._shape = shape;
  406.     }
  407.  
  408.     settings._direction = pDir;
  409.  
  410.     _particleList.push_back(new ParticleObj(settings, *this));
  411. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!