a1d4bc80c2
Single line comments starting with `///` are interpreted by Microsoft Visual Studio as documentation containing XML code. Therefore single line comments starting with `///<` unfortunately cause a parsing error, as IntelliSense will assume the `<` is the start of an XML tag. This is not the case, but unfortunately, IntelliSense will still complain about the following space character rather than displaying the raw string. This commit alters all such comments to start with `//!<` instead, which prevents the issue. This fixes issue #1622.
216 lines
9.6 KiB
C++
216 lines
9.6 KiB
C++
////////////////////////////////////////////////////////////
|
|
//
|
|
// SFML - Simple and Fast Multimedia Library
|
|
// Copyright (C) 2007-2019 Laurent Gomila (laurent@sfml-dev.org)
|
|
//
|
|
// 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 SFML_BLENDMODE_HPP
|
|
#define SFML_BLENDMODE_HPP
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Headers
|
|
////////////////////////////////////////////////////////////
|
|
#include <SFML/Graphics/Export.hpp>
|
|
|
|
|
|
namespace sf
|
|
{
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Blending modes for drawing
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
struct SFML_GRAPHICS_API BlendMode
|
|
{
|
|
////////////////////////////////////////////////////////
|
|
/// \brief Enumeration of the blending factors
|
|
///
|
|
/// The factors are mapped directly to their OpenGL equivalents,
|
|
/// specified by glBlendFunc() or glBlendFuncSeparate().
|
|
////////////////////////////////////////////////////////
|
|
enum Factor
|
|
{
|
|
Zero, //!< (0, 0, 0, 0)
|
|
One, //!< (1, 1, 1, 1)
|
|
SrcColor, //!< (src.r, src.g, src.b, src.a)
|
|
OneMinusSrcColor, //!< (1, 1, 1, 1) - (src.r, src.g, src.b, src.a)
|
|
DstColor, //!< (dst.r, dst.g, dst.b, dst.a)
|
|
OneMinusDstColor, //!< (1, 1, 1, 1) - (dst.r, dst.g, dst.b, dst.a)
|
|
SrcAlpha, //!< (src.a, src.a, src.a, src.a)
|
|
OneMinusSrcAlpha, //!< (1, 1, 1, 1) - (src.a, src.a, src.a, src.a)
|
|
DstAlpha, //!< (dst.a, dst.a, dst.a, dst.a)
|
|
OneMinusDstAlpha //!< (1, 1, 1, 1) - (dst.a, dst.a, dst.a, dst.a)
|
|
};
|
|
|
|
////////////////////////////////////////////////////////
|
|
/// \brief Enumeration of the blending equations
|
|
///
|
|
/// The equations are mapped directly to their OpenGL equivalents,
|
|
/// specified by glBlendEquation() or glBlendEquationSeparate().
|
|
////////////////////////////////////////////////////////
|
|
enum Equation
|
|
{
|
|
Add, //!< Pixel = Src * SrcFactor + Dst * DstFactor
|
|
Subtract, //!< Pixel = Src * SrcFactor - Dst * DstFactor
|
|
ReverseSubtract //!< Pixel = Dst * DstFactor - Src * SrcFactor
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Default constructor
|
|
///
|
|
/// Constructs a blending mode that does alpha blending.
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
BlendMode();
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Construct the blend mode given the factors and equation.
|
|
///
|
|
/// This constructor uses the same factors and equation for both
|
|
/// color and alpha components. It also defaults to the Add equation.
|
|
///
|
|
/// \param sourceFactor Specifies how to compute the source factor for the color and alpha channels.
|
|
/// \param destinationFactor Specifies how to compute the destination factor for the color and alpha channels.
|
|
/// \param blendEquation Specifies how to combine the source and destination colors and alpha.
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
BlendMode(Factor sourceFactor, Factor destinationFactor, Equation blendEquation = Add);
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \brief Construct the blend mode given the factors and equation.
|
|
///
|
|
/// \param colorSourceFactor Specifies how to compute the source factor for the color channels.
|
|
/// \param colorDestinationFactor Specifies how to compute the destination factor for the color channels.
|
|
/// \param colorBlendEquation Specifies how to combine the source and destination colors.
|
|
/// \param alphaSourceFactor Specifies how to compute the source factor.
|
|
/// \param alphaDestinationFactor Specifies how to compute the destination factor.
|
|
/// \param alphaBlendEquation Specifies how to combine the source and destination alphas.
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
BlendMode(Factor colorSourceFactor, Factor colorDestinationFactor,
|
|
Equation colorBlendEquation, Factor alphaSourceFactor,
|
|
Factor alphaDestinationFactor, Equation alphaBlendEquation);
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Member Data
|
|
////////////////////////////////////////////////////////////
|
|
Factor colorSrcFactor; //!< Source blending factor for the color channels
|
|
Factor colorDstFactor; //!< Destination blending factor for the color channels
|
|
Equation colorEquation; //!< Blending equation for the color channels
|
|
Factor alphaSrcFactor; //!< Source blending factor for the alpha channel
|
|
Factor alphaDstFactor; //!< Destination blending factor for the alpha channel
|
|
Equation alphaEquation; //!< Blending equation for the alpha channel
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \relates BlendMode
|
|
/// \brief Overload of the == operator
|
|
///
|
|
/// \param left Left operand
|
|
/// \param right Right operand
|
|
///
|
|
/// \return True if blending modes are equal, false if they are different
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
SFML_GRAPHICS_API bool operator ==(const BlendMode& left, const BlendMode& right);
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \relates BlendMode
|
|
/// \brief Overload of the != operator
|
|
///
|
|
/// \param left Left operand
|
|
/// \param right Right operand
|
|
///
|
|
/// \return True if blending modes are different, false if they are equal
|
|
///
|
|
////////////////////////////////////////////////////////////
|
|
SFML_GRAPHICS_API bool operator !=(const BlendMode& left, const BlendMode& right);
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Commonly used blending modes
|
|
////////////////////////////////////////////////////////////
|
|
SFML_GRAPHICS_API extern const BlendMode BlendAlpha; //!< Blend source and dest according to dest alpha
|
|
SFML_GRAPHICS_API extern const BlendMode BlendAdd; //!< Add source to dest
|
|
SFML_GRAPHICS_API extern const BlendMode BlendMultiply; //!< Multiply source and dest
|
|
SFML_GRAPHICS_API extern const BlendMode BlendNone; //!< Overwrite dest with source
|
|
|
|
} // namespace sf
|
|
|
|
|
|
#endif // SFML_BLENDMODE_HPP
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// \class sf::BlendMode
|
|
/// \ingroup graphics
|
|
///
|
|
/// sf::BlendMode is a class that represents a blend mode. A blend
|
|
/// mode determines how the colors of an object you draw are
|
|
/// mixed with the colors that are already in the buffer.
|
|
///
|
|
/// The class is composed of 6 components, each of which has its
|
|
/// own public member variable:
|
|
/// \li %Color Source Factor (@ref colorSrcFactor)
|
|
/// \li %Color Destination Factor (@ref colorDstFactor)
|
|
/// \li %Color Blend Equation (@ref colorEquation)
|
|
/// \li Alpha Source Factor (@ref alphaSrcFactor)
|
|
/// \li Alpha Destination Factor (@ref alphaDstFactor)
|
|
/// \li Alpha Blend Equation (@ref alphaEquation)
|
|
///
|
|
/// The source factor specifies how the pixel you are drawing contributes
|
|
/// to the final color. The destination factor specifies how the pixel
|
|
/// already drawn in the buffer contributes to the final color.
|
|
///
|
|
/// The color channels RGB (red, green, blue; simply referred to as
|
|
/// color) and A (alpha; the transparency) can be treated separately. This
|
|
/// separation can be useful for specific blend modes, but most often you
|
|
/// won't need it and will simply treat the color as a single unit.
|
|
///
|
|
/// The blend factors and equations correspond to their OpenGL equivalents.
|
|
/// In general, the color of the resulting pixel is calculated according
|
|
/// to the following formula (\a src is the color of the source pixel, \a dst
|
|
/// the color of the destination pixel, the other variables correspond to the
|
|
/// public members, with the equations being + or - operators):
|
|
/// \code
|
|
/// dst.rgb = colorSrcFactor * src.rgb (colorEquation) colorDstFactor * dst.rgb
|
|
/// dst.a = alphaSrcFactor * src.a (alphaEquation) alphaDstFactor * dst.a
|
|
/// \endcode
|
|
/// All factors and colors are represented as floating point numbers between
|
|
/// 0 and 1. Where necessary, the result is clamped to fit in that range.
|
|
///
|
|
/// The most common blending modes are defined as constants
|
|
/// in the sf namespace:
|
|
///
|
|
/// \code
|
|
/// sf::BlendMode alphaBlending = sf::BlendAlpha;
|
|
/// sf::BlendMode additiveBlending = sf::BlendAdd;
|
|
/// sf::BlendMode multiplicativeBlending = sf::BlendMultiply;
|
|
/// sf::BlendMode noBlending = sf::BlendNone;
|
|
/// \endcode
|
|
///
|
|
/// In SFML, a blend mode can be specified every time you draw a sf::Drawable
|
|
/// object to a render target. It is part of the sf::RenderStates compound
|
|
/// that is passed to the member function sf::RenderTarget::draw().
|
|
///
|
|
/// \see sf::RenderStates, sf::RenderTarget
|
|
///
|
|
////////////////////////////////////////////////////////////
|