C++ KartProperties类代码示例

// ----------------------------------------------------------------------------
bool KartProperties::operator<(const KartProperties &other) const
{
    PlayerProfile *p = PlayerManager::getCurrentPlayer();
    bool this_is_locked = p->isLocked(getIdent());
    bool other_is_locked = p->isLocked(other.getIdent());
    if (this_is_locked == other_is_locked)
    {
        return getName() < other.getName();
    }
    else
        return other_is_locked;

    return true;
}  // operator<

/** Loads the 3d model and all wheels.
 */
bool KartModel::loadModels(const KartProperties &kart_properties)
{
    assert(m_is_master);
    std::string  full_path = kart_properties.getKartDir()+m_model_filename;
    m_mesh                 = irr_driver->getAnimatedMesh(full_path);
    if(!m_mesh)
    {
        Log::error("Kart_Model", "Problems loading mesh '%s' - kart '%s' will"
                   "not be available.",
                   full_path.c_str(), kart_properties.getIdent().c_str());
        return false;
    }
    m_mesh->grab();
    irr_driver->grabAllTextures(m_mesh);

    Vec3 kart_min, kart_max;
    MeshTools::minMax3D(m_mesh->getMesh(m_animation_frame[AF_STRAIGHT]),
                        &kart_min, &kart_max);

    // Test if kart model support colorization
    for (u32 i = 0; i < m_mesh->getMeshBufferCount(); i++)
    {
        scene::IMeshBuffer* mb = m_mesh->getMeshBuffer(i);
        Material* material = material_manager->getMaterialFor(mb
            ->getMaterial().getTexture(0), mb);
        m_support_colorization =
            m_support_colorization || material->isColorizable();
    }

#undef MOVE_KART_MESHES
#ifdef MOVE_KART_MESHES
    // Kart models are not exactly centered. The following code would
    // transform the mesh so that they are properly centered, but it
    // would also mean all location relative to the original kart's
    // center (wheel position, emitter, hat) would need to be modified.
    scene::IMeshManipulator *mani =
        irr_driver->getVideoDriver()->getMeshManipulator();
    Vec3 offset_from_center = -0.5f*(kart_max+kart_min);
    offset_from_center.setY(-kart_min.getY());
    offset_from_center.setY(0);

    core::matrix4 translate(core::matrix4::EM4CONST_IDENTITY);
    translate.setTranslation(offset_from_center.toIrrVector());
    mani->transform(m_mesh, translate);
    MeshTools::minMax3D(m_mesh->getMesh(m_animation_frame[AF_STRAIGHT]),
                        &kart_min, &kart_max);
#endif
    m_kart_highest_point = kart_max.getY();
    m_kart_lowest_point  = kart_min.getY();

    // Load the speed weighted object models. We need to do that now because it can affect the dimensions of the kart
    for(size_t i=0 ; i < m_speed_weighted_objects.size() ; i++)
    {
        SpeedWeightedObject&    obj = m_speed_weighted_objects[i];
        std::string full_name =
            kart_properties.getKartDir()+obj.m_name;
        obj.m_model = irr_driver->getAnimatedMesh(full_name);
        // Grab all textures. This is done for the master only, so
        // the destructor will only free the textures if a master
        // copy is freed.
        irr_driver->grabAllTextures(obj.m_model);

        // Update min/max
        Vec3 obj_min, obj_max;
        MeshTools::minMax3D(obj.m_model, &obj_min, &obj_max);
        obj_min += obj.m_position;
        obj_max += obj.m_position;
        kart_min.min(obj_min);
        kart_max.max(obj_max);
    }

    Vec3 size     = kart_max-kart_min;
    m_kart_width  = size.getX();
    m_kart_height = size.getY();
    m_kart_length = size.getZ();

    // Now set default some default parameters (if not defined) that
    // depend on the size of the kart model (wheel position, center
    // of gravity shift)
    for(unsigned int i=0; i<4; i++)
    {
        if(m_wheel_graphics_position[i].getX()==UNDEFINED)
        {
            m_wheel_graphics_position[i].setX( ( i==1||i==3)
                                               ? -0.5f*m_kart_width
                                               :  0.5f*m_kart_width  );
            m_wheel_graphics_position[i].setY(0);
            m_wheel_graphics_position[i].setZ( (i<2) ?  0.5f*m_kart_length
                                                     : -0.5f*m_kart_length);
        }
    }

    // Load the wheel models. This can't be done early, since the default
    // values for the graphical position must be defined, which in turn
    // depend on the size of the model.
    for(unsigned int i=0; i<4; i++)
    {
        // For kart models without wheels.
//.........这里部分代码省略.........

 /** Returns a unique identifier for this kart (name of the directory the
  *  kart was loaded from). */
 const std::string& getIdent() const {return m_kart_properties->getIdent();}

 /** Returns a name to be displayed for this kart. */
 virtual const irr::core::stringw& getName() const 
                                    { return m_kart_properties->getName(); }

 /** Returns the maximum steering angle for this kart, which depends on the
  *  speed. */
 float getMaxSteerAngle () const
                 { return m_kart_properties->getMaxSteerAngle(getSpeed()); }

 /** Returns the time till full steering is reached for this kart. */
 float getTimeFullSteer() const 
                           { return m_kart_properties->getTimeFullSteer(); }

 /** Returns the strenght of the brakes for this kart. */
 float getBrakeFactor() const {return m_kart_properties->getBrakeFactor();}

 /** Returns the maximum engine power for this kart. */
 float getMaxPower     () const {return m_kart_properties->getMaxPower(); }

 /** Returns the current mass of this kart, including any attachment this
  *  kart might have. */
 float getMass() const { return m_kart_properties->getMass()
                              + m_attachment->weightAdjust();}

 /** Sets that the view is blocked by a plunger. The duration depends on
  *  the difficulty, see KartPorperties getPlungerInFaceTime. */
 void           blockViewWithPlunger()   
                          { m_view_blocked_by_plunger = 
                                m_kart_properties->getPlungerInFaceTime();}

 /** Returns a name to be displayed for this kart. */
 virtual const wchar_t* getName() const 
                                     { return m_kart_properties->getName(); }