/* ----------------------------------------------------------------------------- This source file is part of OGRE (Object-oriented Graphics Rendering Engine) For the latest info, see http://www.ogre3d.org/ Copyright (c) 2000-2014 Torus Knot Software Ltd 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. ----------------------------------------------------------------------------- */ #ifndef __PredefinedControllers_H__ #define __PredefinedControllers_H__ #include "OgrePrerequisites.h" #include "OgreCommon.h" #include "OgreController.h" #include "OgreFrameListener.h" #include "OgreHeaderPrefix.h" namespace Ogre { /** \addtogroup Core * @{ */ /** \addtogroup Animation * @{ */ //----------------------------------------------------------------------- // Controller Values //----------------------------------------------------------------------- /** Predefined controller value for getting the latest frame time. */ class _OgreExport FrameTimeControllerValue : public ControllerValue, private FrameListener { private: Real mFrameTime; Real mTimeFactor; Real mElapsedTime; Real mFrameDelay; bool frameStarted(const FrameEvent &evt) override; public: /// @deprecated use create() FrameTimeControllerValue(); static ControllerValueRealPtr create() { return std::make_shared(); } float getValue(void) const override { return mFrameTime; } void setValue(float value) override { /* Do nothing - value is set from frame listener */ } Real getTimeFactor(void) const { return mTimeFactor; } /// @copydoc ControllerManager::setTimeFactor void setTimeFactor(Real tf); Real getFrameDelay(void) const { return mFrameDelay; } /// @copydoc ControllerManager::setFrameDelay void setFrameDelay(Real fd); Real getElapsedTime(void) const { return mElapsedTime; } void setElapsedTime(Real elapsedTime) { mElapsedTime = elapsedTime; } }; //----------------------------------------------------------------------- /** Predefined controller value for getting / setting the frame number of a texture layer */ class _OgreExport TextureFrameControllerValue : public ControllerValue { private: TextureUnitState* mTextureLayer; public: /// @deprecated use create() TextureFrameControllerValue(TextureUnitState* t); static ControllerValueRealPtr create(TextureUnitState* t) { return std::make_shared(t); } /** Gets the frame number as a parametric value in the range [0,1] */ float getValue(void) const override; /** Sets the frame number as a parametric value in the range [0,1]; the actual frame number is (value * numFrames) % numFrames). */ void setValue(float value) override; }; //----------------------------------------------------------------------- /** Predefined controller value for getting / setting a texture coordinate modifications (scales and translates). Effects can be applied to the scale or the offset of the u or v coordinates, or both. If separate modifications are required to u and v then 2 instances are required to control both independently, or 4 if you want separate u and v scales as well as separate u and v offsets. @par Because of the nature of this value, it can accept values outside the 0..1 parametric range. */ class _OgreExport TexCoordModifierControllerValue : public ControllerValue { private: bool mTransU, mTransV; bool mScaleU, mScaleV; bool mRotate; TextureUnitState* mTextureLayer; public: /// @deprecated use create TexCoordModifierControllerValue(TextureUnitState* t, bool translateU = false, bool translateV = false, bool scaleU = false, bool scaleV = false, bool rotate = false ); /** Constructor. @param t TextureUnitState to apply the modification to. @param translateU If true, the u coordinates will be translated by the modification. @param translateV If true, the v coordinates will be translated by the modification. @param scaleU If true, the u coordinates will be scaled by the modification. @param scaleV If true, the v coordinates will be scaled by the modification. @param rotate If true, the texture will be rotated by the modification. */ static ControllerValueRealPtr create(TextureUnitState* t, bool translateU = false, bool translateV = false, bool scaleU = false, bool scaleV = false, bool rotate = false) { return std::make_shared(t, translateU, translateV, scaleU, scaleV, rotate); } float getValue(void) const override; void setValue(float value) override; }; //----------------------------------------------------------------------- /** Predefined controller value for setting a single floating- point value in a constant parameter of a vertex or fragment program. Any value is accepted, it is propagated into the 'x' component of the constant register identified by the index. If you need to use named parameters, retrieve the index from the param object before setting this controller up. @note Retrieving a value from the program parameters is not currently supported, therefore do not use this controller value as a source, only as a target. */ class _OgreExport FloatGpuParameterControllerValue : public ControllerValue { private: /// The parameters to access GpuProgramParametersSharedPtr mParams; /// The index of the parameter to be read or set size_t mParamIndex; public: /// @deprecated use create() FloatGpuParameterControllerValue(const GpuProgramParametersSharedPtr& params, size_t index); /** Constructor. @param params The parameters object to access @param index The index of the parameter to be set */ static ControllerValueRealPtr create(const GpuProgramParametersSharedPtr& params, size_t index) { return std::make_shared(params, index); } float getValue(void) const override; void setValue(float value) override; }; //----------------------------------------------------------------------- // Controller functions //----------------------------------------------------------------------- /** Predefined controller function which just passes through the original source directly to dest. */ class _OgreExport PassthroughControllerFunction : public ControllerFunction { public: /// @deprecated use create() PassthroughControllerFunction(bool deltaInput = false); /// @copydoc ControllerFunction::ControllerFunction static ControllerFunctionRealPtr create(bool deltaInput = false) { return std::make_shared(deltaInput); } float calculate(float source) override; }; /** Predefined controller function for dealing with animation. */ class _OgreExport AnimationControllerFunction : public ControllerFunction { private: Real mSeqTime; Real mTime; public: /// @deprecated use create() AnimationControllerFunction(Real sequenceTime, Real timeOffset = 0.0f); /** Constructor. @param sequenceTime The amount of time in seconds it takes to loop through the whole animation sequence. @param timeOffset The offset in seconds at which to start (default is start at 0) */ static ControllerFunctionRealPtr create(Real sequenceTime, Real timeOffset = 0.0f) { return std::make_shared(sequenceTime, timeOffset); } float calculate(float source) override; /** Set the time value manually. */ void setTime(Real timeVal); /** Set the sequence duration value manually. */ void setSequenceTime(Real seqVal); }; //----------------------------------------------------------------------- /** Predefined controller function which simply scales an input to an output value. */ class _OgreExport ScaleControllerFunction : public ControllerFunction { private: Real mScale; public: /// @deprecated use create() ScaleControllerFunction(Real scalefactor, bool deltaInput); /** Constructor, requires a scale factor. @param scalefactor The multiplier applied to the input to produce the output. @param deltaInput If true, signifies that the input will be a delta value such that the function should add it to an internal counter before calculating the output. */ static ControllerFunctionRealPtr create(Real scalefactor, bool deltaInput = false) { return std::make_shared(scalefactor, deltaInput); } float calculate(float source) override; }; //----------------------------------------------------------------------- /** Predefined controller function based on a waveform. A waveform function translates parametric input to parametric output based on a wave. @par Note that for simplicity of integration with the rest of the controller insfrastructure, the output of the wave is parametric i.e. 0..1, rather than the typical wave output of [-1,1]. To compensate for this, the traditional output of the wave is scaled by the following function before output: @par output = (waveoutput + 1) * 0.5 @par Hence a wave output of -1 becomes 0, a wave output of 1 becomes 1, and a wave output of 0 becomes 0.5. */ class _OgreExport WaveformControllerFunction : public ControllerFunction { private: WaveformType mWaveType; Real mBase; Real mFrequency; Real mPhase; Real mAmplitude; Real mDutyCycle; /** Overridden from ControllerFunction. */ Real getAdjustedInput(Real input); public: /// @deprecated use create() WaveformControllerFunction(WaveformType wType, Real base = 0, Real frequency = 1, Real phase = 0, Real amplitude = 1, bool deltaInput = true, Real dutyCycle = 0.5); /** Default constructor, requires at least a wave type, other parameters can be defaulted unless required. @param wType the shape of the wave @param base the base value of the output from the wave @param frequency the speed of the wave in cycles per second @param phase the offset of the start of the wave, e.g. 0.5 to start half-way through the wave @param amplitude scales the output so that instead of lying within [0,1] it lies within [0,1] * amplitude @param deltaInput If true, signifies that the input will be a delta value such that the function should add it to an internal counter before calculating the output. @param dutyCycle Used in PWM mode to specify the pulse width. */ static ControllerFunctionRealPtr create(WaveformType wType, Real base = 0, Real frequency = 1, Real phase = 0, Real amplitude = 1, bool deltaInput = true, Real dutyCycle = 0.5) { return std::make_shared(wType, base, frequency, phase, amplitude, deltaInput, dutyCycle); } float calculate(float source) override; }; //----------------------------------------------------------------------- /** Predefined controller function based on linear function interpolation. */ class _OgreExport LinearControllerFunction : public ControllerFunction { Real mFrequency; std::vector mKeys; std::vector mValues; public: /// @deprecated use create() LinearControllerFunction(const std::vector& keys, const std::vector& values, Real frequency = 1, bool deltaInput = true); /** Constructor, requires keys and values of the function to interpolate For simplicity and compatibility with the predefined ControllerValue classes the function domain must be [0,1]. However, you can use the frequency parameter to rescale the domain to a different range. @param keys the x-values of the function sampling points. Value range is [0,1]. Must include at least the keys 0 and 1. @param values the function values f(x) of the function. order must match keys @param frequency the speed of the evaluation in cycles per second @param deltaInput If true, signifies that the input will be a delta value such that the function should add it to an internal counter before calculating the output. @note there must be the same amount of keys and values */ static ControllerFunctionRealPtr create(const std::vector& keys, const std::vector& values, Real frequency = 1, bool deltaInput = true) { return std::make_shared(keys, values, frequency, deltaInput); } float calculate(float source) override; }; //----------------------------------------------------------------------- /** @} */ /** @} */ } #include "OgreHeaderSuffix.h" #endif