예제 #1
0
THREAD_RETURN pool_runner_thread(THREAD_ARGUMENTS parameters) {
    /* allocates space for the work thread task */
    struct thread_pool_task_t *work_thread_task;

    /* retrieves the thread pool from the arguments */
    struct thread_pool_t *thread_pool = (struct thread_pool_t *) parameters;

    /* ierates continuously */
    while(TRUE) {
        /* locks the task condition lock */
        CONDITION_LOCK(thread_pool->task_condition, thread_pool->task_condition_lock);

        /* iterates while the task queue is empty */
        while(thread_pool->task_queue->size == 0) {
            /* waits for the task condition */
            CONDITION_WAIT(thread_pool->task_condition, thread_pool->task_condition_lock);
        }

        /* retrieves the work thread task */
        pop_value_linked_list(thread_pool->task_queue, (void **) &work_thread_task, 0);

        /* unlock the task condition lock */
        CONDITION_UNLOCK(thread_pool->task_condition, thread_pool->task_condition_lock);

        /* calls the start function */
        work_thread_task->start_function(NULL);
    }

    /* returns valid */
    return 0;
}
예제 #2
0
void RigidBodyNode::set_kinematic(bool kinematic) {
    CONDITION_LOCK(ph_, ph_->lock());
    if (kinematic) {
        body_->setCollisionFlags(body_->getCollisionFlags() |
                                 btCollisionObject::CF_KINEMATIC_OBJECT);
        body_->setActivationState(DISABLE_DEACTIVATION);
    } else {
        body_->setCollisionFlags(body_->getCollisionFlags() &
                                 ~btCollisionObject::CF_KINEMATIC_OBJECT);
        body_->activate(true);
    }
}
예제 #3
0
void RigidBodyNode::set_mass(float mass) {
    bool was_static(mass_ == 0.f && mass > 0.f && has_static_shapes_);
    mass_ = mass;

    CONDITION_LOCK(ph_, ph_->lock());
    if (mass > 0.f && !was_static)
        body_->getCollisionShape()->calculateLocalInertia(mass_, inertia_);
    body_->setMassProps(mass_, inertia_);
    //Resync associated shapes if the body becomes dynamic and some of the
    //associated shapes do not support dynamic bodies.
    if (was_static)
        sync_shapes(true);
}
예제 #4
0
void insert_task_thread_pool(struct thread_pool_t *thread_pool, struct thread_pool_task_t *thread_pool_task) {
    /* locks the task condition lock */
    CONDITION_LOCK(thread_pool->task_condition, thread_pool->task_condition_lock);

    /* adds the the thread pool task to the task queue */
    append_value_linked_list(thread_pool->task_queue, thread_pool_task);

    /* signals the task condition */
    CONDITION_SIGNAL(thread_pool->task_condition);

    /* unlock the task condition lock */
    CONDITION_UNLOCK(thread_pool->task_condition, thread_pool->task_condition_lock);
}
예제 #5
0
/* virtual */ void RigidBodyNode::set_transform(const math::mat4& transform) {
    //TODO: It's nice to have this function block free
    //      (along with rotate and translate functions)
    CONDITION_LOCK(ph_, ph_->lock());

    if (body_->isKinematicObject()) {
        motion_state_->setWorldTransform(math::mat4_to_btTransform(transform));
    } else {
        body_->setWorldTransform(math::mat4_to_btTransform(transform));
        body_->activate();
    }

    set_dirty();
}
예제 #6
0
/* virtual */ void RigidBodyNode::translate(float x,
                                            float y,
                                            float z) {
    CONDITION_LOCK(ph_, ph_->lock());
    if (body_->isKinematicObject()) {
        btTransform t;
        motion_state_->getWorldTransform(t);
        t.setOrigin(t.getOrigin() + btVector3(x, y, z));
        motion_state_->setWorldTransform(t);
    } else {
        btTransform t(body_->getWorldTransform());
        t.setOrigin(t.getOrigin() + btVector3(x, y, z));
        body_->setWorldTransform(t);
        body_->activate();
    }

    set_dirty();
}
예제 #7
0
void RigidBodyNode::clear_forces() {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->clearForces();
}
예제 #8
0
void RigidBodyNode::apply_central_impulse(const math::vec3& impulse) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->applyCentralImpulse(math::vec3_to_btVector3(impulse));
}
예제 #9
0
void RigidBodyNode::apply_impulse(const math::vec3& impulse,
                                  const math::vec3& rel_pos) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->applyImpulse(math::vec3_to_btVector3(impulse),
                        math::vec3_to_btVector3(rel_pos));
}
예제 #10
0
void RigidBodyNode::apply_torque_impulse(const math::vec3& torque) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->applyTorqueImpulse(math::vec3_to_btVector3(torque));
}
예제 #11
0
void RigidBodyNode::apply_central_force(const math::vec3& force) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->applyCentralForce(math::vec3_to_btVector3(force));
}
예제 #12
0
void RigidBodyNode::apply_force(const math::vec3& force,
                                const math::vec3& rel_pos) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->applyForce(math::vec3_to_btVector3(force),
                      math::vec3_to_btVector3(rel_pos));
}
예제 #13
0
void RigidBodyNode::set_restitution(float rest) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->setRestitution(rest);
}
예제 #14
0
void RigidBodyNode::set_rolling_friction(float frict) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->setRollingFriction(frict);
}
예제 #15
0
void RigidBodyNode::set_linear_velocity(const math::vec3& vel) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->setLinearVelocity(math::vec3_to_btVector3(vel));
}
예제 #16
0
void RigidBodyNode::sync_shapes(bool do_not_lock) {
    has_static_shapes_ = false;
    if (!shapes_.size()) {
        if (body_->getCollisionShape() != bullet_empty_shape_) {
            CONDITION_LOCK(ph_ && !do_not_lock, ph_->lock());
            body_->setCollisionShape(bullet_empty_shape_);
        }
    } else {
        if (body_->isStaticObject()) {  //Static rigid body shape construction

            if (shapes_.size() == 1 && shapes_[0].shape->is_static_shape()) {
                //Rigid body has only one collision shape
                //
                //TODO: Implement offset transform for static rigid bodies.
                //      Now the transform of the collision shape is ignored.
                //      Do not forget to fix set_mass and set_kinematic funcs.
                auto sh = shapes_[0].shape->construct_static();
                assert(sh);
                CONDITION_LOCK(ph_ && !do_not_lock, ph_->lock());
                body_->setCollisionShape(sh);
                if (!shapes_[0].shape->has_identical_shape_constructor())
                    has_static_shapes_ = true;
            } else {
                //Rigid body has more than one collision shape or
                //it cannot be static
                auto cs = new btCompoundShape();
                for (auto sh : shapes_) {
                    if (sh.shape->is_static_shape()) {
                        cs->addChildShape(
                            math::mat4_to_btTransform(sh.transform),
                            sh.shape->construct_static());
                        if (!sh.shape->has_identical_shape_constructor())
                            has_static_shapes_ = true;
                    } else if (sh.shape->is_dynamic_shape())
                        sh.shape->construct_dynamic(
                            cs, math::mat4_to_btTransform(sh.transform));
                }
                //If all the shapes support dynamic bodies, recalculate inertia
                //(in case if the body becomes dynamic)
                if (!has_static_shapes_) {
                    cs->calculateLocalInertia(mass_, inertia_);
                    body_->setMassProps(mass_, inertia_);
                }
                CONDITION_LOCK(ph_ && !do_not_lock, ph_->lock());
                body_->setCollisionShape(cs);
                if (bullet_compound_shape_)
                    delete bullet_compound_shape_;
                bullet_compound_shape_ = cs;
             }

        }
        else {  //Dynamic rigid body shape construction

            auto cs = new btCompoundShape();

            for (auto sh : shapes_) {
                if (sh.shape->is_dynamic_shape())
                    sh.shape->construct_dynamic(
                        cs, math::mat4_to_btTransform(sh.transform));
            }
            cs->calculateLocalInertia(mass_, inertia_);
            body_->setMassProps(mass_, inertia_);
            CONDITION_LOCK(ph_ && !do_not_lock, ph_->lock());
            body_->setCollisionShape(cs);
            if (bullet_compound_shape_)
                delete bullet_compound_shape_;
            bullet_compound_shape_ = cs;

        }
    }
}
예제 #17
0
void RigidBodyNode::set_damping(float lin_damping, float ang_damping) {
    CONDITION_LOCK(ph_, ph_->lock());
    body_->setDamping(lin_damping, ang_damping);
}