PhysXActor.cpp

Go to the documentation of this file.

 
 
#include "Headers/PhysXActor.h"
 
#include "ECS/Components/Headers/RigidBodyComponent.h"
#include "Physics/Headers/PXDevice.h"
 
namespace Divide {
namespace Util {
    vec3<F32> toVec3(const physx::PxVec3& vec) noexcept {
        return { vec.x, vec.y, vec.z };
    }
 
    physx::PxVec3 toVec3(const vec3<F32>& vec) noexcept {
        return { vec.x, vec.y, vec.z };
    }
} //namespace Util
 
    PhysXActor::PhysXActor(RigidBodyComponent& parent) noexcept
        : PhysicsAsset(parent)
    {
    }
 
    PhysXActor::~PhysXActor()
    {
        if (_actor != nullptr) {
            _actor->release();
        }
    }
 
    void PhysXActor::setPosition(const vec3<F32>& position) {
        setPosition(position.x, position.y, position.z);
    }
 
    void PhysXActor::setPosition(const F32 x, const F32 y, const F32 z) {
        DIVIDE_UNUSED(x);
        DIVIDE_UNUSED(y);
        DIVIDE_UNUSED(z);
    }
 
    void PhysXActor::setPositionX(const F32 positionX) {
        DIVIDE_UNUSED(positionX);
 
    }
    void PhysXActor::setPositionY(const F32 positionY) {
        DIVIDE_UNUSED(positionY);
 
    }
    void PhysXActor::setPositionZ(const F32 positionZ) {
        DIVIDE_UNUSED(positionZ);
    }
 
    void PhysXActor::setScale(const vec3<F32>& scale) {
        DIVIDE_UNUSED(scale);
    }
 
    void PhysXActor::setRotation(const vec3<F32>& axis, Angle::DEGREES<F32> degrees) {
        DIVIDE_UNUSED(axis);
        DIVIDE_UNUSED(degrees);
    }
 
    void PhysXActor::setRotation(Angle::DEGREES<F32> pitch, Angle::DEGREES<F32> yaw, Angle::DEGREES<F32> roll) {
        DIVIDE_UNUSED(pitch);
        DIVIDE_UNUSED(yaw);
        DIVIDE_UNUSED(roll);
    }
 
    void PhysXActor::setRotation(const Quaternion<F32>& quat) {
        DIVIDE_UNUSED(quat);
    }
 
    void PhysXActor::translate(const vec3<F32>& axisFactors) {
        DIVIDE_UNUSED(axisFactors);
    }
 
    void PhysXActor::scale(const vec3<F32>& axisFactors) {
        DIVIDE_UNUSED(axisFactors);
    }
 
    void PhysXActor::rotate(const vec3<F32>& axis, Angle::DEGREES<F32> degrees) {
        DIVIDE_UNUSED(axis);
        DIVIDE_UNUSED(degrees);
    }
 
    void PhysXActor::rotate(Angle::DEGREES<F32> pitch, Angle::DEGREES<F32> yaw, Angle::DEGREES<F32> roll) {
        DIVIDE_UNUSED(pitch);
        DIVIDE_UNUSED(yaw);
        DIVIDE_UNUSED(roll);
    }
 
    void PhysXActor::rotate(const Quaternion<F32>& quat) {
        DIVIDE_UNUSED(quat);
    }
 
    void PhysXActor::rotateSlerp(const Quaternion<F32>& quat, const D64 deltaTime) {
        DIVIDE_UNUSED(quat);
        DIVIDE_UNUSED(deltaTime);
    }
 
    void PhysXActor::setScaleX(const F32 amount) {
        DIVIDE_UNUSED(amount);
    }
 
    void PhysXActor::setScaleY(const F32 amount) {
        DIVIDE_UNUSED(amount);
    }
 
    void PhysXActor::setScaleZ(const F32 amount) {
        DIVIDE_UNUSED(amount);
    }
 
    void PhysXActor::scaleX(const F32 amount) {
        DIVIDE_UNUSED( amount );
    }
 
    void PhysXActor::scaleY(const F32 amount) {
        DIVIDE_UNUSED( amount );
    }
 
    void PhysXActor::scaleZ(const F32 amount) {
        DIVIDE_UNUSED( amount );
    }
 
    void PhysXActor::rotateX(const Angle::DEGREES<F32> angle) {
        DIVIDE_UNUSED( angle );
    }
 
    void PhysXActor::rotateY(const Angle::DEGREES<F32> angle) {
        DIVIDE_UNUSED( angle );
    }
 
    void PhysXActor::rotateZ(const Angle::DEGREES<F32> angle) {
        DIVIDE_UNUSED( angle );
    }
 
    void PhysXActor::setRotationX(const Angle::DEGREES<F32> angle) {
        DIVIDE_UNUSED( angle );
    }
 
    void PhysXActor::setRotationY(const Angle::DEGREES<F32> angle) {
        DIVIDE_UNUSED( angle );
    }
 
    void PhysXActor::setRotationZ(const Angle::DEGREES<F32> angle) {
        DIVIDE_UNUSED( angle );
    }
    
    void PhysXActor::getScale(vec3<F32>& scaleOut) const {
        scaleOut.set(1.0f);
    }
 
    void PhysXActor::getPosition(vec3<F32>& posOut) const {
        posOut.set(0.0f);
    }
 
    void  PhysXActor::getOrientation(Quaternion<F32>& quatOut) const {
        quatOut.identity();
    }
 
    void PhysXActor::physicsCollisionGroup(const PhysicsGroup group) {
        if (_parentComponent.physicsCollisionGroup() != group && _actor != nullptr) {
            _context.convertActor(this, group);
        }
 
        PhysicsAsset::physicsCollisionGroup(group);
    }
 
} //namespace Divide