266 lines
7.6 KiB
C++
266 lines
7.6 KiB
C++
//////////////////////////////////////////////////////////////////////////////////
|
|
// SPARK particle engine //
|
|
// Copyright (C) 2008-2009 - Julien Fryer - julienfryer@gmail.com //
|
|
// //
|
|
// This software is provided 'as-is', without any express or implied //
|
|
// warranty. In no event will the authors be held liable for any damages //
|
|
// arising from the use of this software. //
|
|
// //
|
|
// Permission is granted to anyone to use this software for any purpose, //
|
|
// including commercial applications, and to alter it and redistribute it //
|
|
// freely, subject to the following restrictions: //
|
|
// //
|
|
// 1. The origin of this software must not be misrepresented; you must not //
|
|
// claim that you wrote the original software. If you use this software //
|
|
// in a product, an acknowledgment in the product documentation would be //
|
|
// appreciated but is not required. //
|
|
// 2. Altered source versions must be plainly marked as such, and must not be //
|
|
// misrepresented as being the original software. //
|
|
// 3. This notice may not be removed or altered from any source distribution. //
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#ifndef H_SPK_QUADRENDERERINTERFACE
|
|
#define H_SPK_QUADRENDERERINTERFACE
|
|
|
|
#include "Core/SPK_DEF.h"
|
|
#include "Core/SPK_Particle.h"
|
|
|
|
namespace SPK
|
|
{
|
|
/**
|
|
* @enum TexturingMode
|
|
* @brief Constants defining the way to apply texture over the particles
|
|
* @since 1.02.00
|
|
*/
|
|
enum TexturingMode
|
|
{
|
|
TEXTURE_NONE, /**< Constant telling no texturing is used */
|
|
TEXTURE_2D, /**< Constant telling a 2D texture is used */
|
|
TEXTURE_3D, /**< Constant telling a 3D texture is used */
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief Base Interface for rendering particles with quads
|
|
* @since 1.04.00
|
|
*/
|
|
class SPK_PREFIX QuadRendererInterface
|
|
{
|
|
public :
|
|
|
|
//////////////////
|
|
// Constructors //
|
|
//////////////////
|
|
|
|
/**
|
|
* @brief Constructor of QuadRendererInterface
|
|
* @param scaleX the scale of the width of the quad
|
|
* @param scaleY the scale of the height of the quad
|
|
*/
|
|
QuadRendererInterface(float scaleX = 1.0f,float scaleY = 1.0f);
|
|
|
|
////////////////
|
|
// Destructor //
|
|
////////////////
|
|
|
|
/** @brief Destructor of QuadRendererInterface */
|
|
virtual inline ~QuadRendererInterface() {}
|
|
|
|
/////////////
|
|
// Setters //
|
|
/////////////
|
|
|
|
/**
|
|
* @brief Sets the texturing mode for this GLQuadRenderer
|
|
*
|
|
* The texturing mode defines whether or not to apply a texture
|
|
* and if so which type of texture to apply (2D,3D or atlas).<br>
|
|
* <br>
|
|
* Note that the validity of the texturing mode depends on the rendering API below.<br>
|
|
* The method returns true if the rendering mode can be set, false if it cannot
|
|
*
|
|
* @param mode : the texturing mode of this GLQuadRenderer
|
|
* @return true if the rendering mode can be set, false if it cannot
|
|
*/
|
|
virtual inline bool setTexturingMode(TexturingMode mode);
|
|
|
|
/**
|
|
* @brief Sets the cut of the texture
|
|
*
|
|
* This is available only if SPK::PARAM_TEXTURE_INDEX is enabled and texturing mode is TEXTURE_2D.<br>
|
|
* <br>
|
|
* Particles can be rendered only with a part of the texture depending on their texture index value.<br>
|
|
* The cut can only be constant.<br>
|
|
* The user defines in how many parts the texture must be divided in X and Y.<br>
|
|
* The first index is located at the top left cut, the it goes from left to right and from top to bottom.<br>
|
|
* <br>
|
|
* For instance a cut with nbX = 3 and nbY = 2 will be as followed :
|
|
* <br><i>
|
|
* -------------<br>
|
|
* | 0 | 1 | 2 |<br>
|
|
* -------------<br>
|
|
* | 3 | 4 | 5 |<br>
|
|
* -------------</i><br>
|
|
* <br>
|
|
* By default nbX and nbY are equal to 1.<br>
|
|
*
|
|
* @param nbX : the number of cuts in the X axis
|
|
* @param nbY : the number of cuts in the Y axis
|
|
*/
|
|
void setAtlasDimensions(size_t nbX,size_t nbY);
|
|
|
|
/**
|
|
* @brief Sets the size ratio of this GLQuadRenderer
|
|
*
|
|
* These values defines how quads are scaled.
|
|
* The height and width of a quad in the universe is defined as followed :
|
|
* <ul>
|
|
* <li><i>width = size * ratioX</i>
|
|
* <li><i>height = size * ratioY</i>
|
|
* </ul>
|
|
*
|
|
* @param scaleX : the scale of the width of the quad
|
|
* @param scaleY : the scale of the height of the quad
|
|
*/
|
|
inline void setScale(float scaleX,float scaleY);
|
|
|
|
/////////////
|
|
// Getters //
|
|
/////////////
|
|
|
|
/**
|
|
* @brief Gets the texturing mode of this GLQuadRenderer
|
|
* @return the texturing mode of this GLQuadRenderer
|
|
*/
|
|
inline TexturingMode getTexturingMode() const;
|
|
|
|
/**
|
|
* @brief Gets the atlas dimension on the X axis
|
|
*
|
|
* See setAtlasDimensions(size_t,size_t) for more information
|
|
*
|
|
* @return the atlas dimension on the X axis
|
|
*/
|
|
inline size_t getAtlasDimensionX() const;
|
|
|
|
/**
|
|
* @brief Gets the atlas dimension on the Y axis
|
|
*
|
|
* See setAtlasDimensions(size_t,size_t) for more information
|
|
*
|
|
* @return the atlas dimension on the Y axis
|
|
*/
|
|
inline size_t getAtlasDimensionY() const;
|
|
|
|
/**
|
|
* @brief Gets the scale of the width of this GLQuadRenderer
|
|
* @return the scale of the width of this GLQuadRenderer
|
|
*/
|
|
inline float getScaleX() const;
|
|
|
|
/**
|
|
* @brief Gets the scale of the height of this GLQuadRenderer
|
|
* @return the scale of the height of this GLQuadRenderer
|
|
*/
|
|
inline float getScaleY() const;
|
|
|
|
protected :
|
|
|
|
TexturingMode texturingMode;
|
|
|
|
float scaleX;
|
|
float scaleY;
|
|
|
|
// texture atlas info
|
|
size_t textureAtlasNbX;
|
|
size_t textureAtlasNbY;
|
|
float textureAtlasW;
|
|
float textureAtlasH;
|
|
|
|
inline void computeAtlasCoordinates(const Particle& particle) const;
|
|
|
|
inline float textureAtlasU0() const;
|
|
inline float textureAtlasU1() const;
|
|
inline float textureAtlasV0() const;
|
|
inline float textureAtlasV1() const;
|
|
|
|
private :
|
|
|
|
// this is where textureAtlas are stored after computation
|
|
mutable float atlasU0;
|
|
mutable float atlasU1;
|
|
mutable float atlasV0;
|
|
mutable float atlasV1;
|
|
};
|
|
|
|
|
|
inline bool QuadRendererInterface::setTexturingMode(TexturingMode mode)
|
|
{
|
|
texturingMode = mode;
|
|
return true;
|
|
}
|
|
|
|
inline void QuadRendererInterface::setScale(float scaleX,float scaleY)
|
|
{
|
|
this->scaleX = scaleX;
|
|
this->scaleY = scaleY;
|
|
}
|
|
|
|
inline TexturingMode QuadRendererInterface::getTexturingMode() const
|
|
{
|
|
return texturingMode;
|
|
}
|
|
|
|
inline size_t QuadRendererInterface::getAtlasDimensionX() const
|
|
{
|
|
return textureAtlasNbX;
|
|
}
|
|
|
|
inline size_t QuadRendererInterface::getAtlasDimensionY() const
|
|
{
|
|
return textureAtlasNbY;
|
|
}
|
|
|
|
inline float QuadRendererInterface::getScaleX() const
|
|
{
|
|
return scaleX;
|
|
}
|
|
|
|
inline float QuadRendererInterface::getScaleY() const
|
|
{
|
|
return scaleY;
|
|
}
|
|
|
|
inline float QuadRendererInterface::textureAtlasU0() const
|
|
{
|
|
return atlasU0;
|
|
}
|
|
|
|
inline float QuadRendererInterface::textureAtlasU1() const
|
|
{
|
|
return atlasU1;
|
|
}
|
|
|
|
inline float QuadRendererInterface::textureAtlasV0() const
|
|
{
|
|
return atlasV0;
|
|
}
|
|
|
|
inline float QuadRendererInterface::textureAtlasV1() const
|
|
{
|
|
return atlasV1;
|
|
}
|
|
|
|
inline void QuadRendererInterface::computeAtlasCoordinates(const Particle& particle) const
|
|
{
|
|
int textureIndex = static_cast<int>(particle.getParamCurrentValue(PARAM_TEXTURE_INDEX));
|
|
atlasU0 = atlasU1 = static_cast<float>(textureIndex % textureAtlasNbX) / textureAtlasNbX;
|
|
atlasV0 = atlasV1 = static_cast<float>(textureIndex / textureAtlasNbY) / textureAtlasNbY;
|
|
atlasU1 += textureAtlasW;
|
|
atlasV1 += textureAtlasH;
|
|
}
|
|
}
|
|
|
|
#endif
|