SIM/SIM_SweptCollisionUtility.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Michiel Hagedoorn
 *      Side Effects Software Inc.
 *      477 Richmond Street West, Suite 1001
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * This module contains convenient interfaces for using
 * the swept collision code with SIM_Object and SIM_Geometry objects.
 * The code in SIM_SweptCollision itself does not depend on any
 * SIM-specific objects; it could be re-used for collisions in POPS.
 */

#ifndef __SIM_SweptCollisionUtility_h__
#define __SIM_SweptCollisionUtility_h__

#include "SIM_API.h"
#include "SIM_SweptCollisionData.h"
#include <vector>

class SIM_Engine;
class SIM_Object;
class SIM_Impacts;
class SIM_Geometry;
class SIM_GeometryCopy;
class SIM_Time;
class UT_DMatrix4;
class UT_Vector3;

//////////////////////////////////////////////////////////////////////////////
//
// Data structures for merging geometry from an array of SIM_Objects
//
//////////////////////////////////////////////////////////////////////////////

inline bool SIMisValidIndex(const int i, const int n)
{
    return (0 <= i) && (i < n);
}

// Identifies a point:
// the object index it belongs to and the point-id for that geometry
struct SIM_API SIM_MergedIdentityPoint
{
    SIM_MergedIdentityPoint() :
        myIndexObject(-1),
        myPid(-1)
    {
    }

    // Index in std::vector of SIM_Object
    int myIndexObject;
    // point-id relative to object
    int myPid;
};

// MergedPoints represents a set of points that belong to 
// a sequence of objects
class SIM_API SIM_MergeMap
{
public:
    // For a merged point, obtain the object index and object point index (pid)
    void getObjectAndPid(int& index_object, int& pid, const int p) const
    {
        UT_ASSERT( (0 <= p) && (p < myIdentities.size()) );

        const SIM_MergedIdentityPoint& id(myIdentities[p]);
        index_object = id.myIndexObject;
        pid = id.myPid;
    }

    // Number of merged points (total for all objects)
    inline int getNumPointsMerged() const
    {
        return myIdentities.size();
    }

private:
    // Joint array of point identities for object sequence
    std::vector<SIM_MergedIdentityPoint> myIdentities;
    // Contiguous index range [first, second) for each geometry index
    std::vector< std::pair< int, int > > myRanges;

    friend void SIM_API
    SIMmergePoints(
        SIM_MergeMap& merged_points,
        const std::vector<const SIM_Geometry*>& geometries
    );

    friend class SIM_MergeMapObject;
};

// Get a map for a fixed object that maps local point indices (pids)
// to indices for the merged points.
// This is map only valid as long as the SIM_MergeMap object
// that is was created from still exists unchanged.
class SIM_API SIM_MergeMapObject
{
public:
    SIM_MergeMapObject(
        const SIM_MergeMap& merged_points,
        const int index_object
    ) :
        myIdentities(merged_points.myIdentities),
        myBegin(merged_points.myRanges[index_object].first),
        myEnd(merged_points.myRanges[index_object].second)
    {
        UT_ASSERT( 0 <= index_object );
        UT_ASSERT( index_object < merged_points.myRanges.size() );
    }

    // Get merged point index from object point index (pid)
    // Return -1 if the pid isn't merged.
    inline int getP(const int pid) const
    {
        UT_ASSERT( (0 <= pid) && (pid < myEnd - myBegin) );

        return myBegin + pid;
    }

    inline int getNumPointsObject() const
    {
        return myEnd - myBegin;
    }

    inline int getNumPointsMerged() const
    {
        return myEnd - myBegin;
    }

private:
    const std::vector<SIM_MergedIdentityPoint>& myIdentities;
    const int myBegin;
    const int myEnd;

    // Disallow
    SIM_MergeMapObject(const SIM_MergeMapObject&);
    SIM_MergeMapObject operator=(const SIM_MergeMapObject&);
};

//////////////////////////////////////////////////////////////////////////////
//
// Extract merged position, velocity, mass and thickness from 
// an array of SIM_Objects
//
//////////////////////////////////////////////////////////////////////////////

// Construct merged array of points for an array of geometries.
void SIM_API
SIMmergePoints(
    SIM_MergeMap& merged_points,
    const std::vector<const SIM_Geometry*>& geometries
);

// Extract the triangle connectivity for merged geometries.
extern void SIM_API
SIMextractTriangleConnectivityMerged(
    SIM_TriangleConnectivity& triangles,
    const SIM_MergeMap& merged_points,
    const std::vector<const SIM_Geometry*>& geometries
);

// Extract the geometry and the corresponding transform from an object.
// The resulting (transform, geometry) pairs can be used with 
// SIMextractPositionPoints and SIMextractPositionTriangles
extern bool SIM_API
SIMgetGeometryAndTransform(
    const SIM_Geometry*& geometry,
    UT_DMatrix4& geometry_to_sim,
    const SIM_Object& object
);

// Extract the geometry and the corresponding transform
// that correspond to time t. Return false if this information
// couldn't be extracted from updated_object.
// This assumes that substep objects are set up correctly.
// (This is not the case for particle fluid objects, which
// store the substep positions in the final end state object).
// The resulting (transform, geometry) pairs can be used with 
// SIMextractPositionPoints and SIMextractPositionTriangles
extern bool SIM_API
SIMgetGeometryAndTransformAtTime(
    const SIM_Geometry*& geometry,
    UT_DMatrix4& geometry_to_sim,
    const SIM_Engine& engine,
    const SIM_Object& undated_object,
    const SIM_Time& t
);

// Extract merged point thickness array for a set of point-set objects
// (e.g., particle objects). The thickness is taken from the "pscale"
// attribute, if this attribute is present. If there is no "pscale" attribute,
// then default_thickness is used.
extern void SIM_API
SIMreadThicknessPoints(
    std::vector<fpreal>& thickness_points,
    const SIM_MergeMap& merged_points, 
    const std::vector<const SIM_Geometry*>& geometries_end,
    const fpreal default_thickness 
);

//////////////////////////////////////////////////////////////////////////////
//
// Extract merged swept-collision state from an array of SIM_Objects
//
//////////////////////////////////////////////////////////////////////////////

class SIM_Position;
class SIM_Object;
class SIM_Engine;

// Read from a set of objects all data that is needed for
// swept-collision detection. 
// This assumes that substep objects have been set up correctly:
// engine.getObjectAtTime(object, t_start) and
// engine.getObjectAtTime(object, t_end) must give the correct
// states for the substep times t_start and t_end, respectively.
// The extracted topological and spatial data can be used as
// inputs for SIMdetectAndResolveCollisions
// The pscale attribute is used to initialize the thickness for each point.
// If this attribute is absent, then default_thickness is used
extern void SIM_API
SIMreadSweptState(
    SIM_MergeMap& merged_points,
    std::vector<int>& id_objects,
    std::vector<fpreal>& thickness_points,
    SIM_PositionPoints& position_points_start,
    SIM_PositionPoints& position_points_end,
    SIM_VelocityPoints& velocity_points_end,
    const SIM_Engine& engine,
    const std::vector<const SIM_Object*>& objects,
    const fpreal default_thickness,
    const fpreal t_start,
    const fpreal t_end
);

extern void SIM_API
SIMextractTriangleConnectivityMerged(
    SIM_TriangleConnectivity& triangles,
    const SIM_MergeMap& merged_points,
    const std::vector<const SIM_Object*>& objects
);

//////////////////////////////////////////////////////////////////////////////
//
// Read/Write merged position and merged velocity for an array
// of SIM_Objects
//
//////////////////////////////////////////////////////////////////////////////

// Read the merged position sequence for a set of points
// that belong to geometries.
extern void SIM_API
SIMreadPositionPoints(
    SIM_PositionPoints& position_points, 
    const SIM_MergeMap& merged_points,
    const std::vector<UT_DMatrix4>& transforms,
    const std::vector<const SIM_Geometry*>& geometries
);

// Extract the merged position sequence and the merged velocity sequence
// for a set of points that belong to geometries.
extern void SIM_API
SIMreadPositionAndVelocityPoints(
    SIM_PositionPoints& position_points, 
    SIM_VelocityPoints& velocity_points, 
    const SIM_MergeMap& merged_points,
    const std::vector<UT_DMatrix4>& transforms,
    const std::vector<const SIM_Geometry*>& geometries
);

// Set the position and velocity for all points in an array of geometries.
// position_points is written to the point positions
// velocity_points is written to the velocity attribute "v"
// it is assumed that for geometry[i], the map from object space to
// world simulation space is given by transforms[i].
// The a merged positions and velocities are transformed into 
// the geometry's object space when they're applied to a point.
extern void SIM_API
SIMwritePositionAndVelocityPoints(
    const std::vector<SIM_GeometryCopy*>& geometries,
    const SIM_MergeMap& merged_points,
    const SIM_PositionPoints& position_points,
    const SIM_VelocityPoints& velocity_points,
    const std::vector<UT_DMatrix4>& transforms
);

// Read the previous positions for all objects from the previous-position
// attribute. The attribute stores the position in world coordinates
// (no transform). Elements in r_points for points that don't have
// the attribute will retain the values from before the call.
extern void SIM_API
SIMreadPreviousPositionAttribute(
    SIM_PositionPoints& position_points,
    const SIM_MergeMap& merge_map, 
    const std::vector<const SIM_Geometry*>& geometries_end
);

// Store the previous positions for all objects to the previous-position
// attribute. The attribute stores the position in world coordinates
// (no transform). Elements in r_points for points that don't have
// the attribute will not have their values written.
extern void SIM_API
SIMwritePreviousPositionAttribute(
    std::vector<SIM_GeometryCopy*>& geometries_end,
    const SIM_MergeMap& merge_map,
    const SIM_PositionPoints& position_points
);

//////////////////////////////////////////////////////////////////////////////
//
// Detect collisions, resolve collisions, and generate impacts for 
// an array of SIM_Objects.
//
//////////////////////////////////////////////////////////////////////////////

// This function detects collisions and generates impacts for
// a pair of objects (a, b).
// that aim to resolve the collisions.
extern bool SIM_API
SIMdetectCollisionsAndGenerateImpulses(
    SIM_Impacts* impacts_a,
    SIM_Impacts* impacts_b,
    const SIM_Engine& engine,
    const SIM_Object*const undated_object_a,
    const SIM_Object*const undated_object_b,
    const SIM_Time& t_start,
    const SIM_Time& t_end,
    const int impact_flags
);

#endif

---