93 lines
3.2 KiB
C
93 lines
3.2 KiB
C
|
/*
|
||
|
|
** Command & Conquer Generals Zero Hour(tm)
|
||
|
|
** Copyright 2025 Electronic Arts Inc.
|
||
|
|
**
|
||
|
|
** This program is free software: you can redistribute it and/or modify
|
||
|
|
** it under the terms of the GNU General Public License as published by
|
||
|
|
** the Free Software Foundation, either version 3 of the License, or
|
||
|
|
** (at your option) any later version.
|
||
|
|
**
|
||
|
|
** This program is distributed in the hope that it will be useful,
|
||
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
** GNU General Public License for more details.
|
||
|
|
**
|
||
|
|
** You should have received a copy of the GNU General Public License
|
||
|
|
** along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
*/
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
// Copyright (C) 2003, 2004 Electronic Arts
|
||
|
|
//
|
||
|
|
// ParabolicEase.h
|
||
|
|
// Ease in and out based on a parabolic function.
|
||
|
|
// Author: Robert Minsk May 12, 2003
|
||
|
|
// ============================================================================
|
||
|
|
#pragma once
|
||
|
|
#ifndef _PARABOLICEASE_H
|
||
|
|
#define _PARABOLICEASE_H
|
||
|
|
// ============================================================================
|
||
|
|
#include "Lib/BaseType.h"
|
||
|
|
// ============================================================================
|
||
|
|
/// Ease in and out based on a linear velocity.
|
||
|
|
/**
|
||
|
|
* This ends up being a function that is parabolic at both ends and a linear
|
||
|
|
* middle section with respect to position.
|
||
|
|
*
|
||
|
|
* velocity(0.0) = 0.0
|
||
|
|
* velocity(in) = v0
|
||
|
|
* velocity(out) = v0
|
||
|
|
* velocity(1.0) = 0.0
|
||
|
|
*
|
||
|
|
* From 0.0->in velocity is linearly increasing.
|
||
|
|
* From out->1.0 velocity is linearly decreasing.
|
||
|
|
*
|
||
|
|
* velocity(t) = v0*t/in t = [0, in] Linear increasing segment
|
||
|
|
* = v0 t = (in, out] Constant segment
|
||
|
|
* = (1-t)*v0/(1-out) t = (out, 1.0] Linear decreasing segment
|
||
|
|
*
|
||
|
|
* We need to calculate v0. We want the total distance covered to be 1.0.
|
||
|
|
*
|
||
|
|
* 1 = integral(velocity(t), 0, 1)
|
||
|
|
* 1 = integral(velocity(t), 0, in) +
|
||
|
|
* integral(velocity(t), in, out) +
|
||
|
|
* integral(velocity(t), out, 1.0)
|
||
|
|
* 1 = v0*in/2 + v0*(out - in) + v0*(1 - out)/2
|
||
|
|
* = v0*(out-in+1)/2
|
||
|
|
* v0 = 2/(out-in+1)
|
||
|
|
*
|
||
|
|
* Now we can calculate the distance function.
|
||
|
|
*
|
||
|
|
* d(0->in) = integral(velocity(t), 0, s)
|
||
|
|
* = v0*s*s/(2*in)
|
||
|
|
* d(in->out) = d(0->in) + integral(velocity(t), in, s)
|
||
|
|
* = (v0*in/2) + (v0*(s - in))
|
||
|
|
* d(out->1) = d(0->in) + d(in->out) + integral(velocity(t), out, s)
|
||
|
|
* = (v0*in/2) + (v0*(out - in)) + (s-s*s/2-out+out*out/2)*v0/(1-out)
|
||
|
|
*/
|
||
|
|
class ParabolicEase
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
explicit ParabolicEase(Real easeInTime = 0.0f, Real easeOutTime = 0.0f)
|
||
|
|
{ setEaseTimes(easeInTime, easeOutTime); }
|
||
|
|
|
||
|
|
/// Initialize the ease-in/ease-out function.
|
||
|
|
/**
|
||
|
|
* \param easeInTime/\param easeOutTime is the amount of time to
|
||
|
|
* accomplish the transition. The time is normalized from 0 to 1.
|
||
|
|
*/
|
||
|
|
void setEaseTimes(Real easeInTime, Real easeOutTime);
|
||
|
|
|
||
|
|
/// Evaluate the ease-in/ease-out function at time \param param.
|
||
|
|
/**
|
||
|
|
* \param param is normalized from 0 to 1.
|
||
|
|
*/
|
||
|
|
Real operator ()(Real param) const;
|
||
|
|
|
||
|
|
private:
|
||
|
|
Real m_in, m_out;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ============================================================================
|
||
|
|
#endif // _PARABOLICEASE_H
|