597 lines
25 KiB
C++
597 lines
25 KiB
C++
#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/window/payloads.h>
|
|
#include <uf/utils/camera/camera.h>
|
|
#include <uf/utils/audio/audio.h>
|
|
#include <uf/ext/openvr/openvr.h>
|
|
#include <uf/engine/graph/graph.h>
|
|
#include <uf/ext/bullet/bullet.h>
|
|
#include <uf/utils/math/physics.h>
|
|
#include <uf/spec/controller/controller.h>
|
|
|
|
#include <sstream>
|
|
|
|
UF_BEHAVIOR_REGISTER_CPP(ext::PlayerBehavior)
|
|
UF_BEHAVIOR_TRAITS_CPP(ext::PlayerBehavior, ticks = true, renders = false, multithread = false)
|
|
#define this (&self)
|
|
void ext::PlayerBehavior::initialize( uf::Object& self ) {
|
|
auto& transform = this->getComponent<pod::Transform<>>();
|
|
|
|
auto& collider = this->getComponent<pod::Bullet>();
|
|
|
|
auto& metadata = this->getComponent<ext::PlayerBehavior::Metadata>();
|
|
auto& metadataJson = this->getComponent<uf::Serializer>();
|
|
|
|
auto& camera = this->getComponent<uf::Camera>();
|
|
auto& cameraTransform = camera.getTransform();
|
|
{
|
|
camera.setStereoscopic(true);
|
|
|
|
cameraTransform.position = uf::vector::decode( metadataJson["camera"]["position"], cameraTransform.position );
|
|
cameraTransform.scale = uf::vector::decode( metadataJson["camera"]["scale"], cameraTransform.scale );
|
|
cameraTransform.reference = &transform;
|
|
|
|
if ( metadataJson["camera"]["ortho"].as<bool>() ) {
|
|
float l = metadataJson["camera"]["settings"]["left"].as<float>();
|
|
float r = metadataJson["camera"]["settings"]["right"].as<float>();
|
|
float b = metadataJson["camera"]["settings"]["bottom"].as<float>();
|
|
float t = metadataJson["camera"]["settings"]["top"].as<float>();
|
|
float n = metadataJson["camera"]["settings"]["near"].as<float>();
|
|
float f = metadataJson["camera"]["settings"]["far"].as<float>();
|
|
|
|
camera.setProjection( uf::matrix::orthographic( l, r, b, t, n, f ) );
|
|
} else {
|
|
float fov = metadataJson["camera"]["settings"]["fov"].as<float>(120) * (3.14159265358f / 180.0f);
|
|
float znear = metadataJson["camera"]["settings"]["clip"]["near"].as<float>();
|
|
float zfar = metadataJson["camera"]["settings"]["clip"]["far"].as<float>();
|
|
|
|
pod::Vector2ui size = uf::vector::decode( metadataJson["camera"]["settings"]["size"], pod::Vector2ui{} );
|
|
float raidou = (float) size.x / (float) size.y;
|
|
|
|
if ( size.x == 0 || size.y == 0 ) {
|
|
size = uf::vector::decode( ext::config["window"]["size"], pod::Vector2ui{} );
|
|
raidou = (float) size.x / (float) size.y;
|
|
this->addHook( "window:Resized", [&, fov, znear, zfar](ext::json::Value& json){
|
|
pod::Vector2ui size = uf::vector::decode( json["window"]["size"], pod::Vector2ui{} );
|
|
float raidou = (float) size.x / (float) size.y;
|
|
camera.setProjection( uf::matrix::perspective( fov, raidou, znear, zfar ) );
|
|
} );
|
|
}
|
|
camera.setProjection( uf::matrix::perspective( fov, raidou, znear, zfar ) );
|
|
}
|
|
camera.update(true);
|
|
}
|
|
metadataJson["system"]["control"] = true;
|
|
this->addHook( "window:Mouse.CursorVisibility", [&](ext::json::Value& json){
|
|
metadata.system.control = !json["state"].as<bool>();
|
|
});
|
|
|
|
// Rotate Camera
|
|
this->addHook( "window:Mouse.Moved", [&](pod::payloads::windowMouseMoved& payload ){
|
|
float sensitivity = 2;
|
|
pod::Vector2 relta = { (float) sensitivity * payload.mouse.delta.x / payload.window.size.x, (float) sensitivity * payload.mouse.delta.y / payload.window.size.y };
|
|
if ( (payload.mouse.delta.x == 0 && payload.mouse.delta.y == 0) || !metadata.system.control ) return;
|
|
|
|
bool updateCamera = false;
|
|
if ( payload.mouse.delta.x != 0 ) {
|
|
if ( metadata.camera.invert.x ) relta.x *= -1;
|
|
metadata.camera.limit.current.x += relta.x;
|
|
if ( metadata.camera.limit.current.x != metadata.camera.limit.current.x || ( metadata.camera.limit.current.x < metadata.camera.limit.max.x && metadata.camera.limit.current.x > metadata.camera.limit.min.x ) ) {
|
|
if ( collider.body && !collider.shared ) {
|
|
#if UF_USE_BULLET
|
|
ext::bullet::applyRotation( collider, transform.up, relta.x );
|
|
#endif
|
|
} else {
|
|
uf::transform::rotate( transform, transform.up, relta.x ), updateCamera = true;
|
|
}
|
|
} else metadata.camera.limit.current.x -= relta.x;
|
|
}
|
|
if ( payload.mouse.delta.y != 0 ) {
|
|
if ( metadata.camera.invert.y ) relta.y *= -1;
|
|
metadata.camera.limit.current.y += relta.y;
|
|
if ( metadata.camera.limit.current.y != metadata.camera.limit.current.y || ( metadata.camera.limit.current.y < metadata.camera.limit.max.y && metadata.camera.limit.current.y > metadata.camera.limit.min.y ) ) {
|
|
// if ( collider.body && !collider.shared ) {
|
|
// ext::bullet::applyRotation( collider, cameraTransform.right, relta.y );
|
|
// } else {
|
|
uf::transform::rotate( cameraTransform, cameraTransform.right, relta.y );
|
|
// }
|
|
updateCamera = true;
|
|
} else metadata.camera.limit.current.y -= relta.y;
|
|
}
|
|
if ( updateCamera ) camera.update(true);
|
|
});
|
|
|
|
#if UF_USE_DISCORD
|
|
// Discord Integration
|
|
this->addHook( "discord.Activity.Update.%UID%", [&](ext::json::Value& json){
|
|
uf::stl::string leaderId = metadataJson[""]["party"][0].as<uf::stl::string>();
|
|
uf::Serializer cardData = masterDataGet("Card", leaderId);
|
|
uf::Serializer charaData = masterDataGet("Chara", cardData["character_id"].as<uf::stl::string>());
|
|
uf::stl::string leader = charaData["name"].as<uf::stl::string>();
|
|
|
|
uf::Serializer payload = json;
|
|
payload["details"] = "Leader: " + leader;
|
|
uf::hooks.call( "discord:Activity.Update", payload );
|
|
});
|
|
this->queueHook("discord.Activity.Update.%UID%", ext::json::null(), 1.0);
|
|
#endif
|
|
|
|
this->addHook( "object:UpdateMetadata.%UID%", [&](){
|
|
metadata.deserialize(self, metadataJson);
|
|
});
|
|
metadata.deserialize(self, metadataJson);
|
|
}
|
|
void ext::PlayerBehavior::tick( uf::Object& self ) {
|
|
auto& camera = this->getComponent<uf::Camera>();
|
|
auto& transform = this->getComponent<pod::Transform<>>();
|
|
auto& physics = this->getComponent<pod::Physics>();
|
|
auto& scene = uf::scene::getCurrentScene();
|
|
|
|
struct {
|
|
bool forward;
|
|
bool backwards;
|
|
bool left;
|
|
bool right;
|
|
|
|
bool lookLeft;
|
|
bool lookRight;
|
|
bool running;
|
|
bool walk;
|
|
bool jump;
|
|
bool crouch;
|
|
bool paused;
|
|
bool vee;
|
|
} keys = {
|
|
.forward = uf::Window::isKeyPressed("W"),
|
|
.backwards = uf::Window::isKeyPressed("S"),
|
|
.left = uf::Window::isKeyPressed("A"),
|
|
.right = uf::Window::isKeyPressed("D"),
|
|
.lookLeft = uf::Window::isKeyPressed("Left"),
|
|
.lookRight = uf::Window::isKeyPressed("Right"),
|
|
.running = uf::Window::isKeyPressed("LShift"),
|
|
.walk = uf::Window::isKeyPressed("LAlt"),
|
|
.jump = uf::Window::isKeyPressed(" "),
|
|
.crouch = uf::Window::isKeyPressed("LControl"),
|
|
.paused = uf::Window::isKeyPressed("Escape"),
|
|
.vee = uf::Window::isKeyPressed("V"),
|
|
};
|
|
|
|
if ( spec::controller::connected() ) {
|
|
#if UF_USE_OPENVR
|
|
if ( spec::controller::pressed( "R_DPAD_UP" ) ) keys.forward = true;
|
|
if ( spec::controller::pressed( "R_DPAD_DOWN" ) ) keys.backwards = true;
|
|
if ( spec::controller::pressed( "R_DPAD_LEFT" ) ) keys.lookLeft = true; // keys.left = true;
|
|
if ( spec::controller::pressed( "R_DPAD_RIGHT" ) ) keys.lookRight = true; // keys.right = true;
|
|
if ( spec::controller::pressed( "R_JOYSTICK" ) ) keys.running = true;
|
|
if ( spec::controller::pressed( "R_A" ) ) keys.jump = true;
|
|
|
|
if ( spec::controller::pressed( "L_DPAD_UP" ) ) keys.forward = true;
|
|
if ( spec::controller::pressed( "L_DPAD_DOWN" ) ) keys.backwards = true;
|
|
if ( spec::controller::pressed( "L_DPAD_LEFT" ) ) keys.lookLeft = true;
|
|
if ( spec::controller::pressed( "L_DPAD_RIGHT" ) ) keys.lookRight = true;
|
|
if ( spec::controller::pressed( "L_JOYSTICK" ) ) keys.crouch = true, keys.walk = true;
|
|
if ( spec::controller::pressed( "L_A" ) ) keys.paused = true;
|
|
#else
|
|
if ( spec::controller::pressed( "DPAD_UP" ) ) keys.forward = true;
|
|
if ( spec::controller::pressed( "DPAD_DOWN" ) ) keys.backwards = true;
|
|
if ( spec::controller::pressed( "DPAD_LEFT" ) ) keys.lookLeft = true;
|
|
if ( spec::controller::pressed( "DPAD_RIGHT" ) ) keys.lookRight = true;
|
|
if ( spec::controller::pressed( "A" ) ) keys.jump = true;
|
|
if ( spec::controller::pressed( "B" ) ) keys.running = true;
|
|
if ( spec::controller::pressed( "X" ) ) keys.crouch = true, keys.walk = true;
|
|
if ( spec::controller::pressed( "Y" ) ) keys.vee = true;
|
|
if ( spec::controller::pressed( "L_TRIGGER" ) ) keys.left = true;
|
|
if ( spec::controller::pressed( "R_TRIGGER" ) ) keys.right = true;
|
|
if ( spec::controller::pressed( "START" ) ) keys.paused = true;
|
|
#endif
|
|
}
|
|
|
|
struct {
|
|
bool updateCamera = true;
|
|
bool deltaCrouch = false;
|
|
bool walking = false;
|
|
bool floored = true;
|
|
bool impulse = true;
|
|
bool noclipped = false;
|
|
uf::stl::string menu = "";
|
|
uf::stl::string targetAnimation = "";
|
|
} stats;
|
|
|
|
auto& metadata = this->getComponent<ext::PlayerBehavior::Metadata>();
|
|
auto& metadataJson = this->getComponent<uf::Serializer>();
|
|
#if UF_ENTITY_METADATA_USE_JSON
|
|
metadata.deserialize(self, metadataJson);
|
|
#endif
|
|
stats.menu = metadata.system.menu;
|
|
stats.impulse = metadata.system.physics.impulse;
|
|
stats.noclipped = metadata.system.noclipped;
|
|
stats.floored = fabs(physics.linear.velocity.y) < 0.01f || stats.noclipped;
|
|
struct {
|
|
float move = 4;
|
|
float walk = 1;
|
|
float run = 8;
|
|
float rotate = uf::physics::time::delta;
|
|
float limitSquared = 4*4;
|
|
} speed; {
|
|
speed.rotate *= metadata.system.physics.rotate;
|
|
speed.move = metadata.system.physics.move;
|
|
speed.run = metadata.system.physics.run / speed.move;
|
|
speed.walk = metadata.system.physics.walk / speed.move;
|
|
|
|
if ( stats.noclipped ) {
|
|
speed.move *= 4.0;
|
|
speed.run *= 2.0;
|
|
}
|
|
}
|
|
if ( !metadata.system.physics.collision ) {
|
|
stats.impulse = true;
|
|
}
|
|
if ( keys.running ) speed.move *= speed.run;
|
|
else if ( keys.walk ) speed.move *= speed.walk;
|
|
speed.limitSquared = speed.move * speed.move;
|
|
|
|
uf::Object* menu = (uf::Object*) scene.globalFindByName("Gui: Menu");
|
|
if ( !menu ) stats.menu = "";
|
|
// make assumptions
|
|
if ( stats.menu == "" && keys.paused ) {
|
|
stats.menu = "paused";
|
|
metadata.system.control = false;
|
|
uf::hooks.call("menu:Pause");
|
|
}
|
|
else if ( !metadata.system.control ) {
|
|
stats.menu = "menu";
|
|
} else if ( stats.menu == "" ) {
|
|
metadata.system.control = true;
|
|
} else {
|
|
metadata.system.control = false;
|
|
}
|
|
metadata.system.menu = stats.menu;
|
|
auto& collider = this->getComponent<pod::Bullet>();
|
|
if ( metadata.system.control ) {
|
|
{
|
|
TIMER(0.25, keys.vee && ) {
|
|
bool state = !stats.noclipped;
|
|
metadata.system.noclipped = state;
|
|
|
|
UF_MSG_DEBUG( (state ? "En" : "Dis") << "abled noclip: " << uf::vector::toString(transform.position));
|
|
if ( state ) {
|
|
#if UF_USE_BULLET
|
|
if ( collider.body ) {
|
|
collider.body->setGravity(btVector3(0,0.0,0));
|
|
collider.body->setCollisionFlags(collider.body->getCollisionFlags() | btCollisionObject::CF_NO_CONTACT_RESPONSE);
|
|
collider.body->setActivationState(DISABLE_SIMULATION);
|
|
}
|
|
#endif
|
|
} else {
|
|
#if UF_USE_BULLET
|
|
if ( collider.body ) {
|
|
collider.body->setGravity(btVector3(0,-9.81,0));
|
|
collider.body->setCollisionFlags(collider.body->getCollisionFlags() & ~btCollisionObject::CF_NO_CONTACT_RESPONSE);
|
|
collider.body->setActivationState(DISABLE_DEACTIVATION);
|
|
}
|
|
#endif
|
|
}
|
|
stats.noclipped = state;
|
|
}
|
|
}
|
|
|
|
if ( stats.floored ) {
|
|
pod::Transform<> translator = transform;
|
|
|
|
#if UF_USE_OPENVR
|
|
if ( ext::openvr::context ) {
|
|
bool useController = true;
|
|
translator.orientation = uf::quaternion::multiply( transform.orientation * pod::Vector4f{1,1,1,1}, useController ? (ext::openvr::controllerQuaternion( vr::Controller_Hand::Hand_Right ) * pod::Vector4f{1,1,1,1}) : ext::openvr::hmdQuaternion() );
|
|
translator = uf::transform::reorient( translator );
|
|
|
|
if ( !stats.noclipped ) {
|
|
translator.forward *= { 1, 0, 1 };
|
|
translator.right *= { 1, 0, 1 };
|
|
}
|
|
|
|
translator.forward = uf::vector::normalize( translator.forward );
|
|
translator.right = uf::vector::normalize( translator.right );
|
|
} else
|
|
#endif
|
|
if ( stats.noclipped ){
|
|
auto& cameraTransform = camera.getTransform();
|
|
// translator = uf::transform::flatten( cameraTransform );
|
|
translator.forward.y += cameraTransform.forward.y;
|
|
}
|
|
pod::Vector3f queued = {};
|
|
if ( keys.forward || keys.backwards ) {
|
|
float polarity = keys.forward ? 1 : -1;
|
|
float mag = uf::vector::magnitude(physics.linear.velocity); // * pod::Vector3{1, 0, 1});
|
|
if ( mag < speed.limitSquared ) {
|
|
mag = uf::vector::magnitude(physics.linear.velocity + translator.forward * speed.move * polarity);
|
|
} else mag = speed.limitSquared;
|
|
pod::Vector3 correction = translator.forward * ::sqrt(mag) * polarity;
|
|
|
|
if ( collider.body && !collider.shared ) {
|
|
queued += correction;
|
|
} else {
|
|
if ( stats.impulse && stats.noclipped ) {
|
|
physics.linear.velocity.x = correction.x;
|
|
physics.linear.velocity.z = correction.z;
|
|
|
|
if ( stats.noclipped ) physics.linear.velocity.y = correction.y;
|
|
} else {
|
|
correction *= uf::physics::time::delta;
|
|
transform.position.x += correction.x;
|
|
transform.position.z += correction.z;
|
|
|
|
if ( stats.noclipped ) transform.position.y += correction.y;
|
|
}
|
|
}
|
|
stats.updateCamera = (stats.walking = true);
|
|
}
|
|
if ( keys.left || keys.right ) {
|
|
float polarity = keys.right ? 1 : -1;
|
|
float mag = uf::vector::magnitude(physics.linear.velocity); // * pod::Vector3{1, 0, 1});
|
|
if ( mag < speed.limitSquared ) {
|
|
mag = uf::vector::magnitude(physics.linear.velocity + translator.right * speed.move * polarity);
|
|
} else mag = speed.limitSquared;
|
|
pod::Vector3 correction = translator.right * ::sqrt(mag) * polarity;
|
|
|
|
if ( collider.body && !collider.shared ) {
|
|
queued += correction;
|
|
} else {
|
|
if ( stats.impulse && stats.noclipped ) {
|
|
physics.linear.velocity.x = correction.x;
|
|
physics.linear.velocity.z = correction.z;
|
|
} else {
|
|
correction *= uf::physics::time::delta;
|
|
transform.position.x += correction.x;
|
|
transform.position.z += correction.z;
|
|
}
|
|
}
|
|
stats.updateCamera = (stats.walking = true);
|
|
}
|
|
if ( keys.left || keys.right || keys.forward || keys.backwards ) {
|
|
if ( collider.body && !collider.shared ) {
|
|
physics.linear.velocity.x = queued.x;
|
|
physics.linear.velocity.z = queued.z;
|
|
|
|
if ( stats.noclipped ) physics.linear.velocity.y = queued.y;
|
|
#if UF_USE_BULLET
|
|
ext::bullet::move( collider, physics.linear.velocity );
|
|
#endif
|
|
}
|
|
}
|
|
if ( !keys.forward && !keys.backwards && !keys.left && !keys.right ) {
|
|
if ( collider.body && !collider.shared ) {
|
|
physics.linear.velocity.x = 0;
|
|
physics.linear.velocity.z = 0;
|
|
|
|
if ( stats.noclipped ) physics.linear.velocity.y = 0;
|
|
#if UF_USE_BULLET
|
|
ext::bullet::move( collider, physics.linear.velocity );
|
|
#endif
|
|
}
|
|
}
|
|
if ( keys.jump ) {
|
|
pod::Vector3f yump = metadata.system.physics.jump;
|
|
if ( collider.body && !collider.shared ) {
|
|
if ( fabs(yump.x) > 0.001f ) physics.linear.velocity.x = yump.x;
|
|
if ( fabs(yump.y) > 0.001f ) physics.linear.velocity.y = yump.y;
|
|
if ( fabs(yump.z) > 0.001f ) physics.linear.velocity.z = yump.z;
|
|
#if UF_USE_BULLET
|
|
ext::bullet::move( collider, physics.linear.velocity );
|
|
#endif
|
|
} else {
|
|
transform.position += uf::vector::multiply(yump, uf::physics::time::delta);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( keys.lookLeft ) {
|
|
if ( collider.body && !collider.shared ) {
|
|
#if UF_USE_BULLET
|
|
ext::bullet::applyRotation( collider, transform.up, -speed.rotate );
|
|
#endif
|
|
} else {
|
|
uf::transform::rotate( transform, transform.up, -speed.rotate );
|
|
}
|
|
stats.updateCamera = true;
|
|
}
|
|
if ( keys.lookRight ) {
|
|
if ( collider.body && !collider.shared ) {
|
|
#if UF_USE_BULLET
|
|
ext::bullet::applyRotation( collider, transform.up, speed.rotate );
|
|
#endif
|
|
} else {
|
|
uf::transform::rotate( transform, transform.up, speed.rotate );
|
|
}
|
|
stats.updateCamera = true;
|
|
}
|
|
if ( keys.crouch ) {
|
|
pod::Vector3f yump = metadata.system.physics.jump;
|
|
if ( stats.noclipped ) {
|
|
if ( collider.body && !collider.shared ) {
|
|
if ( fabs(yump.x) > 0.001f ) physics.linear.velocity.x = -yump.x;
|
|
if ( fabs(yump.y) > 0.001f ) physics.linear.velocity.y = -yump.y;
|
|
if ( fabs(yump.z) > 0.001f ) physics.linear.velocity.z = -yump.z;
|
|
#if UF_USE_BULLET
|
|
ext::bullet::move( collider, physics.linear.velocity );
|
|
#endif
|
|
}
|
|
} else {
|
|
if ( !metadata.system.physics.collision ) {
|
|
transform.position -= uf::vector::multiply(yump, uf::physics::time::delta);
|
|
} else {
|
|
if ( !metadata.system.crouching ) stats.deltaCrouch = true;
|
|
metadata.system.crouching = true;
|
|
}
|
|
}
|
|
} else {
|
|
if ( metadata.system.crouching ) stats.deltaCrouch = true;
|
|
metadata.system.crouching = false;
|
|
}
|
|
}
|
|
if ( stats.noclipped && !keys.forward && !keys.backwards && !keys.left && !keys.right && !keys.jump && !keys.crouch ) {
|
|
if ( collider.body && !collider.shared ) {
|
|
physics.linear.velocity = {};
|
|
#if UF_USE_BULLET
|
|
ext::bullet::move( collider, physics.linear.velocity );
|
|
#endif
|
|
}
|
|
}
|
|
if ( stats.deltaCrouch ) {
|
|
float delta = metadata.system.physics.crouch;
|
|
if ( metadata.system.crouching ) camera.getTransform().position.y -= delta;
|
|
else camera.getTransform().position.y += delta;
|
|
stats.updateCamera = true;
|
|
}
|
|
#if UF_USE_OPENAL
|
|
if ( stats.floored ) {
|
|
if ( stats.walking ) {
|
|
auto& emitter = this->getComponent<uf::MappedSoundEmitter>();
|
|
int cycle = rand() % metadata.audio.footstep.list.size();
|
|
uf::stl::string filename = metadata.audio.footstep.list[cycle];
|
|
uf::Audio& footstep = emitter.has(filename) ? emitter.get(filename) : emitter.load(filename);
|
|
|
|
bool playing = false;
|
|
for ( uint i = 0; i < metadata.audio.footstep.list.size(); ++i ) {
|
|
if ( !emitter.has(metadata.audio.footstep.list[i]) ) continue;
|
|
uf::Audio& audio = emitter.get( metadata.audio.footstep.list[i] );
|
|
if ( audio.playing() ) playing = true;
|
|
}
|
|
if ( !playing ) {
|
|
// [0, 1]
|
|
float modulation = (rand() % 100) / 100.0;
|
|
// [0, 0.1]
|
|
modulation *= 0.1f;
|
|
// [-0.05, 0.05]
|
|
modulation -= 0.05f;
|
|
if ( keys.running ) modulation += 0.5f;
|
|
footstep.setPitch( 1 + modulation );
|
|
footstep.setVolume( metadata.audio.footstep.volume );
|
|
footstep.setPosition( transform.position );
|
|
|
|
footstep.setTime( 0 );
|
|
footstep.play();
|
|
}
|
|
// set animation to walk
|
|
stats.targetAnimation = "walk";
|
|
} else if ( !keys.jump ) {
|
|
stats.targetAnimation = "idle_wank";
|
|
}
|
|
}
|
|
#endif
|
|
#if !UF_ENV_DREAMCAST
|
|
// set animation to idle
|
|
if ( stats.targetAnimation != "" ) {
|
|
auto* playerModel = this->findByName("Player: Model");
|
|
if ( playerModel && playerModel->hasComponent<pod::Graph>() ) {
|
|
auto& graph = playerModel->getComponent<pod::Graph>();
|
|
bool should = true;
|
|
if ( graph.sequence.empty() && graph.sequence.front() == stats.targetAnimation ) should = false;
|
|
if ( should ) {
|
|
graph.settings.animations.loop = true;
|
|
uf::graph::animate( graph, stats.targetAnimation );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#if UF_USE_LUA && !UF_ENV_DREAMCAST
|
|
#define TRACK_ORIENTATION(ORIENTATION) {\
|
|
static pod::Quaternion<> storedCameraOrientation = ORIENTATION;\
|
|
const pod::Quaternion<> prevCameraOrientation = storedCameraOrientation;\
|
|
const pod::Quaternion<> curCameraOrientation = ORIENTATION;\
|
|
const pod::Quaternion<> deltaOrientation = uf::quaternion::multiply( curCameraOrientation, uf::quaternion::inverse( prevCameraOrientation ) ) ;\
|
|
const pod::Vector3f deltaAngles = uf::quaternion::eulerAngles( deltaOrientation );\
|
|
combinedDeltaAngles = uf::vector::add( combinedDeltaAngles, deltaAngles );\
|
|
combinedDeltaOrientation = uf::quaternion::multiply( deltaOrientation, combinedDeltaOrientation );\
|
|
storedCameraOrientation = ORIENTATION;\
|
|
}
|
|
{
|
|
pod::Quaternion<> combinedDeltaOrientation = {0,0,0,1};
|
|
pod::Vector3f combinedDeltaAngles = {};
|
|
TRACK_ORIENTATION(transform.orientation);
|
|
TRACK_ORIENTATION(camera.getTransform().orientation);
|
|
float magnitude = uf::quaternion::magnitude( combinedDeltaOrientation );
|
|
if ( magnitude > 0.0001f ) {
|
|
uf::Serializer payload;
|
|
payload["delta"] = uf::vector::encode( combinedDeltaOrientation );
|
|
payload["angle"]["pitch"] = combinedDeltaAngles.x;
|
|
payload["angle"]["yaw"] = combinedDeltaAngles.y;
|
|
payload["angle"]["roll"] = combinedDeltaAngles.z;
|
|
payload["magnitude"] = magnitude;
|
|
this->callHook("controller:Camera.Rotated", payload);
|
|
}
|
|
}
|
|
#endif
|
|
if ( stats.updateCamera ) camera.update(true);
|
|
|
|
#if UF_ENTITY_METADATA_USE_JSON
|
|
metadata.serialize(self, metadataJson);
|
|
#endif
|
|
}
|
|
|
|
void ext::PlayerBehavior::render( uf::Object& self ){}
|
|
void ext::PlayerBehavior::destroy( uf::Object& self ){}
|
|
void ext::PlayerBehavior::Metadata::serialize( uf::Object& self, uf::Serializer& serializer ){
|
|
auto& serializerSystem = serializer["system"];
|
|
auto& serializerSystemPhysics = serializerSystem["physics"];
|
|
auto& serializerAudioFootstep = serializer["audio"]["footstep"];
|
|
auto& serializerCamera = serializer["camera"];
|
|
auto& serializerCameraLimit = serializerCamera["limit"];
|
|
|
|
serializerSystem["menu"] = /*this->*/system.menu;
|
|
serializerSystem["control"] = /*this->*/system.control;
|
|
serializerSystem["crouching"] = /*this->*/system.crouching;
|
|
serializerSystem["noclipped"] = /*this->*/system.noclipped;
|
|
serializerSystemPhysics["impulse"] = /*this->*/system.physics.impulse;
|
|
serializerSystemPhysics["rotate"] = /*this->*/system.physics.rotate;
|
|
serializerSystemPhysics["move"] = /*this->*/system.physics.move;
|
|
serializerSystemPhysics["run"] = /*this->*/system.physics.run;
|
|
serializerSystemPhysics["walk"] = /*this->*/system.physics.walk;
|
|
serializerSystemPhysics["collision"] = /*this->*/system.physics.collision;
|
|
serializerSystemPhysics["jump"] = uf::vector::encode(/*this->*/system.physics.jump);
|
|
serializerSystemPhysics["crouch"] = /*this->*/system.physics.crouch;
|
|
serializerAudioFootstep["list"] = /*this->*/audio.footstep.list;
|
|
serializerAudioFootstep["volume"] = /*this->*/audio.footstep.volume;
|
|
serializerCamera["invert"] = uf::vector::encode(/*this->*/camera.invert);
|
|
serializerCameraLimit["current"] = uf::vector::encode(/*this->*/camera.limit.current);
|
|
serializerCameraLimit["minima"] = uf::vector::encode(/*this->*/camera.limit.min);
|
|
serializerCameraLimit["maxima"] = uf::vector::encode(/*this->*/camera.limit.max);
|
|
}
|
|
void ext::PlayerBehavior::Metadata::deserialize( uf::Object& self, uf::Serializer& serializer ){
|
|
auto& serializerSystem = serializer["system"];
|
|
auto& serializerAudioFootstep = serializer["audio"]["footstep"];
|
|
auto& serializerSystemPhysics = serializerSystem["physics"];
|
|
auto& serializerCamera = serializer["camera"];
|
|
auto& serializerCameraLimit = serializerCamera["limit"];
|
|
|
|
/*this->*/system.menu = serializerSystem["menu"].as<uf::stl::string>();
|
|
/*this->*/system.control = serializerSystem["control"].as<bool>();
|
|
/*this->*/system.crouching = serializerSystem["crouching"].as<bool>();
|
|
/*this->*/system.noclipped = serializerSystem["noclipped"].as<bool>();
|
|
/*this->*/system.physics.impulse = serializerSystemPhysics["impulse"].as<bool>();
|
|
/*this->*/system.physics.rotate = serializerSystemPhysics["rotate"].as<float>();
|
|
/*this->*/system.physics.move = serializerSystemPhysics["move"].as<float>();
|
|
/*this->*/system.physics.run = serializerSystemPhysics["run"].as<float>();
|
|
/*this->*/system.physics.walk = serializerSystemPhysics["walk"].as<float>();
|
|
/*this->*/system.physics.collision = serializerSystemPhysics["collision"].as<bool>();
|
|
/*this->*/system.physics.jump = uf::vector::decode(serializerSystemPhysics["jump"], pod::Vector3f{});
|
|
/*this->*/system.physics.crouch = serializerSystemPhysics["crouch"].as<float>();
|
|
ext::json::forEach( serializerAudioFootstep["list"], [&]( const ext::json::Value& value ){
|
|
/*this->*/audio.footstep.list.emplace_back(value);
|
|
});
|
|
/*this->*/audio.footstep.volume = serializerAudioFootstep["volume"].as<float>();
|
|
|
|
/*this->*/camera.invert = uf::vector::decode( serializerCamera["invert"], pod::Vector3t<bool>{false, false, false} );
|
|
/*this->*/camera.limit.current = uf::vector::decode( serializerCameraLimit["current"], pod::Vector3f{NAN, NAN, NAN} );
|
|
/*this->*/camera.limit.min = uf::vector::decode( serializerCameraLimit["minima"], pod::Vector3f{NAN, NAN, NAN} );
|
|
/*this->*/camera.limit.max = uf::vector::decode( serializerCameraLimit["maxima"], pod::Vector3f{NAN, NAN, NAN} );
|
|
|
|
// for ( uint_fast8_t i = 0; i < 3; ++i ) this->camera.limit.current[i] = serializerCameraLimit["current"][i].as<float>(NAN);
|
|
// for ( uint_fast8_t i = 0; i < 3; ++i ) this->camera.limit.min[i] = serializerCameraLimit["minima"][i].as<float>(NAN);
|
|
// for ( uint_fast8_t i = 0; i < 3; ++i ) this->camera.limit.max[i] = serializerCameraLimit["maxima"][i].as<float>(NAN);
|
|
}
|
|
#undef this |