Exemplo n.º 1
0
void ResolveInterActorCollisions(const float dt, PointColDetector &interPointCD,
        const int free_collcab, int collcabs[], int cabs[],
        collcab_rate_t inter_collcabrate[], node_t nodes[],
        const float collrange,
        ground_model_t &submesh_ground_model)
{
    Actor** actor_slots = RoR::App::GetSimController()->GetBeamFactory()->GetInternalActorSlots();

    for (int i=0; i<free_collcab; i++)
    {
        if (inter_collcabrate[i].rate > 0)
        {
            inter_collcabrate[i].distance++;
            inter_collcabrate[i].rate--;
            continue;
        }
        inter_collcabrate[i].rate = std::min(inter_collcabrate[i].distance, 12);
        inter_collcabrate[i].distance = 0;

        int tmpv = collcabs[i]*3;
        const auto no = &nodes[cabs[tmpv]];
        const auto na = &nodes[cabs[tmpv+1]];
        const auto nb = &nodes[cabs[tmpv+2]];

        interPointCD.query(no->AbsPosition
                , na->AbsPosition
                , nb->AbsPosition, collrange);

        if (interPointCD.hit_count > 0)
        {
            // setup transformation of points to triangle local coordinates
            const Triangle triangle(na->AbsPosition, nb->AbsPosition, no->AbsPosition);
            const CartesianToTriangleTransform transform(triangle);

            for (int h=0; h<interPointCD.hit_count; h++)
            {
                const auto hitnodeid = interPointCD.hit_list[h]->node_id;
                const auto hit_actor_id = interPointCD.hit_list[h]->actor_id;
                const auto hitnode = &actor_slots[hit_actor_id]->ar_nodes[hitnodeid];
                const Actor* hit_actor = actor_slots[hit_actor_id];

                // transform point to triangle local coordinates
                const auto local_point = transform(hitnode->AbsPosition);

                // collision test
                const bool is_colliding = InsideTriangleTest(local_point, collrange);
                if (is_colliding)
                {
                    inter_collcabrate[i].rate = 0;

                    const auto coord = local_point.barycentric;
                    auto distance   = local_point.distance;
                    auto normal     = triangle.normal();

                    // adapt in case the collision is occuring on the backface of the triangle
                    const auto neighbour_node_ids = hit_actor->ar_node_to_node_connections[hitnodeid];
                    const bool is_backface = BackfaceCollisionTest(distance, normal, *no, neighbour_node_ids, hit_actor->ar_nodes);
                    if (is_backface)
                    {
                        // flip surface normal and distance to triangle plane
                        normal   = -normal;
                        distance = -distance;
                    }

                    const auto penetration_depth = collrange - distance;

                    ResolveCollisionForces(penetration_depth, *hitnode, *na, *nb, *no, coord.alpha,
                            coord.beta, coord.gamma, normal, dt, submesh_ground_model);
                }
            }
        }
        else
        {
            inter_collcabrate[i].rate++;
        }
    }
}
Exemplo n.º 2
0
void ResolveIntraActorCollisions(const float dt, PointColDetector &intraPointCD,
        const int free_collcab, int collcabs[], int cabs[],
        collcab_rate_t intra_collcabrate[], node_t nodes[],
        const float collrange,
        ground_model_t &submesh_ground_model)
{
    for (int i=0; i<free_collcab; i++)
    {
        if (intra_collcabrate[i].rate > 0)
        {
            intra_collcabrate[i].distance++;
            intra_collcabrate[i].rate--;
            continue;
        }
        if (intra_collcabrate[i].distance > 0)
        {
            intra_collcabrate[i].rate = std::min(intra_collcabrate[i].distance, 12);
            intra_collcabrate[i].distance = 0;
        }

        int tmpv = collcabs[i]*3;
        const auto no = &nodes[cabs[tmpv]];
        const auto na = &nodes[cabs[tmpv+1]];
        const auto nb = &nodes[cabs[tmpv+2]];

        intraPointCD.query(no->AbsPosition
                , na->AbsPosition
                , nb->AbsPosition, collrange);

        bool collision = false;

        if (intraPointCD.hit_count > 0)
        {
            // setup transformation of points to triangle local coordinates
            const Triangle triangle(na->AbsPosition, nb->AbsPosition, no->AbsPosition);
            const CartesianToTriangleTransform transform(triangle);

            for (int h=0; h<intraPointCD.hit_count; h++)
            {
                const auto hitnodeid = intraPointCD.hit_list[h]->node_id;
                const auto hitnode = &nodes[hitnodeid];

                //ignore wheel/chassis self contact
                if (hitnode->iswheel) continue;
                if (no == hitnode || na == hitnode || nb == hitnode) continue;

                // transform point to triangle local coordinates
                const auto local_point = transform(hitnode->AbsPosition);

                // collision test
                const bool is_colliding = InsideTriangleTest(local_point, collrange);
                if (is_colliding)
                {
                    collision = true;

                    const auto coord = local_point.barycentric;
                    auto distance = local_point.distance;
                    auto normal   = triangle.normal();

                    // adapt in case the collision is occuring on the backface of the triangle
                    if (distance < 0) 
                    {
                        // flip surface normal and distance to triangle plane
                        normal   = -normal;
                        distance = -distance;
                    }

                    const auto penetration_depth = collrange - distance;

                    ResolveCollisionForces(penetration_depth, *hitnode, *na, *nb, *no, coord.alpha,
                            coord.beta, coord.gamma, normal, dt, submesh_ground_model);
                }
            }
        }

        if (collision)
        {
            intra_collcabrate[i].rate = -20000;
        }
        else
        {
            intra_collcabrate[i].rate++;
        }
    }
}
Exemplo n.º 3
0
void ResolveInterActorCollisions(const float dt, PointColDetector &interPointCD,
        const int free_collcab, int collcabs[], int cabs[],
        collcab_rate_t inter_collcabrate[], node_t nodes[],
        const float collrange,
        ground_model_t &submesh_ground_model)
{
    for (int i=0; i<free_collcab; i++)
    {
        if (inter_collcabrate[i].rate > 0)
        {
            inter_collcabrate[i].distance++;
            inter_collcabrate[i].rate--;
            continue;
        }
        inter_collcabrate[i].rate = std::min(inter_collcabrate[i].distance, 12);
        inter_collcabrate[i].distance = 0;

        int tmpv = collcabs[i]*3;
        const auto no = &nodes[cabs[tmpv]];
        const auto na = &nodes[cabs[tmpv+1]];
        const auto nb = &nodes[cabs[tmpv+2]];

        interPointCD.query(no->AbsPosition
                , na->AbsPosition
                , nb->AbsPosition, collrange);

        if (!interPointCD.hit_list.empty())
        {
            // setup transformation of points to triangle local coordinates
            const Triangle triangle(na->AbsPosition, nb->AbsPosition, no->AbsPosition);
            const CartesianToTriangleTransform transform(triangle);

            for (auto h : interPointCD.hit_list)
            {
                const auto hit_actor = h->actor;
                const auto hitnode = &hit_actor->ar_nodes[h->node_id];

                // transform point to triangle local coordinates
                const auto local_point = transform(hitnode->AbsPosition);

                // collision test
                const bool is_colliding = InsideTriangleTest(local_point, collrange);
                if (is_colliding)
                {
                    inter_collcabrate[i].rate = 0;

                    const auto coord = local_point.barycentric;
                    auto distance   = local_point.distance;
                    auto normal     = triangle.normal();

                    // adapt in case the collision is occuring on the backface of the triangle
                    const auto neighbour_node_ids = hit_actor->ar_node_to_node_connections[h->node_id];
                    const bool is_backface = BackfaceCollisionTest(distance, normal, *no, neighbour_node_ids, hit_actor->ar_nodes);
                    if (is_backface)
                    {
                        // flip surface normal and distance to triangle plane
                        normal   = -normal;
                        distance = -distance;
                    }

                    const auto penetration_depth = collrange - distance;

                    const bool remote = (hit_actor->ar_sim_state == Actor::SimState::NETWORKED_OK);

                    ResolveCollisionForces(penetration_depth, *hitnode, *na, *nb, *no, coord.alpha,
                            coord.beta, coord.gamma, normal, dt, remote, submesh_ground_model);

                    hitnode->nd_last_collision_gm = &submesh_ground_model;
                    hitnode->nd_has_mesh_contact = true;
                    na->nd_has_mesh_contact = true;
                    nb->nd_has_mesh_contact = true;
                    no->nd_has_mesh_contact = true;
                }
            }
        }
        else
        {
            inter_collcabrate[i].rate++;
        }
    }
}