Particle.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
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.
 
Library: NDEVR
File: NDEVRPCH
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "Base/Headers/Vertex.hpp"
#include "Base/Headers/VectorFunctions.hpp"
#include "Base/Headers/Buffer.hpp"
#define SimpleParticle 1
namespace NDEVR
{
    /* Some physics constants */
    constexpr fltp04 damping_factor = 0.01f; // how much to damp the cloth simulation each frame
#define MAX_INF    9999999999.0f
#define MIN_INF    -9999999999.0f
 
/*
Initially, we have to make modifications of particle positions for each constraint(constraintTimes = rigidness), However, to save computation time, we
precomputed the total displacement of a particle for all constraintTimes.
For singleMove1, which means one of the two particles is unmovable, then we move the other one only:
if constraintTimes = 0: singleMove1 = 0
if constraintTimes = 1: singleMove1 = 0.3, i.e., each time we move 0.3 (scale factor of the total distance) for a particle towards the other one
if constraintTimes = 2: singleMove1 = (1-0.3)*0.3+0.3 = 0.51
if constraintTimes = 3: singleMove1 = (1-0.51)*0.3+0.51 = 0.657
...
 
For doubleMove1, we move both of the two particles towards each other.
if constraintTimes = 0: singleMove2 = 0
if constraintTimes = 1: singleMove2 = 0.3, i.e., each time we move 0.3 (scale factor of the total distance) for the two particles towards each other
if constraintTimes = 2: singleMove2 = (1-0.3*2)*0.3+0.3 = 0.42
if constraintTimes = 3: singleMove2 = (1-0.42*2)*0.3+0.42 = 0.468
...
 
*/
    const fltp04 singleMove1[15] = { 0, 0.3f, 0.51f, 0.657f, 0.7599f, 0.83193f, 0.88235f, 0.91765f, 0.94235f, 0.95965f, 0.97175f, 0.98023f, 0.98616f, 0.99031f, 0.99322f };
    const fltp04 doubleMove1[15] = { 0, 0.3f, 0.42f, 0.468f, 0.4872f, 0.4949f, 0.498f, 0.4992f, 0.4997f, 0.4999f, 0.4999f, 0.5f, 0.5f, 0.5f, 0.5f };
    class Particle : public Vertex<3, fltp04>
    {
    public:
        Particle(const Vector<3, fltp04>& pos)
            : Vertex<3, fltp04>(pos)
#ifndef SimpleParticle
            , mass(1)
            , acceleration(Vector<3, fltp04>(0, 0, 0))
            , old_pos(pos)
#else
            , old_pos(pos[Z])
#endif
            , movable(true)
            
        {}
 
        Particle()
            : Vertex<3, fltp04>(0, 0, 0)
#ifndef SimpleParticle
            , mass(1)
            , acceleration(Vector<3, fltp04>(0, 0, 0))
#endif
            //, accumulated_normal(Vector<3, fltp04>(0, 0, 0))
            , old_pos(0.0f)
            , movable(true)
        {}
 
 
        bool isMovable() const
        {
            return movable;
        }
 
        
 
        /* This is one of the important methods, where the time is
         * progressed a single step size (TIME_STEPSIZE) The method is
         * called by Cloth.time_step()*/
        inline void timeStep(fltp04 time, const Vector<3, fltp04>& acceleration)
        {
            constexpr fltp04 local_damping = (1.0f - damping_factor);
#ifdef SimpleParticle
            fltp04 temp = (*this)[Z];
            (*this)[Z] += ((*this)[Z] - old_pos) * local_damping + acceleration[Z] * time;
            old_pos = temp;
#else
            Vector<3, fltp04> temp = *this;
            (*this) += ((*this) - old_pos) * (1.0f - DAMPING) + acceleration * time;
            old_pos = temp;
#endif
        }
 
#ifndef SimpleParticle
        void resetAcceleration()
        {
            acceleration = Vector<3, fltp04>(0, 0, 0);
        }
        void addForce(const Vector<3, fltp04>& f)
        {
            acceleration += f / mass;
        }
#endif
        void makeUnmovable()
        {
            movable = false;
        }
        // These two members are used in the process of edge smoothing after
        // the cloth simulation step.
        // the position of the particle in the previous time step, used as
        // part of the verlet numerical integration scheme
        
#ifndef SimpleParticle
        Vector<3, fltp04> acceleration;
        Vector<3, fltp04> old_pos;
        fltp04 time_step2;
        fltp04 mass;
#else
        fltp04 old_pos;
#endif
        //Vector<3, fltp04> accumulated_normal; // an accumulated normal (i.e. non normalized), used for OpenGL soft shading
        
        bool movable;            // can the particle move or not ? used to pin parts of the cloth
    };
    template<> inline const Particle Constant<Particle>::Invalid = Particle();
}