525 lines
24 KiB
C++
525 lines
24 KiB
C++
#include <uf/config.h>
|
|
#if UF_USE_OPENVR
|
|
#include "behavior.h"
|
|
|
|
#include <uf/utils/hook/hook.h>
|
|
#include <uf/utils/time/time.h>
|
|
#include <uf/utils/serialize/serializer.h>
|
|
#include <uf/utils/userdata/userdata.h>
|
|
#include <uf/utils/window/window.h>
|
|
#include <uf/utils/camera/camera.h>
|
|
#include <uf/utils/audio/audio.h>
|
|
#include <uf/ext/openvr/openvr.h>
|
|
#include <uf/utils/math/physics.h>
|
|
#include <uf/utils/mesh/mesh.h>
|
|
#include <uf/utils/graphic/graphic.h>
|
|
#include <uf/utils/math/transform.h>
|
|
#include <uf/utils/math/collision.h>
|
|
#include <uf/utils/thread/thread.h>
|
|
#include <uf/utils/renderer/renderer.h>
|
|
|
|
#include <sstream>
|
|
|
|
namespace {
|
|
struct {
|
|
uf::Object* left;
|
|
uf::Object* right;
|
|
} hands, lines, lights;
|
|
}
|
|
|
|
UF_BEHAVIOR_REGISTER_CPP(ext::PlayerHandBehavior)
|
|
UF_BEHAVIOR_TRAITS_CPP(ext::PlayerHandBehavior, ticks = true, renders = true, multithread = false)
|
|
#define this (&self)
|
|
void ext::PlayerHandBehavior::initialize( uf::Object& self ) {
|
|
#if UF_USE_OPENVR
|
|
uf::Serializer& metadata = this->getComponent<uf::Serializer>();
|
|
{
|
|
::hands.left = (uf::Object*) &uf::instantiator::instantiate("Object");
|
|
::hands.right = (uf::Object*) &uf::instantiator::instantiate("Object");
|
|
|
|
::lines.left = (uf::Object*) &uf::instantiator::instantiate("Object");
|
|
::lines.right = (uf::Object*) &uf::instantiator::instantiate("Object");
|
|
|
|
this->addChild(::hands.left);
|
|
this->addChild(::hands.right);
|
|
|
|
::hands.left->addChild(::lines.left);
|
|
::hands.right->addChild(::lines.right);
|
|
}
|
|
{
|
|
bool loaded = true;
|
|
for ( auto it = metadata["hands"].begin(); it != metadata["hands"].end(); ++it ) {
|
|
uf::stl::string key = it.key();
|
|
if ( !ext::openvr::requestRenderModel(metadata["hands"][key]["controller"]["model"].as<uf::stl::string>()) ) loaded = false;
|
|
}
|
|
if ( !loaded ) {
|
|
this->addHook( "VR:Model.Loaded", [&](pod::payloads::assetLoad& payload){
|
|
uf::stl::string name = payload.filename; // json["name"].as<uf::stl::string>();
|
|
uf::stl::string side = "";
|
|
if ( name == metadata["hands"]["left"]["controller"]["model"].as<uf::stl::string>() ) {
|
|
side = "left";
|
|
} else if ( name == metadata["hands"]["right"]["controller"]["model"].as<uf::stl::string>() ) {
|
|
side = "right";
|
|
};
|
|
if ( side == "" ) return;
|
|
|
|
uf::Object& hand = *(side == "left" ? ::hands.left : ::hands.right);
|
|
uf::Object& line = *(side == "left" ? ::lines.left : ::lines.right);
|
|
{
|
|
uf::Graphic& graphic = (hand.getComponent<uf::Graphic>() = ext::openvr::getRenderModel( name ));
|
|
|
|
graphic.process = true;
|
|
|
|
graphic.descriptor.frontFace = uf::renderer::enums::Face::CCW;
|
|
graphic.material.attachShader(uf::io::root+"/shaders/base/base.vert.spv", uf::renderer::enums::Shader::VERTEX);
|
|
graphic.material.attachShader(uf::io::root+"/shaders/base/base.frag.spv", uf::renderer::enums::Shader::FRAGMENT);
|
|
|
|
uf::instantiator::bind( "EntityBehavior", hand );
|
|
uf::instantiator::bind( "ObjectBehavior", hand );
|
|
hand.initialize();
|
|
}
|
|
if ( metadata["hands"][side]["pointer"]["length"].as<float>() > 0 ) {
|
|
// line.addAlias<uf::LineMesh, uf::Mesh>();
|
|
|
|
pod::Transform<>& transform = line.getComponent<pod::Transform<>>();
|
|
transform.orientation = uf::quaternion::axisAngle(
|
|
{
|
|
metadata["hands"][side]["pointer"]["orientation"]["axis"][0].as<float>(),
|
|
metadata["hands"][side]["pointer"]["orientation"]["axis"][1].as<float>(),
|
|
metadata["hands"][side]["pointer"]["orientation"]["axis"][2].as<float>()
|
|
},
|
|
metadata["hands"][side]["pointer"]["orientation"]["angle"].as<float>() * 3.14159f / 180.0f
|
|
);
|
|
transform.position = {
|
|
metadata["hands"][side]["pointer"]["offset"][0].as<float>(),
|
|
metadata["hands"][side]["pointer"]["offset"][1].as<float>(),
|
|
metadata["hands"][side]["pointer"]["offset"][2].as<float>()
|
|
};
|
|
|
|
auto& mesh = line.getComponent<uf::LineMesh>();
|
|
auto& graphic = line.getComponent<uf::Graphic>();
|
|
|
|
mesh.vertices = {
|
|
{ {0.0f, 0.0f, 0.0f} },
|
|
{ {0.0f, 0.0f, metadata["hands"][side]["pointer"]["length"].as<float>()} },
|
|
};
|
|
graphic.initialize();
|
|
graphic.initializeMesh(mesh);
|
|
|
|
graphic.material.attachShader(uf::io::root+"/shaders/line/base.vert.spv", uf::renderer::enums::Shader::VERTEX);
|
|
graphic.material.attachShader(uf::io::root+"/shaders/line/base.frag.spv", uf::renderer::enums::Shader::FRAGMENT);
|
|
graphic.descriptor.topology = uf::renderer::enums::PrimitiveTopology::LINE_STRIP;
|
|
graphic.descriptor.fill = uf::renderer::enums::PolygonMode::LINE;
|
|
graphic.descriptor.lineWidth = metadata["hands"][side]["pointer"]["width"].as<float>();
|
|
|
|
line.initialize();
|
|
}
|
|
if ( metadata["hands"][side]["light"]["should"].as<bool>() ){
|
|
auto& child = hand.loadChild("/light.json", false);
|
|
if (side == "left" )
|
|
lights.left = &child;
|
|
else
|
|
lights.right = &child;
|
|
|
|
auto& json = metadata["hands"][side]["light"];
|
|
auto& light = side == "left" ? *lights.left : *lights.right;
|
|
|
|
auto& metadata = light.getComponent<uf::Serializer>();
|
|
if ( !ext::json::isNull( json["color"] ) ) metadata["light"]["color"] = json["color"];
|
|
if ( !ext::json::isNull( json["radius"] ) ) metadata["light"]["radius"] = json["radius"];
|
|
if ( !ext::json::isNull( json["power"] ) ) metadata["light"]["power"] = json["power"];
|
|
if ( !ext::json::isNull( json["type"] ) ) metadata["light"]["type"] = json["type"];
|
|
if ( !ext::json::isNull( json["shadows"] ) ) metadata["light"]["shadows"] = json["shadows"];
|
|
metadata["lights"]["external update"] = true;
|
|
|
|
// light.initialize();
|
|
/*
|
|
auto* child = (uf::Object*) hand.findByUid(hand.loadChild("/light.json", false));
|
|
if ( child ) {
|
|
if (side == "left" ) lights.left = child; else lights.right = child;
|
|
auto& json = metadata["hands"][side]["light"];
|
|
auto& light = side == "left" ? *lights.left : *lights.right;
|
|
|
|
auto& metadata = light.getComponent<uf::Serializer>();
|
|
if ( !ext::json::isNull( json["color"] ) ) metadata["light"]["color"] = json["color"];
|
|
if ( !ext::json::isNull( json["radius"] ) ) metadata["light"]["radius"] = json["radius"];
|
|
if ( !ext::json::isNull( json["power"] ) ) metadata["light"]["power"] = json["power"];
|
|
if ( !ext::json::isNull( json["shadows"] ) ) metadata["light"]["shadows"] = json["shadows"];
|
|
metadata["lights"]["external update"] = true;
|
|
|
|
light.initialize();
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
});
|
|
}
|
|
uf::stl::vector<uf::Object*> vHands = { ::hands.left, ::hands.right };
|
|
for ( auto pointer : vHands ) {
|
|
auto& hand = *pointer;
|
|
hand.addHook("VR:Input.Digital", [&]( pod::payloads::vrInputDigital& payload){
|
|
int_fast8_t side = &hand == hands.left ? -1 : 1;
|
|
if ( payload.side != side ) return;
|
|
|
|
// fire mouse click
|
|
if ( payload.name == "click" ) {
|
|
pod::payloads::windowMouseClick pload;
|
|
pload.type = "window:Mouse.Click";
|
|
pload.invoker = "vr";
|
|
pload.mouse.position = uf::vector::encode( metadata["hands"][side]["cursor"]["position"], pload.mouse.position );
|
|
pload.mouse.delta = {};
|
|
pload.mouse.button = side == -1 ? "Right" : "Left";
|
|
pload.mouse.state = payload.state;
|
|
|
|
uf::hooks.call( pload.type, payload );
|
|
}
|
|
});
|
|
|
|
hand.addHook("world:Collision.%UID%", [&]( pod::payloads::worldCollision& payload){
|
|
uf::stl::string side = &hand == hands.left ? "left" : "right";
|
|
|
|
pod::payloads::vrHaptics pload;
|
|
pload.delay = 0;
|
|
pload.duration = uf::physics::time::delta;
|
|
pload.frequency = 1;
|
|
pload.amplitude = fmin(1.0f, 1000.0f * payload.depth);
|
|
plaod.side = &hand == hands.left ? -1 : 1;;
|
|
uf::hooks.call( "VR:Haptics." + side, payload );
|
|
});
|
|
|
|
auto& transform = hand.getComponent<pod::Transform<>>();
|
|
auto& collider = hand.getComponent<uf::Collider>();
|
|
|
|
// auto* box = new uf::BoundingBox( transform.position, {0.25, 0.25, 0.25} );
|
|
// box->getTransform().reference = &transform;
|
|
// collider.add(box);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
void ext::PlayerHandBehavior::tick( uf::Object& self ) {
|
|
#if UF_USE_OPENVR
|
|
auto& scene = uf::scene::getCurrentScene();
|
|
auto& controller = scene.getController();
|
|
auto& controllerCamera = controller.getComponent<uf::Camera>();
|
|
auto& controllerTransform = controller.getComponent<pod::Transform<>>();
|
|
auto& controllerCameraTransform = controllerCamera.getTransform();
|
|
|
|
auto& scene = uf::scene::getCurrentScene();
|
|
auto& controller = scene.getController();
|
|
auto& camera = controller.getComponent<uf::Camera>();
|
|
|
|
pod::Matrix4f playerModel = uf::matrix::identity(); {
|
|
auto& controller = this->getParent();
|
|
auto& camera = controller.getComponent<uf::Camera>();
|
|
pod::Matrix4f translation = uf::matrix::translate( uf::matrix::identity(), camera.getTransform().position + controller.getComponent<pod::Transform<>>().position );
|
|
pod::Matrix4f rotation = uf::quaternion::matrix( controller.getComponent<pod::Transform<>>().orientation );
|
|
playerModel = translation * rotation;
|
|
}
|
|
|
|
{
|
|
pod::Transform<>& transform = ::hands.left->getComponent<pod::Transform<>>();
|
|
transform.position = ext::openvr::controllerPosition( vr::Controller_Hand::Hand_Left );
|
|
transform.orientation = ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Left );
|
|
transform.scale = { 1, 1, 1 };
|
|
transform.reference = &controllerTransform;
|
|
|
|
auto& collider = ::hands.left->getComponent<uf::Collider>();
|
|
for ( auto* box : collider.getContainer() ) {
|
|
box->getTransform().position = transform.position + controllerTransform.position + controllerCameraTransform.position;
|
|
}
|
|
}
|
|
{
|
|
pod::Transform<>& transform = ::hands.right->getComponent<pod::Transform<>>();
|
|
transform.position = ext::openvr::controllerPosition( vr::Controller_Hand::Hand_Right );
|
|
transform.orientation = ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Right );
|
|
transform.scale = { 1, 1, 1 };
|
|
transform.reference = &controllerTransform;
|
|
|
|
auto& collider = ::hands.right->getComponent<uf::Collider>();
|
|
for ( auto* box : collider.getContainer() ) {
|
|
box->getTransform().position = transform.position + controllerTransform.position + controllerCameraTransform.position;
|
|
}
|
|
}
|
|
{
|
|
pod::Transform<>& transform = ::lines.left->getComponent<pod::Transform<>>();
|
|
transform.position = ext::openvr::controllerPosition( vr::Controller_Hand::Hand_Left, true );
|
|
transform.orientation = ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Left, true );
|
|
transform.scale = { 1, 1, 1 };
|
|
transform.reference = &controllerTransform;
|
|
|
|
if ( lights.left ) {
|
|
if ( lights.left->getUid() == 0 ) {
|
|
lights.left->initialize();
|
|
}
|
|
auto& light = *lights.left;
|
|
auto& lightTransform = light.getComponent<pod::Transform<>>();
|
|
lightTransform.position = controllerCameraTransform.position + controller.getComponent<pod::Transform<>>().position + transform.position;
|
|
|
|
auto& lightCamera = light.getComponent<uf::Camera>();
|
|
pod::Matrix4f playerModel = uf::matrix::identity();
|
|
pod::Matrix4f translation = uf::matrix::translate( uf::matrix::identity(), controllerCameraTransform.position + controllerTransform.position );
|
|
pod::Matrix4f rotation = uf::quaternion::matrix( controllerTransform.orientation );
|
|
playerModel = translation * rotation;
|
|
|
|
pod::Matrix4f model = uf::matrix::inverse( playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Left, true ) );
|
|
for ( size_t i = 0; i < 2; ++i ) lightCamera.setView( model, i );
|
|
}
|
|
}
|
|
{
|
|
pod::Transform<>& transform = ::lines.right->getComponent<pod::Transform<>>();
|
|
transform.position = ext::openvr::controllerPosition( vr::Controller_Hand::Hand_Right, true );
|
|
transform.orientation = ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Right, true );
|
|
transform.scale = { 1, 1, 1 };
|
|
transform.reference = &controllerTransform;
|
|
|
|
if ( lights.right ) {
|
|
if ( lights.right->getUid() == 0 ) {
|
|
lights.right->initialize();
|
|
}
|
|
auto& light = *lights.right;
|
|
auto& lightTransform = light.getComponent<pod::Transform<>>();
|
|
lightTransform.position = controllerCameraTransform.position + controllerTransform.position + transform.position;
|
|
|
|
auto& lightCamera = light.getComponent<uf::Camera>();
|
|
pod::Matrix4f playerModel = uf::matrix::identity();
|
|
pod::Matrix4f translation = uf::matrix::translate( uf::matrix::identity(), controllerCameraTransform.position + controllerTransform.position );
|
|
pod::Matrix4f rotation = uf::quaternion::matrix( controllerTransform.orientation );
|
|
playerModel = translation * rotation;
|
|
|
|
pod::Matrix4f model = uf::matrix::inverse( playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Right, true ) );
|
|
for ( size_t i = 0; i < 2; ++i ) lightCamera.setView( model, i );
|
|
}
|
|
}
|
|
//
|
|
if ( ::hands.left && ::hands.left->hasComponent<uf::Graphic>() ) {
|
|
auto& graphic = ::hands.left->getComponent<uf::Graphic>();
|
|
auto& transform = ::hands.left->getComponent<pod::Transform<>>();
|
|
graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Left );
|
|
pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Left, false );
|
|
if ( graphic.initialized && graphic.material.hasShader("vertex") ) {
|
|
struct UniformDescriptor {
|
|
/*alignas(16)*/ pod::Matrix4f model;
|
|
};
|
|
auto& shader = graphic.material.getShader("vertex");
|
|
auto& uniforms = uniform.get<UniformDescriptor>();
|
|
uniforms.model = model;
|
|
// uniforms.color = uf::vector::decode( metadata["hands"]["left"]["controller"]["color"], pod::Vector4f{1,1,1,1} );
|
|
|
|
if ( uf::renderer::currentRenderMode ) {
|
|
auto& renderMode = *uf::renderer::currentRenderMode;
|
|
if ( renderMode.getName() == "" ) uniforms.model = pod::Matrix4f{};
|
|
} else uniforms.model = pod::Matrix4f{};
|
|
|
|
shader.updateUniform( "UBO", uniform );
|
|
}
|
|
}
|
|
if ( ::hands.right && ::hands.right->hasComponent<uf::Graphic>() ) {
|
|
auto& graphic = ::hands.right->getComponent<uf::Graphic>();
|
|
auto& transform = ::hands.right->getComponent<pod::Transform<>>();
|
|
graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Right );
|
|
pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Right, false );
|
|
if ( graphic.initialized && graphic.material.hasShader("vertex") ) {
|
|
struct UniformDescriptor {
|
|
/*alignas(16)*/ pod::Matrix4f model;
|
|
};
|
|
auto& shader = graphic.material.getShader("vertex");
|
|
auto& uniforms = uniform.get<UniformDescriptor>();
|
|
uniforms.model = model;
|
|
// uniforms.color = uf::vector::decode( metadata["hands"]["right"]["controller"]["color"], pod::Vector4f{1,1,1,1} );
|
|
|
|
if ( uf::renderer::currentRenderMode ) {
|
|
auto& renderMode = *uf::renderer::currentRenderMode;
|
|
if ( renderMode.getName() == "" ) uniforms.model = pod::Matrix4f{};
|
|
} else uniforms.model = pod::Matrix4f{};
|
|
|
|
shader.updateUniform( "UBO", uniform );
|
|
}
|
|
}
|
|
if ( ::lines.left && ::lines.left->hasComponent<uf::Graphic>() ) {
|
|
auto& graphic = ::lines.left->getComponent<uf::Graphic>();
|
|
auto& transform = ::lines.left->getComponent<pod::Transform<>>();
|
|
graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Left );
|
|
pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Left, true );
|
|
if ( graphic.initialized && graphic.material.hasShader("vertex") ) {
|
|
struct UniformDescriptor {
|
|
/*alignas(16)*/ pod::Matrix4f model;
|
|
};
|
|
auto& shader = graphic.material.getShader("vertex");
|
|
auto& uniforms = uniform.get<UniformDescriptor>();
|
|
uniforms.model = model;
|
|
// uniforms.color = uf::vector::decode( metadata["hands"]["left"]["pointer"]["color"], pod::Vector4f{1,1,1,1} );
|
|
|
|
if ( uf::renderer::currentRenderMode ) {
|
|
auto& renderMode = *uf::renderer::currentRenderMode;
|
|
if ( renderMode.getName() == "" ) uniforms.model = pod::Matrix4f{};
|
|
} else uniforms.model = pod::Matrix4f{};
|
|
|
|
shader.updateUniform( "UBO", uniform );
|
|
}
|
|
}
|
|
if ( ::lines.right && ::lines.right->hasComponent<uf::Graphic>() ) {
|
|
auto& graphic = ::lines.right->getComponent<uf::Graphic>();
|
|
auto& transform = ::lines.right->getComponent<pod::Transform<>>();
|
|
graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Right );
|
|
pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Right, true );
|
|
if ( graphic.initialized && graphic.material.hasShader("vertex") ) {
|
|
struct UniformDescriptor {
|
|
/*alignas(16)*/ pod::Matrix4f model;
|
|
};
|
|
auto& shader = graphic.material.getShader("vertex");
|
|
auto& uniforms = uniform.get<UniformDescriptor>();
|
|
uniforms.model = model;
|
|
// uniforms.color = uf::vector::decode( metadata["hands"]["right"]["pointer"]["color"], pod::Vector4f{1,1,1,1} );
|
|
|
|
if ( uf::renderer::currentRenderMode ) {
|
|
auto& renderMode = *uf::renderer::currentRenderMode;
|
|
if ( renderMode.getName() == "" ) uniforms.model = pod::Matrix4f{};
|
|
} else uniforms.model = pod::Matrix4f{};
|
|
|
|
shader.updateUniform( "UBO", uniform );
|
|
}
|
|
}
|
|
// raytrace pointer / hand collision
|
|
{
|
|
uf::stl::vector<uf::Object*> handPointers = { ::hands.left, ::hands.right };
|
|
for ( auto pointer : handPointers ) { auto& hand = *pointer;
|
|
uf::stl::string side = &hand == ::hands.left ? "left" : "right";
|
|
if ( !ext::openvr::controllerActive( side == "left" ? vr::Controller_Hand::Hand_Left : vr::Controller_Hand::Hand_Right ) ) continue;
|
|
{
|
|
pod::Transform<>& transform = (side == "left" ? ::lines.left : ::lines.right)->getComponent<pod::Transform<>>();
|
|
struct {
|
|
pod::Vector3f origin;
|
|
pod::Vector3f direction;
|
|
} ray;
|
|
struct {
|
|
pod::Vector3f center;
|
|
pod::Vector3f normal;
|
|
} plane;
|
|
|
|
transform = uf::transform::reorient( transform );
|
|
ray.origin = transform.position;
|
|
ray.direction = transform.forward;
|
|
|
|
pod::Transform<> gtransform;
|
|
pod::Matrix4f mvp;
|
|
uf::Serializer& cMetadata = controller.getComponent<uf::Serializer>();
|
|
if ( ext::json::isArray( cMetadata["overlay"]["position"] ) )
|
|
gtransform.position = {
|
|
cMetadata["overlay"]["position"][0].as<float>(),
|
|
cMetadata["overlay"]["position"][1].as<float>(),
|
|
cMetadata["overlay"]["position"][2].as<float>(),
|
|
};
|
|
if ( ext::json::isArray( cMetadata["overlay"]["scale"] ) )
|
|
gtransform.scale = {
|
|
cMetadata["overlay"]["scale"][0].as<float>(),
|
|
cMetadata["overlay"]["scale"][1].as<float>(),
|
|
cMetadata["overlay"]["scale"][2].as<float>(),
|
|
};
|
|
if ( ext::json::isArray( cMetadata["overlay"]["orientation"] ) )
|
|
gtransform.orientation = {
|
|
cMetadata["overlay"]["orientation"][0].as<float>(),
|
|
cMetadata["overlay"]["orientation"][1].as<float>(),
|
|
cMetadata["overlay"]["orientation"][2].as<float>(),
|
|
cMetadata["overlay"]["orientation"][3].as<float>(),
|
|
};
|
|
|
|
plane.center = gtransform.position;
|
|
{
|
|
auto rotated = uf::quaternion::multiply( gtransform.orientation, pod::Vector4f{ 0, 0, 1, 1 } );
|
|
plane.normal.x = rotated.x;
|
|
plane.normal.y = rotated.y;
|
|
plane.normal.z = rotated.z;
|
|
plane.normal = uf::vector::normalize( plane.normal );
|
|
}
|
|
|
|
float denom = uf::vector::dot(plane.normal, ray.direction);
|
|
if (abs(denom) > 0.0001f) {
|
|
float t = uf::vector::dot( uf::vector::subtract(plane.center, ray.origin), plane.normal ) / denom;
|
|
if ( t >= 0 ) {
|
|
pod::Vector3f hit = ray.origin + (ray.direction * t);
|
|
pod::Vector3f translated = uf::matrix::multiply<float>( uf::matrix::inverse( uf::matrix::scale( uf::matrix::identity(), gtransform.scale ) ), uf::vector::subtract( plane.center, hit ) );
|
|
{
|
|
auto& metadata = this->getComponent<uf::Serializer>();
|
|
cMetadata["overlay"]["cursor"]["type"] = "vr";
|
|
cMetadata["overlay"]["cursor"]["position"][0] = translated.x;
|
|
cMetadata["overlay"]["cursor"]["position"][1] = translated.y;
|
|
cMetadata["overlay"]["cursor"]["position"][2] = translated.z;
|
|
|
|
metadata["hands"][side]["cursor"] = cMetadata["overlay"]["cursor"];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void ext::PlayerHandBehavior::render( uf::Object& self ){
|
|
#if UF_USE_OPENVR
|
|
uf::Serializer& metadata = this->getComponent<uf::Serializer>();
|
|
auto& scene = uf::scene::getCurrentScene();
|
|
auto& controller = scene.getController();
|
|
auto& camera = controller.getComponent<uf::Camera>();
|
|
|
|
if ( ::hands.left && ::hands.left->hasComponent<uf::Graphic>() ) {
|
|
auto& graphic = ::hands.left->getComponent<uf::Graphic>();
|
|
auto& transform = ::hands.left->getComponent<pod::Transform<>>();
|
|
graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Left );
|
|
pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Left, false );
|
|
if ( graphic.initialized && graphic.material.hasShader("vertex") ) {
|
|
auto& shader = graphic.material.getShader("vertex");
|
|
auto& uniform = shader.getUniform("Camera");
|
|
auto& uniforms = uniform.get<pod::Camera::Viewports>();
|
|
uniforms = camera.data().viewport;
|
|
shader.updateUniform("Camera", uniform);
|
|
}
|
|
}
|
|
if ( ::hands.right && ::hands.right->hasComponent<uf::Graphic>() ) {
|
|
auto& graphic = ::hands.right->getComponent<uf::Graphic>();
|
|
auto& transform = ::hands.right->getComponent<pod::Transform<>>();
|
|
graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Right );
|
|
pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Right, false );
|
|
if ( graphic.initialized && graphic.material.hasShader("vertex") ) {
|
|
auto& shader = graphic.material.getShader("vertex");
|
|
auto& uniform = shader.getUniform("Camera");
|
|
auto& uniforms = uniform.get<pod::Camera::Viewports>();
|
|
uniforms = camera.data().viewport;
|
|
shader.updateUniform("Camera", uniform);
|
|
}
|
|
}
|
|
if ( ::lines.left && ::lines.left->hasComponent<uf::Graphic>() ) {
|
|
auto& graphic = ::lines.left->getComponent<uf::Graphic>();
|
|
auto& transform = ::lines.left->getComponent<pod::Transform<>>();
|
|
graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Left );
|
|
pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Left, true );
|
|
if ( graphic.initialized && graphic.material.hasShader("vertex") ) {
|
|
auto& shader = graphic.material.getShader("vertex");
|
|
auto& uniform = shader.getUniform("Camera");
|
|
auto& uniforms = uniform.get<pod::Camera::Viewports>();
|
|
uniforms = camera.data().viewport;
|
|
shader.updateUniform("Camera", uniform);
|
|
}
|
|
}
|
|
if ( ::lines.right && ::lines.right->hasComponent<uf::Graphic>() ) {
|
|
auto& graphic = ::lines.right->getComponent<uf::Graphic>();
|
|
auto& transform = ::lines.right->getComponent<pod::Transform<>>();
|
|
graphic.process = ext::openvr::controllerActive( vr::Controller_Hand::Hand_Right );
|
|
pod::Matrix4f model = playerModel * ext::openvr::controllerModelMatrix( vr::Controller_Hand::Hand_Right, true );
|
|
if ( graphic.initialized && graphic.material.hasShader("vertex") ) {
|
|
auto& shader = graphic.material.getShader("vertex");
|
|
auto& uniform = shader.getUniform("Camera");
|
|
auto& uniforms = uniform.get<pod::Camera::Viewports>();
|
|
uniforms = camera.data().viewport;
|
|
shader.updateUniform("Camera", uniform);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
void ext::PlayerHandBehavior::destroy( uf::Object& self ){}
|
|
void ext::PlayerHandBehavior::Metadata::serialize( uf::Object& self, uf::Serializer& serializer ) {}
|
|
void ext::PlayerHandBehavior::Metadata::deserialize( uf::Object& self, uf::Serializer& serializer ) {}
|
|
#undef this
|
|
#endif |