ObjectCollisionConvexHull.cc

#include "ObjectCollisionConvexHull.hh"
 
namespace Field {
 
ObjectCollisionConvexHull::ObjectCollisionConvexHull(const std::span<const EGG::Vector3f> &points)
    : ObjectCollisionConvexHull(points.size()) {
    m_worldRadius = 70.0f;
 
    for (size_t i = 0; i < points.size(); ++i) {
        m_points[i] = points[i];
    }
}
 
ObjectCollisionConvexHull::~ObjectCollisionConvexHull() {
    delete[] m_points.data();
    delete[] m_worldPoints.data();
}
 
void ObjectCollisionConvexHull::transform(const EGG::Matrix34f &mat, const EGG::Vector3f &scale,
        const EGG::Vector3f &speed) {
    m_translation = speed;
 
    if (scale.x == 0.0f) {
        for (size_t i = 0; i < m_points.size(); ++i) {
            m_worldPoints[i] = mat.ps_multVector(m_points[i]);
        }
    } else {
        EGG::Matrix34f temp;
        temp.makeS(scale);
        temp = mat.multiplyTo(temp);
 
        for (size_t i = 0; i < m_points.size(); ++i) {
            m_worldPoints[i] = temp.ps_multVector(m_points[i]);
        }
    }
}
 
const EGG::Vector3f &ObjectCollisionConvexHull::getSupport(const EGG::Vector3f &v) const {
    const EGG::Vector3f *result = &m_worldPoints[0];
    f32 maxDot = v.dot(*result);
 
    for (size_t i = 1; i < m_worldPoints.size(); ++i) {
        const auto &iter = m_worldPoints[i];
        f32 iterDot = v.dot(iter);
 
        if (maxDot < iterDot) {
            result = &iter;
            maxDot = iterDot;
        }
    }
 
    return *result;
}
 
ObjectCollisionConvexHull::ObjectCollisionConvexHull(size_t count) {
    ASSERT(count < 0x100);
 
    m_points = std::span<EGG::Vector3f>(new EGG::Vector3f[count], count);
    m_worldPoints = std::span<EGG::Vector3f>(new EGG::Vector3f[count], count);
}
 
} // namespace Field