From cb1769acea0dde80d9019f1e150b2273cac11fd6 Mon Sep 17 00:00:00 2001 From: Benau Date: Wed, 27 Feb 2019 11:04:49 +0800 Subject: [PATCH] Use btTransform and normal compression if possible --- src/karts/abstract_kart_animation.cpp | 18 +++++++++---- src/karts/abstract_kart_animation.hpp | 3 +++ src/karts/cannon_animation.cpp | 3 +++ src/karts/explosion_animation.cpp | 30 ++++++++++++++------- src/karts/explosion_animation.hpp | 3 +++ src/karts/rescue_animation.cpp | 34 ++++++++++++----------- src/karts/rescue_animation.hpp | 9 +++---- src/modes/ctf_flag.cpp | 31 ++++++++++++--------- src/modes/ctf_flag.hpp | 11 ++++---- src/utils/mini_glm.hpp | 39 +++++++++++++++++++++++++++ 10 files changed, 129 insertions(+), 52 deletions(-) diff --git a/src/karts/abstract_kart_animation.cpp b/src/karts/abstract_kart_animation.cpp index e4cfe0490..e4ec8391d 100644 --- a/src/karts/abstract_kart_animation.cpp +++ b/src/karts/abstract_kart_animation.cpp @@ -29,6 +29,7 @@ #include "physics/physics.hpp" #include "physics/triangle_mesh.hpp" #include "tracks/track.hpp" +#include "utils/mini_glm.hpp" #include @@ -72,6 +73,8 @@ AbstractKartAnimation::AbstractKartAnimation(AbstractKart* kart, kart->setSquash(0.0f, 0.0f); } } + MiniGLM::compressbtTransform(m_created_transform, + m_created_transform_compressed); } // AbstractKartAnimation // ---------------------------------------------------------------------------- @@ -179,9 +182,10 @@ float AbstractKartAnimation::getMaximumHeight(const Vec3& up_vector, void AbstractKartAnimation::saveState(BareNetworkString* buffer) { buffer->addUInt32(m_created_ticks); - buffer->add(m_created_transform.getOrigin()); - btQuaternion q = m_created_transform.getRotation(); - buffer->add(q); + buffer->addInt24(m_created_transform_compressed[0]) + .addInt24(m_created_transform_compressed[1]) + .addInt24(m_created_transform_compressed[2]) + .addUInt32(m_created_transform_compressed[3]); } // saveState // ---------------------------------------------------------------------------- @@ -190,6 +194,10 @@ void AbstractKartAnimation::saveState(BareNetworkString* buffer) void AbstractKartAnimation::restoreBasicState(BareNetworkString* buffer) { m_created_ticks = buffer->getUInt32(); - m_created_transform.setOrigin(buffer->getVec3()); - m_created_transform.setRotation(buffer->getQuat()); + m_created_transform_compressed[0] = buffer->getInt24(); + m_created_transform_compressed[1] = buffer->getInt24(); + m_created_transform_compressed[2] = buffer->getInt24(); + m_created_transform_compressed[3] = buffer->getUInt32(); + m_created_transform = + MiniGLM::decompressbtTransform(m_created_transform_compressed); } // restoreBasicState diff --git a/src/karts/abstract_kart_animation.hpp b/src/karts/abstract_kart_animation.hpp index bc831dc6d..262971098 100644 --- a/src/karts/abstract_kart_animation.hpp +++ b/src/karts/abstract_kart_animation.hpp @@ -67,6 +67,9 @@ protected: * to recreate the animation with the same one. */ btTransform m_created_transform; + /* Compressed values for server to send to avoid compressing everytime. */ + int m_created_transform_compressed[4]; + void resetPowerUp(); // ------------------------------------------------------------------------ void restoreBasicState(BareNetworkString* buffer); diff --git a/src/karts/cannon_animation.cpp b/src/karts/cannon_animation.cpp index 29cc0592f..e4ac1e643 100644 --- a/src/karts/cannon_animation.cpp +++ b/src/karts/cannon_animation.cpp @@ -29,6 +29,7 @@ #include "network/network_string.hpp" #include "tracks/check_cannon.hpp" #include "tracks/check_manager.hpp" +#include "utils/mini_glm.hpp" #include "LinearMath/btTransform.h" @@ -75,6 +76,8 @@ CannonAnimation::CannonAnimation(Flyable* flyable, CheckCannon* cc) { m_flyable = flyable; m_created_transform = m_flyable->getTrans(); + MiniGLM::compressbtTransform(m_created_transform, + m_created_transform_compressed); m_check_cannon = cc; init(cc->getIpo()->clone(), cc->getLeftPoint(), cc->getRightPoint(), cc->getTargetLeft(), cc->getTargetRight(), /*skid_rot*/0); diff --git a/src/karts/explosion_animation.cpp b/src/karts/explosion_animation.cpp index 2fe1f93b3..a255efec1 100644 --- a/src/karts/explosion_animation.cpp +++ b/src/karts/explosion_animation.cpp @@ -27,6 +27,9 @@ #include "network/network_string.hpp" #include "race/race_manager.hpp" #include "tracks/track.hpp" +#include "utils/mini_glm.hpp" + +#include /** A static create function that does only create an explosion if * the explosion happens to be close enough to affect the kart. @@ -82,6 +85,8 @@ ExplosionAnimation *ExplosionAnimation::create(AbstractKart *kart) ExplosionAnimation::ExplosionAnimation(AbstractKart* kart, bool direct_hit) : AbstractKartAnimation(kart, "ExplosionAnimation") { + memset(m_reset_trans_compressed, 0, 16); + Vec3 normal = m_created_transform.getBasis().getColumn(1).normalized(); // Put the kart back to its own flag base like rescue if direct hit in CTF bool reset = race_manager->getMinorMode() == RaceManager::MINOR_MODE_CAPTURE_THE_FLAG && direct_hit; @@ -92,11 +97,13 @@ ExplosionAnimation::ExplosionAnimation(AbstractKart* kart, bool direct_hit) btTransform reset_trans = m_kart->getTrans(); m_kart->getBody()->setCenterOfMassTransform(prev_trans); m_kart->setTrans(prev_trans); - init(direct_hit, m_kart->getNormal(), reset_trans); + MiniGLM::compressbtTransform(reset_trans, + m_reset_trans_compressed); + init(direct_hit, normal, reset_trans); } else { - init(direct_hit, m_kart->getNormal(), + init(direct_hit, normal, btTransform(btQuaternion(0.0f, 0.0f, 0.0f, 1.0f))); } @@ -121,15 +128,19 @@ ExplosionAnimation::ExplosionAnimation(AbstractKart* kart, BareNetworkString* b) void ExplosionAnimation::restoreData(BareNetworkString* b) { bool direct_hit = b->getUInt8() == 1; - Vec3 normal = b->getVec3(); + Vec3 normal = m_created_transform.getBasis().getColumn(1).normalized(); btTransform reset_transform = btTransform(btQuaternion(0.0f, 0.0f, 0.0f, 1.0f)); if (race_manager->getMinorMode() == RaceManager::MINOR_MODE_CAPTURE_THE_FLAG && direct_hit) { - reset_transform.setOrigin(b->getVec3()); - reset_transform.setRotation(b->getQuat()); + m_reset_trans_compressed[0] = b->getInt24(); + m_reset_trans_compressed[1] = b->getInt24(); + m_reset_trans_compressed[2] = b->getInt24(); + m_reset_trans_compressed[3] = b->getUInt32(); + reset_transform = + MiniGLM::decompressbtTransform(m_reset_trans_compressed); } init(direct_hit, normal, reset_transform); } // restoreData @@ -288,13 +299,14 @@ bool ExplosionAnimation::hasResetAlready() const void ExplosionAnimation::saveState(BareNetworkString* buffer) { AbstractKartAnimation::saveState(buffer); - buffer->addUInt8(m_direct_hit ? 1 : 0).add(m_normal); + buffer->addUInt8(m_direct_hit ? 1 : 0); if (race_manager->getMinorMode() == RaceManager::MINOR_MODE_CAPTURE_THE_FLAG && m_direct_hit) { - buffer->add(m_reset_trans.getOrigin()); - btQuaternion q = m_reset_trans.getRotation(); - buffer->add(q); + buffer->addInt24(m_reset_trans_compressed[0]) + .addInt24(m_reset_trans_compressed[1]) + .addInt24(m_reset_trans_compressed[2]) + .addUInt32(m_reset_trans_compressed[3]); } } // saveState diff --git a/src/karts/explosion_animation.hpp b/src/karts/explosion_animation.hpp index e3f672af1..5f002dbdb 100644 --- a/src/karts/explosion_animation.hpp +++ b/src/karts/explosion_animation.hpp @@ -58,6 +58,9 @@ friend class KartRewinder; /** Used for reset kart back to flag base in CTF. */ btTransform m_reset_trans; + /* Compressed values for server to send to avoid compressing everytime. */ + int m_reset_trans_compressed[4]; + bool m_direct_hit; // ------------------------------------------------------------------------ diff --git a/src/karts/rescue_animation.cpp b/src/karts/rescue_animation.cpp index 587f14347..3dba636be 100644 --- a/src/karts/rescue_animation.cpp +++ b/src/karts/rescue_animation.cpp @@ -26,6 +26,7 @@ #include "modes/follow_the_leader.hpp" #include "modes/three_strikes_battle.hpp" #include "network/network_string.hpp" +#include "utils/mini_glm.hpp" #include "ISceneNode.h" @@ -46,9 +47,10 @@ RescueAnimation::RescueAnimation(AbstractKart* kart, bool is_auto_rescue) World::getWorld()->moveKartAfterRescue(kart); btTransform rescue_transform = kart->getTrans(); + MiniGLM::compressbtTransform(rescue_transform, + m_rescue_transform_compressed); kart->getBody()->setCenterOfMassTransform(prev_trans); kart->setTrans(prev_trans); - m_created_transform = prev_trans; // Determine maximum rescue height with up-raycast float max_height = m_kart->getKartProperties()->getRescueHeight(); @@ -59,7 +61,7 @@ RescueAnimation::RescueAnimation(AbstractKart* kart, bool is_auto_rescue) float timer = m_kart->getKartProperties()->getRescueDuration(); float velocity = max_height / timer; - init(rescue_transform, velocity, up_vector); + init(rescue_transform, velocity); m_kart->getAttachment()->clear(); // Add a hit unless it was auto-rescue @@ -103,12 +105,14 @@ RescueAnimation::RescueAnimation(AbstractKart* kart, BareNetworkString* b) //----------------------------------------------------------------------------- void RescueAnimation::restoreData(BareNetworkString* b) { - btTransform rescue_transform; - rescue_transform.setOrigin(b->getVec3()); - rescue_transform.setRotation(b->getQuat()); + m_rescue_transform_compressed[0] = b->getInt24(); + m_rescue_transform_compressed[1] = b->getInt24(); + m_rescue_transform_compressed[2] = b->getInt24(); + m_rescue_transform_compressed[3] = b->getUInt32(); + btTransform rescue_transform = + MiniGLM::decompressbtTransform(m_rescue_transform_compressed); float velocity = b->getFloat(); - Vec3 up_vector = b->getVec3(); - init(rescue_transform, velocity, up_vector); + init(rescue_transform, velocity); } // restoreData //----------------------------------------------------------------------------- @@ -117,14 +121,13 @@ void RescueAnimation::restoreData(BareNetworkString* b) * time. */ void RescueAnimation::init(const btTransform& rescue_transform, - float velocity, const Vec3& up_vector) + float velocity) { m_rescue_transform = rescue_transform; float timer = m_kart->getKartProperties()->getRescueDuration(); m_end_ticks = m_created_ticks + stk_config->time2Ticks(timer); m_rescue_moment = m_created_ticks + stk_config->time2Ticks(timer * 0.4f); m_velocity = velocity; - m_up_vector = up_vector; } // init //----------------------------------------------------------------------------- @@ -152,7 +155,7 @@ void RescueAnimation::update(int ticks) float dur = stk_config->ticks2Time(m_end_ticks - m_rescue_moment - (World::getWorld()->getTicksSinceStart() - m_rescue_moment)); Vec3 xyz = m_rescue_transform.getOrigin() + - dur * m_velocity * m_up_vector; + dur * m_velocity * m_rescue_transform.getBasis().getColumn(1); m_kart->setXYZ(xyz); m_kart->setRotation(m_rescue_transform.getRotation()); } @@ -161,7 +164,7 @@ void RescueAnimation::update(int ticks) float dur = stk_config->ticks2Time( World::getWorld()->getTicksSinceStart() - m_created_ticks); Vec3 xyz = m_created_transform.getOrigin() + - dur * m_velocity * m_up_vector; + dur * m_velocity * m_created_transform.getBasis().getColumn(1); m_kart->setXYZ(xyz); m_kart->setRotation(m_created_transform.getRotation()); } @@ -191,10 +194,11 @@ void RescueAnimation::updateGraphics(float dt) void RescueAnimation::saveState(BareNetworkString* buffer) { AbstractKartAnimation::saveState(buffer); - buffer->add(m_rescue_transform.getOrigin()); - btQuaternion q = m_rescue_transform.getRotation(); - buffer->add(q); - buffer->addFloat(m_velocity).add(m_up_vector); + buffer->addInt24(m_rescue_transform_compressed[0]) + .addInt24(m_rescue_transform_compressed[1]) + .addInt24(m_rescue_transform_compressed[2]) + .addUInt32(m_rescue_transform_compressed[3]); + buffer->addFloat(m_velocity); } // saveState // ---------------------------------------------------------------------------- diff --git a/src/karts/rescue_animation.hpp b/src/karts/rescue_animation.hpp index 67c4c5c71..18ba86830 100644 --- a/src/karts/rescue_animation.hpp +++ b/src/karts/rescue_animation.hpp @@ -32,9 +32,6 @@ class RescueAnimation: public AbstractKartAnimation { protected: friend class KartRewinder; - /** Column 1 of btTransform of kart. */ - Vec3 m_up_vector; - /** The velocity with which the kart is moved. */ float m_velocity; @@ -48,13 +45,15 @@ friend class KartRewinder; /* Final transformation to place kart. */ btTransform m_rescue_transform; + /* Compressed values for server to send to avoid compressing everytime. */ + int m_rescue_transform_compressed[4]; + // ------------------------------------------------------------------------ RescueAnimation(AbstractKart* kart, BareNetworkString* b); // ------------------------------------------------------------------------ void restoreData(BareNetworkString* b); // ------------------------------------------------------------------------ - void init(const btTransform& rescue_transform, float velocity, - const Vec3& up_vector); + void init(const btTransform& rescue_transform, float velocity); public: RescueAnimation(AbstractKart* kart, bool is_auto_rescue = false); diff --git a/src/modes/ctf_flag.cpp b/src/modes/ctf_flag.cpp index ee5ffa6f8..4cbb7e594 100644 --- a/src/modes/ctf_flag.cpp +++ b/src/modes/ctf_flag.cpp @@ -30,17 +30,15 @@ const Vec3 g_kart_flag_offset(0.0, 0.2f, -0.5f); // ============================================================================ BareNetworkString* CTFFlag::saveState(std::vector* ru) { - using namespace MiniGLM; ru->push_back(getUniqueIdentity()); BareNetworkString* buffer = new BareNetworkString(); buffer->addUInt8(m_flag_status); if (m_flag_status == OFF_BASE) { - Vec3 normal = quatRotate(m_flag_trans.getRotation(), - Vec3(0.0f, 1.0f, 0.0f)); - buffer->add(m_flag_trans.getOrigin()); - buffer->addUInt32( - compressVector3(Vec3(normal.normalize()).toIrrVector())); + buffer->addInt24(m_off_base_compressed[0]) + .addInt24(m_off_base_compressed[1]) + .addInt24(m_off_base_compressed[2]) + .addUInt32(m_off_base_compressed[3]); buffer->addUInt16(m_ticks_since_off_base); } return buffer; @@ -53,12 +51,11 @@ void CTFFlag::restoreState(BareNetworkString* buffer, int count) m_flag_status = buffer->getUInt8(); if (m_flag_status == OFF_BASE) { - Vec3 origin = buffer->getVec3(); - uint32_t normal_packed = buffer->getUInt32(); - Vec3 normal = decompressVector3(normal_packed); - m_flag_trans.setOrigin(origin); - m_flag_trans.setRotation( - shortestArcQuat(Vec3(0.0f, 1.0f, 0.0f), normal)); + m_off_base_compressed[0] = buffer->getInt24(); + m_off_base_compressed[1] = buffer->getInt24(); + m_off_base_compressed[2] = buffer->getInt24(); + m_off_base_compressed[3] = buffer->getUInt32(); + m_flag_trans = decompressbtTransform(m_off_base_compressed); m_ticks_since_off_base = buffer->getUInt16(); } updateFlagTrans(m_flag_trans); @@ -120,3 +117,13 @@ void CTFFlag::updateFlagGraphics(irr::scene::IAnimatedMeshSceneNode* flag_node) flag_node->setAnimationSpeed(25.0f); } } // updateFlagPosition + +// ---------------------------------------------------------------------------- +void CTFFlag::dropFlagAt(const btTransform& t) +{ + m_flag_status = OFF_BASE; + m_ticks_since_off_base = 0; + m_flag_trans = t; + using namespace MiniGLM; + compressbtTransform(m_flag_trans, m_off_base_compressed); +} // updateFlagPosition diff --git a/src/modes/ctf_flag.hpp b/src/modes/ctf_flag.hpp index e9c500b7c..3ad658b22 100644 --- a/src/modes/ctf_flag.hpp +++ b/src/modes/ctf_flag.hpp @@ -23,6 +23,7 @@ #include "utils/vec3.hpp" #include "LinearMath/btTransform.h" +#include enum FlagColor : unsigned int { @@ -58,6 +59,8 @@ private: FlagColor m_flag_color; + /* Set by dropFlagAt to pre-compressed the dropped flag transformation. */ + int m_off_base_compressed[4]; public: // ------------------------------------------------------------------------ CTFFlag(FlagColor fc, const btTransform& base_trans) @@ -70,6 +73,7 @@ public: m_flag_trans.setRotation(btQuaternion(0.0f, 0.0f, 0.0f, 1.0f)); m_flag_color = fc; m_ticks_since_off_base = 0; + memset(m_off_base_compressed, 0, 16); } // ------------------------------------------------------------------------ virtual void saveTransform() {} @@ -116,12 +120,7 @@ public: updateFlagTrans(); } // ------------------------------------------------------------------------ - void dropFlagAt(const btTransform& t) - { - m_flag_status = OFF_BASE; - m_ticks_since_off_base = 0; - m_flag_trans = t; - } + void dropFlagAt(const btTransform& t); // ------------------------------------------------------------------------ bool isInBase() const { return m_flag_status == IN_BASE; } // ------------------------------------------------------------------------ diff --git a/src/utils/mini_glm.hpp b/src/utils/mini_glm.hpp index a6f7ceb38..8211ba4c8 100644 --- a/src/utils/mini_glm.hpp +++ b/src/utils/mini_glm.hpp @@ -19,6 +19,7 @@ #define HEADER_MINI_GLM_HPP #include "LinearMath/btQuaternion.h" +#include "LinearMath/btTransform.h" #include "utils/vec3.hpp" #include @@ -29,6 +30,8 @@ #include #include +#include "irrMath.h" + using namespace irr; // GLM without template @@ -565,6 +568,42 @@ namespace MiniGLM return compressVector3(tangent) | 1 << 30; } // quickTangent // ------------------------------------------------------------------------ + inline void compressbtTransform(btTransform& cur_t, + int* compressed_data = NULL) + { + int x = (int)(cur_t.getOrigin().x() * 1000.0f); + int y = (int)(cur_t.getOrigin().y() * 1000.0f); + int z = (int)(cur_t.getOrigin().z() * 1000.0f); + x = core::clamp(x, -8388608, 8388607); + y = core::clamp(y, -8388608, 8388607); + z = core::clamp(z, -8388608, 8388607); + uint32_t compressed_q = compressQuaternion(cur_t.getRotation()); + cur_t.setOrigin(btVector3( + (float)x / 1000.0f, + (float)y / 1000.0f, + (float)z / 1000.0f)); + cur_t.setRotation(decompressbtQuaternion(compressed_q)); + if (compressed_data) + { + compressed_data[0] = x; + compressed_data[1] = y; + compressed_data[2] = z; + compressed_data[3] = (int)compressed_q; + } + } // compressbtTransform + // ------------------------------------------------------------------------ + inline btTransform decompressbtTransform(int* compressed_data) + { + btTransform trans; + trans.setOrigin(btVector3( + (float)compressed_data[0] / 1000.0f, + (float)compressed_data[1] / 1000.0f, + (float)compressed_data[2] / 1000.0f)); + trans.setRotation(decompressbtQuaternion( + (uint32_t)compressed_data[3])); + return trans; + } // decompressbtTransform + // ------------------------------------------------------------------------ void unitTesting(); }