game2006/server/gameserver/mapcollider.cc

#include "precompile.h"

#include <f8/udplog.h>

#include "mapcollider.h"

namespace mc
{

    static void Vec3_Read(glm::vec3& v, std::shared_ptr<a8::XObject> xobj)
    {
        v.x = xobj->At("x")->AsXValue().GetDouble() * MAP_SCALE;
        v.y = xobj->At("y")->AsXValue().GetDouble();
        v.z = xobj->At("z")->AsXValue().GetDouble() * MAP_SCALE;
    }

    static void Quat_Read(glm::quat& v, std::shared_ptr<a8::XObject> xobj)
    {
        v.x = xobj->At("x")->AsXValue().GetDouble();
        v.y = xobj->At("y")->AsXValue().GetDouble();
        v.z = xobj->At("z")->AsXValue().GetDouble();
        v.w = xobj->At("w")->AsXValue().GetDouble();
    }

    static void Bounds_Read(Bounds& v, std::shared_ptr<a8::XObject> xobj)
    {
        Vec3_Read(v.center, xobj->At("center"));
        Vec3_Read(v.size, xobj->At("size"));
    }

    void Transform::Read(std::shared_ptr<a8::XObject> xobj)
    {
        Vec3_Read(local_position, xobj->At("local_position"));
        Quat_Read(local_rotation, xobj->At("local_rotation"));
        Vec3_Read(local_scale, xobj->At("local_scale"));
    }

    void Collider::Read(std::shared_ptr<a8::XObject> xobj)
    {
        ca_type = xobj->At("ca_type")->AsXValue();
        if (ca_type < kCA_Floor || ca_type > kCA_End) {
            abort();
        }
        enabled = xobj->At("enabled")->AsXValue();
        is_trigger = xobj->At("is_trigger")->AsXValue();
        Bounds_Read(bounds, xobj->At("bounds"));
    }

    void BoxCollider::Read(std::shared_ptr<a8::XObject> xobj)
    {
        type = kBoxCollider;
        Collider::Read(xobj);
        Vec3_Read(center, xobj->At("center"));
        Vec3_Read(size, xobj->At("size"));
    }

    void MeshCollider::Read(std::shared_ptr<a8::XObject> xobj)
    {
        type = kMeshCollider;
        Collider::Read(xobj);
        {
            auto verts_xobj = xobj->At("mesh")->At("vertices");
            for (int i = 0; i < verts_xobj->Size(); ++i) {
                glm::vec3 v;
                Vec3_Read(v, verts_xobj->At(i));
                mesh.vertices.push_back(v);
            }
        }
        {
            auto trig_xobj = xobj->At("mesh")->At("triangles");
            for (int i = 0; i < trig_xobj->Size(); ++i) {
                mesh.raw_triangles.push_back(trig_xobj->At(i)->AsXValue().GetDouble());
            }
        }
        if (mesh.raw_triangles.size() % 3 != 0) {
            abort();
        }
        Bounds_Read(mesh.bounds, xobj->At("mesh")->At("bounds"));
    }

    void ColliderNode::Read(std::shared_ptr<a8::XObject> xobj)
    {
        name = xobj->At("name")->AsXValue().GetString();
        Bounds_Read(bounds, xobj->At("bounds"));
        transform.Read(xobj->At("transform"));
        {
            auto colliders_arr = xobj->At("colliders");
            for (int i = 0; i < colliders_arr->Size(); ++i) {
                auto collider_union_xobj = colliders_arr->At(i);
                switch (collider_union_xobj->At("type")->AsXValue().GetInt()) {
                case kBoxCollider:
                    {
                        Collider* c = new BoxCollider();
                        c->type = kBoxCollider;
                        c->Read(collider_union_xobj->At("box"));
                        colliders.push_back(c);
                    }
                    break;
                case kMeshCollider:
                    {
                        Collider* c = new MeshCollider();
                        c->type = kMeshCollider;
                        c->Read(collider_union_xobj->At("mesh"));
                        colliders.push_back(c);
                    }
                    break;
                default:
                    {
                        A8_ABORT();
                        break;
                    }
                }
            }
        }
        {
            auto childs_arr = xobj->At("childs");
            for (int i = 0; i < childs_arr->Size(); ++i) {
                ColliderNode* node = new ColliderNode();
                node->parent = this;
                node->Read(childs_arr->At(i));
                if (childs.find(node->name) != childs.end()) {
                    #if 1
                    f8::UdpLog::Instance()->Warning
                        (
                         "node->name:%s exists",
                         {
                             node->name
                         });
                    childs[node->name] = node;
                    #else
                    A8_ABORT();
                    #endif
                } else {
                    childs[node->name] = node;
                }
            }
        }
    }

    void RotateBounds(const glm::vec3& center,
                      const glm::vec3& size,
                      const glm::quat& quat,
                      std::vector<glm::vec3>& points)
    {
        glm::vec3 extends = size / 2.0f;
        std::vector<glm::vec3> dirs;
        //plane up
        dirs.push_back(glm::vec3(extends.x, extends.y, extends.z));
        dirs.push_back(glm::vec3(extends.x, extends.y, -extends.z));
        dirs.push_back(glm::vec3(-extends.x, extends.y, -extends.z));
        dirs.push_back(glm::vec3(-extends.x, extends.y, extends.z));
        //plane down
        dirs.push_back(glm::vec3(extends.x, -extends.y, extends.z));
        dirs.push_back(glm::vec3(extends.x, -extends.y, -extends.z));
        dirs.push_back(glm::vec3(-extends.x, -extends.y, -extends.z));
        dirs.push_back(glm::vec3(-extends.x, -extends.y, extends.z));
        for (const glm::vec3& dir : dirs) {
            points.push_back(center + dir);
        }
    }

}