TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-01-20 04:34:48 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity
Torque3D/Engine/source/platform/input/openVR/openVRTrackedObject.cpp
James Urquhart 212ac36cc1 Tidy up indentation in openvr changes
2016-09-11 22:51:00 +01:00

982 lines
28 KiB
C++
Raw Blame History

#include "platform/platform.h"
#include "platform/input/openVR/openVRTrackedObject.h"
#include "platform/input/openVR/openVRProvider.h"
#include "math/mathIO.h"
#include "scene/sceneRenderState.h"
#include "console/consoleTypes.h"
#include "core/stream/bitStream.h"
#include "core/resourceManager.h"
#include "materials/materialManager.h"
#include "materials/baseMatInstance.h"
#include "renderInstance/renderPassManager.h"
#include "lighting/lightQuery.h"
#include "console/engineAPI.h"
#include "gfx/gfxTextureManager.h"
#include "gfx/sim/debugDraw.h"
#include "gfx/gfxTransformSaver.h"
#include "environment/skyBox.h"
#include "collision/boxConvex.h"
#include "collision/concretePolyList.h"
#include "T3D/physics/physicsPlugin.h"
#include "T3D/physics/physicsCollision.h"
#include "T3D/physics/physicsBody.h"
#ifdef TORQUE_EXTENDED_MOVE
#include "T3D/gameBase/extended/extendedMove.h"
#endif
bool OpenVRTrackedObject::smDebugControllerMovePosition = true;
bool OpenVRTrackedObject::smDebugControllerPosition = false;
static const U32 sCollisionMoveMask = (PlayerObjectType |
StaticShapeObjectType | VehicleObjectType);
U32 OpenVRTrackedObject::sServerCollisionMask = sCollisionMoveMask; // ItemObjectType
U32 OpenVRTrackedObject::sClientCollisionMask = sCollisionMoveMask;
//-----------------------------------------------------------------------------
IMPLEMENT_CO_DATABLOCK_V1(OpenVRTrackedObjectData);
OpenVRTrackedObjectData::OpenVRTrackedObjectData() :
mShapeFile(NULL)
{
mCollisionBoxMin = Point3F(-0.02, -0.20, -0.02);
mCollisionBoxMax = Point3F(0.02, 0.05, 0.02);
}
OpenVRTrackedObjectData::~OpenVRTrackedObjectData()
{
}
bool OpenVRTrackedObjectData::onAdd()
{
if (Parent::onAdd())
{
return true;
}
return false;
}
bool OpenVRTrackedObjectData::preload(bool server, String &errorStr)
{
if (!Parent::preload(server, errorStr))
return false;
bool error = false;
if (!server)
{
mShape = mShapeFile ? ResourceManager::get().load(mShapeFile) : NULL;
}
}
void OpenVRTrackedObjectData::initPersistFields()
{
addGroup("Render Components");
addField("shape", TypeShapeFilename, Offset(mShapeFile, OpenVRTrackedObjectData), "Shape file to use for controller model.");
addField("collisionMin", TypePoint3F, Offset(mCollisionBoxMin, OpenVRTrackedObjectData), "Box min");
addField("collisionMax", TypePoint3F, Offset(mCollisionBoxMax, OpenVRTrackedObjectData), "Box min");
endGroup("Render Components");
Parent::initPersistFields();
}
void OpenVRTrackedObjectData::packData(BitStream* stream)
{
Parent::packData(stream);
stream->writeString(mShapeFile);
}
void OpenVRTrackedObjectData::unpackData(BitStream* stream)
{
Parent::unpackData(stream);
mShapeFile = stream->readSTString();
}
//-----------------------------------------------------------------------------
IMPLEMENT_CO_NETOBJECT_V1(OpenVRTrackedObject);
ConsoleDocClass(OpenVRTrackedObject,
"@brief Renders and handles interactions OpenVR controllers and tracked objects.\n\n"
"This class implements basic rendering and interactions with OpenVR controllers.\n\n"
"The object should be controlled by a player object. Controllers will be rendered at\n"
"the correct position regardless of the current transform of the object.\n"
"@ingroup OpenVR\n");
//-----------------------------------------------------------------------------
// Object setup and teardown
//-----------------------------------------------------------------------------
OpenVRTrackedObject::OpenVRTrackedObject() :
mDataBlock(NULL),
mShapeInstance(NULL),
mBasicModel(NULL),
mDeviceIndex(-1),
mMappedMoveIndex(-1),
mIgnoreParentRotation(true),
mConvexList(new Convex()),
mPhysicsRep(NULL)
{
// Flag this object so that it will always
// be sent across the network to clients
mNetFlags.set(Ghostable | ScopeAlways);
// Set it as a "static" object that casts shadows
mTypeMask |= StaticObjectType | StaticShapeObjectType;
mPose.connected = false;
}
OpenVRTrackedObject::~OpenVRTrackedObject()
{
clearRenderData();
delete mConvexList;
}
void OpenVRTrackedObject::updateRenderData()
{
clearRenderData();
if (!mDataBlock)
return;
// Are we using a model?
if (mDataBlock->mShape)
{
if (mShapeInstance && mShapeInstance->getShape() != mDataBlock->mShape)
{
delete mShapeInstance;
mShapeInstance = NULL;
}
if (!mShapeInstance)
{
mShapeInstance = new TSShapeInstance(mDataBlock->mShape, isClientObject());
}
}
else
{
setupRenderDataFromModel(isClientObject());
}
}
void OpenVRTrackedObject::setupRenderDataFromModel(bool loadComponentModels)
{
clearRenderData();
if (!OPENVR || !OPENVR->isEnabled())
return;
vr::IVRRenderModels *models = OPENVR->getRenderModels();
if (!models)
return;
if (!mShapeInstance && mModelName && mModelName[0] != '\0')
{
bool failed = false;
S32 idx = OPENVR->preloadRenderModel(mModelName);
while (!OPENVR->getRenderModel(idx, &mBasicModel, failed))
{
if (failed)
break;
}
}
if (loadComponentModels)
{
mRenderComponents.setSize(models->GetComponentCount(mModelName));
for (U32 i = 0, sz = mRenderComponents.size(); i < sz; i++)
{
RenderModelSlot &slot = mRenderComponents[i];
char buffer[1024];
slot.mappedNodeIdx = -1;
slot.componentName = NULL;
slot.nativeModel = NULL;
U32 result = models->GetComponentName(mModelName, i, buffer, sizeof(buffer));
if (result == 0)
continue;
#ifdef DEBUG_CONTROLLER_MODELS
Con::printf("Controller[%s] component %i NAME == %s", mModelName, i, buffer);
#endif
slot.componentName = StringTable->insert(buffer, true);
result = models->GetComponentRenderModelName(mModelName, slot.componentName, buffer, sizeof(buffer));
if (result == 0)
{
#ifdef DEBUG_CONTROLLER_MODELS
Con::printf("Controller[%s] component %i NO MODEL", mModelName, i);
#endif
continue;
}
#ifdef DEBUG_CONTROLLER_MODELS
Con::printf("Controller[%s] component %i == %s", mModelName, i, slot.componentName);
#endif
bool failed = false;
S32 idx = OPENVR->preloadRenderModel(StringTable->insert(buffer, true));
while (!OPENVR->getRenderModel(idx, &slot.nativeModel, failed))
{
if (failed)
break;
}
}
}
}
void OpenVRTrackedObject::clearRenderData()
{
mBasicModel = NULL;
mRenderComponents.clear();
}
//-----------------------------------------------------------------------------
// Object Editing
//-----------------------------------------------------------------------------
void OpenVRTrackedObject::initPersistFields()
{
// SceneObject already handles exposing the transform
Parent::initPersistFields();
addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track");
addField("mappedMoveIndex", TypeS32, Offset(mMappedMoveIndex, OpenVRTrackedObject), "Index of movemanager state to track"); addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track");
addField("ignoreParentRotation", TypeBool, Offset(mIgnoreParentRotation, OpenVRTrackedObject), "Index of movemanager state to track"); addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track");
static bool conInit = false;
if (!conInit)
{
Con::addVariable("$OpenVRTrackedObject::debugControllerPosition", TypeBool, &smDebugControllerPosition);
Con::addVariable("$OpenVRTrackedObject::debugControllerMovePosition", TypeBool, &smDebugControllerMovePosition);
conInit = true;
}
}
void OpenVRTrackedObject::inspectPostApply()
{
Parent::inspectPostApply();
// Flag the network mask to send the updates
// to the client object
setMaskBits(UpdateMask);
}
bool OpenVRTrackedObject::onAdd()
{
if (!Parent::onAdd())
return false;
// Set up a 1x1x1 bounding box
mObjBox.set(Point3F(-0.5f, -0.5f, -0.5f),
Point3F(0.5f, 0.5f, 0.5f));
resetWorldBox();
// Add this object to the scene
addToScene();
if (mDataBlock)
{
mObjBox.minExtents = mDataBlock->mCollisionBoxMin;
mObjBox.maxExtents = mDataBlock->mCollisionBoxMax;
resetWorldBox();
}
else
{
setGlobalBounds();
}
return true;
}
void OpenVRTrackedObject::onRemove()
{
// Remove this object from the scene
removeFromScene();
clearRenderData();
SAFE_DELETE(mPhysicsRep);
Parent::onRemove();
}
void OpenVRTrackedObject::_updatePhysics()
{
SAFE_DELETE(mPhysicsRep);
if (!PHYSICSMGR)
return;
PhysicsCollision *colShape = NULL;
MatrixF offset(true);
colShape = PHYSICSMGR->createCollision();
colShape->addBox(getObjBox().getExtents() * 0.5f * mObjScale, offset);
if (colShape)
{
PhysicsWorld *world = PHYSICSMGR->getWorld(isServerObject() ? "server" : "client");
mPhysicsRep = PHYSICSMGR->createBody();
mPhysicsRep->init(colShape, 0, PhysicsBody::BF_TRIGGER | PhysicsBody::BF_KINEMATIC, this, world);
mPhysicsRep->setTransform(getTransform());
}
}
bool OpenVRTrackedObject::onNewDataBlock(GameBaseData *dptr, bool reload)
{
mDataBlock = dynamic_cast<OpenVRTrackedObjectData*>(dptr);
if (!mDataBlock || !Parent::onNewDataBlock(dptr, reload))
return false;
// Setup the models
clearRenderData();
mObjBox.minExtents = mDataBlock->mCollisionBoxMin;
mObjBox.maxExtents = mDataBlock->mCollisionBoxMax;
mGlobalBounds = false;
resetWorldBox();
_updatePhysics();
scriptOnNewDataBlock();
return true;
}
void OpenVRTrackedObject::setInteractObject(SceneObject* object, bool holding)
{
mInteractObject = object;
mHoldInteractedObject = holding;
}
void OpenVRTrackedObject::setTransform(const MatrixF & mat)
{
// Let SceneObject handle all of the matrix manipulation
Parent::setTransform(mat);
// Dirty our network mask so that the new transform gets
// transmitted to the client object
setMaskBits(UpdateMask);
}
void OpenVRTrackedObject::setModelName(String &modelName)
{
if (!isServerObject())
return;
mModelName = StringTable->insert(modelName.c_str(), true);
setMaskBits(UpdateMask);
}
U32 OpenVRTrackedObject::packUpdate(NetConnection *conn, U32 mask, BitStream *stream)
{
// Allow the Parent to get a crack at writing its info
U32 retMask = Parent::packUpdate(conn, mask, stream);
// Write our transform information
if (stream->writeFlag(mask & UpdateMask))
{
mathWrite(*stream, getTransform());
mathWrite(*stream, getScale());
stream->write((S16)mDeviceIndex);
stream->write((S16)mMappedMoveIndex);
stream->writeString(mModelName);
}
return retMask;
}
void OpenVRTrackedObject::unpackUpdate(NetConnection *conn, BitStream *stream)
{
// Let the Parent read any info it sent
Parent::unpackUpdate(conn, stream);
if (stream->readFlag()) // UpdateMask
{
mathRead(*stream, &mObjToWorld);
mathRead(*stream, &mObjScale);
setTransform(mObjToWorld);
S16 readDeviceIndex;
S16 readMoveIndex;
stream->read(&readDeviceIndex);
stream->read(&readMoveIndex);
mDeviceIndex = readDeviceIndex;
mMappedMoveIndex = readMoveIndex;
mModelName = stream->readSTString();
updateRenderData();
}
}
void OpenVRTrackedObject::writePacketData(GameConnection *conn, BitStream *stream)
{
Parent::writePacketData(conn, stream);
}
void OpenVRTrackedObject::readPacketData(GameConnection *conn, BitStream *stream)
{
Parent::readPacketData(conn, stream);
}
MatrixF OpenVRTrackedObject::getTrackedTransform()
{
IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex);
MatrixF trackedMat(1);
pose.orientation.setMatrix(&trackedMat);
trackedMat.setPosition(pose.position);
return trackedMat;
}
MatrixF OpenVRTrackedObject::getLastTrackedTransform()
{
MatrixF trackedMat(1);
mPose.orientation.setMatrix(&trackedMat);
trackedMat.setPosition(mPose.position);
return trackedMat;
}
MatrixF OpenVRTrackedObject::getBaseTrackingTransform()
{
if (isMounted())
{
MatrixF mat;
mMount.object->getMountTransform(mMount.node, mMount.xfm, &mat);
if (mIgnoreParentRotation)
{
Point3F pos = mat.getPosition();
mat = MatrixF(1);
mat.setPosition(pos);
}
//mat.inverse();
return mat;
}
return MatrixF(1);
}
void OpenVRTrackedObject::prepRenderImage(SceneRenderState *state)
{
RenderPassManager *renderPass = state->getRenderPass();
// debug rendering for now
if (mDeviceIndex < 0)
return;
// Current pose
IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex);
IDevicePose hmdPose = OPENVR->getTrackedDevicePose(0);
if (!pose.connected && !mPose.connected)
return;
MatrixF offsetMat = getBaseTrackingTransform();
//offsetMat.inverse();
Point3F pos = offsetMat.getPosition();
//Con::printf("Base offs == %f,%f,%f", pos.x, pos.y, pos.z);
const F32 CONTROLLER_SCALE = 0.1;
if (smDebugControllerPosition)
{
ColorI drawColor = ColorI::GREEN;
if (!pose.valid)
{
drawColor = ColorI::RED;
}
// Draw Camera
/*
DisplayPose cameraPose;
OPENVR->getFrameEyePose(&cameraPose, -1);
Point3F cameraCenter(0);
MatrixF cameraMat(1);
cameraPose.orientation.setMatrix(&cameraMat);
cameraMat.setPosition(cameraPose.position);
cameraMat.mulP(cameraCenter);
//DebugDrawer::get()->drawBox(cameraCenter - Point3F(0.1), cameraCenter + Point3F(0.1), ColorI::GREEN);
DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -0.1, -0.5), Point3F(0.5, 0.1, 0.5), ColorI::WHITE, cameraMat); // general box
*/
// Draw Tracked HMD Pos
Point3F hmdCenter(0, 0, 0);
MatrixF hmdMat(1);
hmdPose.orientation.setMatrix(&hmdMat);
hmdMat.setPosition(hmdPose.position);
hmdMat.inverse(); // -> world mat (as opposed to world -> tracked pos)
hmdMat = offsetMat * hmdMat;
hmdMat.mulP(hmdCenter);
DebugDrawer::get()->drawBox(hmdCenter - Point3F(0.1), hmdCenter + Point3F(0.1), ColorI::RED);
DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -0.1, -0.5), Point3F(0.5, 0.1, 0.5), ColorI::GREEN, hmdMat); // general box
// Draw Controller
MatrixF mat(1);
pose.orientation.setMatrix(&mat);
mat.setPosition(pose.position);
mat.inverse(); // same as HMD
mat = offsetMat * mat;
Point3F middleStart(0, -1 * CONTROLLER_SCALE, 0);
Point3F middleEnd(0, 1 * CONTROLLER_SCALE, 0);
Point3F middle(0, 0, 0);
Point3F center(0, 0, 0);
mat.mulP(center);
//DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE);
mat.mulP(middleStart);
mat.mulP(middle);
mat.mulP(middleEnd);
char buffer[256];
dSprintf(buffer, 256, "%f %f %f", center.x, center.y, center.z);
DebugDrawer::get()->drawText(middle, buffer);
DebugDrawer::get()->drawLine(middleStart, middle, ColorI(0, 255, 0)); // axis back
DebugDrawer::get()->drawLine(middleEnd, middle, ColorI(255, 0, 0)); // axis forward
DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -1, -0.5) * CONTROLLER_SCALE, Point3F(0.5, 1, 0.5) * CONTROLLER_SCALE, drawColor, mat); // general box
DebugDrawer::get()->drawBoxOutline(Point3F(-1), Point3F(1), ColorI::WHITE);
}
if (isClientObject() && smDebugControllerMovePosition)
{
MatrixF transform = getRenderTransform();
transform.scale(mObjScale);
DebugDrawer::get()->drawTransformedBoxOutline(mObjBox.minExtents, mObjBox.maxExtents, ColorI::RED, transform);
// jamesu - grab server object pose for debugging
OpenVRTrackedObject* tracked = static_cast<OpenVRTrackedObject*>(getServerObject());
if (tracked)
{
mPose = tracked->mPose;
}
ColorI drawColor = ColorI::GREEN;
if (!pose.valid)
{
drawColor = ColorI::RED;
}
// Draw Controller
MatrixF mat(1);
mPose.orientation.setMatrix(&mat);
mat.setPosition(mPose.position);
mat.inverse(); // same as HMD
mat = offsetMat * mat;
Point3F middleStart(0, -1 * CONTROLLER_SCALE, 0);
Point3F middleEnd(0, 1 * CONTROLLER_SCALE, 0);
Point3F middle(0, 0, 0);
Point3F center(0, 0, 0);
mat.mulP(center);
//DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE);
mat.mulP(middleStart);
mat.mulP(middle);
mat.mulP(middleEnd);
char buffer[256];
dSprintf(buffer, 256, "%f %f %f", center.x, center.y, center.z);
DebugDrawer::get()->drawText(middle, buffer);
DebugDrawer::get()->drawLine(middleStart, middle, ColorI(0, 255, 0)); // axis back
DebugDrawer::get()->drawLine(middleEnd, middle, ColorI(255, 0, 0)); // axis forward
DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -1, -0.5) * CONTROLLER_SCALE, Point3F(0.5, 1, 0.5) * CONTROLLER_SCALE, drawColor, mat); // general box
DebugDrawer::get()->drawBoxOutline(Point3F(-1), Point3F(1), ColorI::WHITE);
}
// Controller matrix base
MatrixF trackedMat = getTrackedTransform();
MatrixF invTrackedMat(1);
invTrackedMat = trackedMat;
invTrackedMat.inverse(); // -> world mat (as opposed to world -> tracked pos)
invTrackedMat = getBaseTrackingTransform() * invTrackedMat;
trackedMat = invTrackedMat;
trackedMat.inverse();
// Render the controllers, using either the render model or the shape
if (mShapeInstance)
{
// Calculate the distance of this object from the camera
Point3F cameraOffset = invTrackedMat.getPosition();
cameraOffset -= state->getDiffuseCameraPosition();
F32 dist = cameraOffset.len();
if (dist < 0.01f)
dist = 0.01f;
// Set up the LOD for the shape
F32 invScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z));
mShapeInstance->setDetailFromDistance(state, dist * invScale);
// Make sure we have a valid level of detail
if (mShapeInstance->getCurrentDetail() < 0)
return;
// GFXTransformSaver is a handy helper class that restores
// the current GFX matrices to their original values when
// it goes out of scope at the end of the function
GFXTransformSaver saver;
// Set up our TS render state
TSRenderState rdata;
rdata.setSceneState(state);
rdata.setFadeOverride(1.0f);
// We might have some forward lit materials
// so pass down a query to gather lights.
LightQuery query;
query.init(getWorldSphere());
rdata.setLightQuery(&query);
// Set the world matrix to the objects render transform
MatrixF mat = trackedMat;
mat.scale(mObjScale);
GFX->setWorldMatrix(mat);
// TODO: move the nodes about for components
mShapeInstance->animate();
mShapeInstance->render(rdata);
}
else if (mRenderComponents.size() > 0)
{
vr::IVRRenderModels *models = OPENVR->getRenderModels();
if (!models)
return;
vr::IVRSystem* vrs = vr::VRSystem();
if (!vrs->GetControllerState(mDeviceIndex, &mCurrentControllerState))
{
return;
}
for (U32 i = 0, sz = mRenderComponents.size(); i < sz; i++)
{
RenderModelSlot slot = mRenderComponents[i];
vr::RenderModel_ControllerMode_State_t modeState;
vr::RenderModel_ComponentState_t componentState;
modeState.bScrollWheelVisible = false;
if (models->GetComponentState(mModelName, slot.componentName, &mCurrentControllerState, &modeState, &componentState))
{
MeshRenderInst *ri = renderPass->allocInst<MeshRenderInst>();
// Set our RenderInst as a standard mesh render
ri->type = RenderPassManager::RIT_Mesh;
// Calculate our sorting point
if (state && slot.nativeModel)
{
// Calculate our sort point manually.
const Box3F rBox = slot.nativeModel->getWorldBox(invTrackedMat);
ri->sortDistSq = rBox.getSqDistanceToPoint(state->getCameraPosition());
}
else
{
ri->sortDistSq = 0.0f;
}
MatrixF newTransform = trackedMat;
MatrixF controllerOffsMat = OpenVRUtil::convertSteamVRAffineMatrixToMatrixFPlain(componentState.mTrackingToComponentRenderModel);
MatrixF offComponentMat(1);
OpenVRUtil::convertTransformFromOVR(controllerOffsMat, offComponentMat);
newTransform = offComponentMat * newTransform;
newTransform.inverse();
//DebugDrawer::get()->drawBox(newTransform.getPosition() - Point3F(0.001), newTransform.getPosition() + Point3F(0.001), ColorI::BLUE);
if (!slot.nativeModel)
continue;
if (i < 1)
continue;
// Set up our transforms
ri->objectToWorld = renderPass->allocUniqueXform(newTransform);
ri->worldToCamera = renderPass->allocSharedXform(RenderPassManager::View);
ri->projection = renderPass->allocSharedXform(RenderPassManager::Projection);
// If our material needs lights then fill the RIs
// light vector with the best lights.
if (true)
{
LightQuery query;
Point3F center(0, 0, 0);
invTrackedMat.mulP(center);
query.init(SphereF(center, 10.0f));
query.getLights(ri->lights, 8);
}
// Draw model
slot.nativeModel->draw(state, ri);
state->getRenderPass()->addInst(ri);
}
}
}
else if (mBasicModel)
{
MeshRenderInst *ri = renderPass->allocInst<MeshRenderInst>();
// Set our RenderInst as a standard mesh render
ri->type = RenderPassManager::RIT_Mesh;
// Calculate our sorting point
if (state)
{
// Calculate our sort point manually.
const Box3F rBox = mBasicModel->getWorldBox(invTrackedMat);
ri->sortDistSq = rBox.getSqDistanceToPoint(state->getCameraPosition());
}
else
{
ri->sortDistSq = 0.0f;
}
MatrixF newTransform = invTrackedMat;
// Set up our transforms
ri->objectToWorld = renderPass->allocUniqueXform(newTransform);
ri->worldToCamera = renderPass->allocSharedXform(RenderPassManager::View);
ri->projection = renderPass->allocSharedXform(RenderPassManager::Projection);
// If our material needs lights then fill the RIs
// light vector with the best lights.
if (true)
{
LightQuery query;
Point3F center(0, 0, 0);
invTrackedMat.mulP(center);
query.init(SphereF(center, 10.0f));
query.getLights(ri->lights, 8);
}
// Draw model
mBasicModel->draw(state, ri);
state->getRenderPass()->addInst(ri);
}
}
U32 OpenVRTrackedObject::getCollisionMask()
{
if (isServerObject())
return sServerCollisionMask;
else
return sClientCollisionMask;
}
void OpenVRTrackedObject::updateWorkingCollisionSet()
{
const U32 mask = getCollisionMask();
Box3F convexBox = mConvexList->getBoundingBox(getTransform(), getScale());
F32 len = (50) * TickSec;
F32 l = (len * 1.1) + 0.1; // fudge factor
convexBox.minExtents -= Point3F(l, l, l);
convexBox.maxExtents += Point3F(l, l, l);
disableCollision();
mConvexList->updateWorkingList(convexBox, mask);
enableCollision();
}
void OpenVRTrackedObject::updateMove(const Move *move)
{
// Set transform based on move
#ifdef TORQUE_EXTENDED_MOVE
const ExtendedMove* emove = dynamic_cast<const ExtendedMove*>(move);
if (!emove)
return;
U32 emoveIndex = mMappedMoveIndex;
if (emoveIndex >= ExtendedMove::MaxPositionsRotations)
emoveIndex = 0;
//IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex);
//Con::printf("OpenVRTrackedObject::processTick move %i", emoveIndex);
if (!emove->EulerBasedRotation[emoveIndex])
{
AngAxisF inRot = AngAxisF(Point3F(emove->rotX[emoveIndex], emove->rotY[emoveIndex], emove->rotZ[emoveIndex]), emove->rotW[emoveIndex]);
// Update our pose based on the move info
mPose.orientation = inRot;
mPose.position = Point3F(emove->posX[emoveIndex], emove->posY[emoveIndex], emove->posZ[emoveIndex]);
mPose.valid = true;
mPose.connected = true;
}
// Set transform based on move pose
MatrixF trackedMat(1);
MatrixF invTrackedMat(1);
mPose.orientation.setMatrix(&trackedMat);
trackedMat.setPosition(mPose.position);
invTrackedMat = trackedMat;
invTrackedMat.inverse(); // -> world mat (as opposed to world -> tracked pos)
invTrackedMat = getBaseTrackingTransform() * invTrackedMat;
trackedMat = invTrackedMat;
trackedMat.inverse();
SceneObject::setTransform(invTrackedMat);
if (mPhysicsRep)
mPhysicsRep->setTransform(invTrackedMat);
#endif
}
void OpenVRTrackedObject::processTick(const Move *move)
{
// Perform collision checks
if (isServerObject())
{
updateMove(move);
if (!mPhysicsRep)
{
updateWorkingCollisionSet();
}
}
Parent::processTick(move);
}
void OpenVRTrackedObject::interpolateTick(F32 delta)
{
// Set latest transform
Parent::interpolateTick(delta);
}
void OpenVRTrackedObject::advanceTime(F32 dt)
{
Parent::advanceTime(dt);
}
bool OpenVRTrackedObject::castRay(const Point3F &start, const Point3F &end, RayInfo* info)
{
if (!mPose.connected || !mPose.valid)
return false;
// Collide against bounding box.
F32 st, et, fst = 0.0f, fet = 1.0f;
F32 *bmin = &mObjBox.minExtents.x;
F32 *bmax = &mObjBox.maxExtents.x;
F32 const *si = &start.x;
F32 const *ei = &end.x;
for (S32 i = 0; i < 3; i++) {
if (*si < *ei) {
if (*si > *bmax || *ei < *bmin)
return false;
F32 di = *ei - *si;
st = (*si < *bmin) ? (*bmin - *si) / di : 0.0f;
et = (*ei > *bmax) ? (*bmax - *si) / di : 1.0f;
}
else {
if (*ei > *bmax || *si < *bmin)
return false;
F32 di = *ei - *si;
st = (*si > *bmax) ? (*bmax - *si) / di : 0.0f;
et = (*ei < *bmin) ? (*bmin - *si) / di : 1.0f;
}
if (st > fst) fst = st;
if (et < fet) fet = et;
if (fet < fst)
return false;
bmin++; bmax++;
si++; ei++;
}
info->normal = start - end;
info->normal.normalizeSafe();
getTransform().mulV(info->normal);
info->t = fst;
info->object = this;
info->point.interpolate(start, end, fst);
info->material = 0;
return true;
}
void OpenVRTrackedObject::buildConvex(const Box3F& box, Convex* convex)
{
// These should really come out of a pool
mConvexList->collectGarbage();
Box3F realBox = box;
mWorldToObj.mul(realBox);
realBox.minExtents.convolveInverse(mObjScale);
realBox.maxExtents.convolveInverse(mObjScale);
if (realBox.isOverlapped(getObjBox()) == false)
return;
// Just return a box convex for the entire shape...
Convex* cc = 0;
CollisionWorkingList& wl = convex->getWorkingList();
for (CollisionWorkingList* itr = wl.wLink.mNext; itr != &wl; itr = itr->wLink.mNext) {
if (itr->mConvex->getType() == BoxConvexType &&
itr->mConvex->getObject() == this) {
cc = itr->mConvex;
break;
}
}
if (cc)
return;
// Create a new convex.
BoxConvex* cp = new BoxConvex;
mConvexList->registerObject(cp);
convex->addToWorkingList(cp);
cp->init(this);
mObjBox.getCenter(&cp->mCenter);
cp->mSize.x = mObjBox.len_x() / 2.0f;
cp->mSize.y = mObjBox.len_y() / 2.0f;
cp->mSize.z = mObjBox.len_z() / 2.0f;
}
bool OpenVRTrackedObject::testObject(SceneObject* enter)
{
return false; // TODO
}
DefineEngineMethod(OpenVRTrackedObject, setModelName, void, (String modelName),, "Set model name. Typically you should do this from the client to update the server representation.")
{
object->setModelName(modelName);
}
Reference in a new issue View git blame Copy permalink