AirBrake.cpp

Go to the documentation of this file.

/*
    This source file is part of Rigs of Rods
    Copyright 2005-2012 Pierre-Michel Ricordel
    Copyright 2007-2012 Thomas Fischer
 
    For more information, see http://www.rigsofrods.org/
 
    Rigs of Rods is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 3, as
    published by the Free Software Foundation.
 
    Rigs of Rods is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "AirBrake.h"
 
#include "Application.h"
#include "SimData.h"
#include "Actor.h"
#include "GfxActor.h"
#include "GfxScene.h"
 
#include <Ogre.h>
 
using namespace Ogre;
using namespace RoR;
 
Airbrake::Airbrake(ActorPtr actor, const char* basename, int num, node_t* ndref, node_t* ndx, node_t* ndy, node_t* nda, Ogre::Vector3 pos, float width, float length, float maxang, std::string const & texname, float tx1, float ty1, float tx2, float ty2, float lift_coef)
{
    snode = 0;
    noderef = ndref;
    nodex = ndx;
    nodey = ndy;
    nodea = nda;
    offset = pos;
    maxangle = maxang;
    area = width * length * lift_coef;
    char meshname[256];
    sprintf(meshname, "airbrakemesh-%s-%i", basename, num);
    msh = MeshManager::getSingleton().createManual(meshname, actor->GetGfxActor()->GetResourceGroup());
 
    union
    {
        float* vertices;
        CoVertice_t* covertices;
    };
 
    SubMesh* sub = msh->createSubMesh();
 
    //materials
    sub->setMaterialName(texname);
 
    size_t nVertices = 4;
    size_t vbufCount = (2 * 3 + 2) * nVertices;
    vertices = (float*)malloc(vbufCount * sizeof(float));
 
    //textures coordinates
    covertices[0].texcoord = Vector2(tx1, ty1);
    covertices[1].texcoord = Vector2(tx2, ty1);
    covertices[2].texcoord = Vector2(tx2, ty2);
    covertices[3].texcoord = Vector2(tx1, ty2);
 
    size_t ibufCount = 3 * 4;
    unsigned short* faces = (unsigned short*)malloc(ibufCount * sizeof(unsigned short));
    faces[0] = 0;
    faces[1] = 1;
    faces[2] = 2;
    faces[3] = 0;
    faces[4] = 2;
    faces[5] = 3;
    faces[6] = 0;
    faces[7] = 2;
    faces[8] = 1;
    faces[9] = 0;
    faces[10] = 3;
    faces[11] = 2;
 
    //set coords
    covertices[0].vertex = Vector3(0, 0, 0);
    covertices[1].vertex = Vector3(width, 0, 0);
    covertices[2].vertex = Vector3(width, 0, length);
    covertices[3].vertex = Vector3(0, 0, length);
 
    covertices[0].normal = Vector3(0, 1, 0);
    covertices[1].normal = Vector3(0, 1, 0);
    covertices[2].normal = Vector3(0, 1, 0);
    covertices[3].normal = Vector3(0, 1, 0);
 
    msh->sharedVertexData = new VertexData();
    msh->sharedVertexData->vertexCount = nVertices;
 
    VertexDeclaration* decl = msh->sharedVertexData->vertexDeclaration;
    size_t offset = 0;
    decl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
    offset += VertexElement::getTypeSize(VET_FLOAT3);
    decl->addElement(0, offset, VET_FLOAT3, VES_NORMAL);
    offset += VertexElement::getTypeSize(VET_FLOAT3);
    //        decl->addElement(0, offset, VET_FLOAT3, VES_DIFFUSE);
    //        offset += VertexElement::getTypeSize(VET_FLOAT3);
    decl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0);
    offset += VertexElement::getTypeSize(VET_FLOAT2);
 
    HardwareVertexBufferSharedPtr vbuf =
        HardwareBufferManager::getSingleton().createVertexBuffer(
            offset, msh->sharedVertexData->vertexCount, HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
 
    vbuf->writeData(0, vbuf->getSizeInBytes(), vertices, true);
 
    VertexBufferBinding* bind = msh->sharedVertexData->vertexBufferBinding;
    bind->setBinding(0, vbuf);
 
    HardwareIndexBufferSharedPtr faceibuf = HardwareBufferManager::getSingleton().
        createIndexBuffer(
            HardwareIndexBuffer::IT_16BIT,
            ibufCount,
            HardwareBuffer::HBU_STATIC_WRITE_ONLY);
 
    faceibuf->writeData(0, faceibuf->getSizeInBytes(), faces, true);
 
    sub->useSharedVertices = true;
    sub->indexData->indexBuffer = faceibuf;
    sub->indexData->indexCount = ibufCount;
    sub->indexData->indexStart = 0;
 
    msh->_setBounds(AxisAlignedBox(-1, -1, 0, 1, 1, 0), true);
    //msh->_setBoundingSphereRadius(Math::Sqrt(1*1+1*1));
 
    msh->load();
 
    // create the entity and scene node
    char entname[256];
    sprintf(entname, "airbrakenode-%s-%i", basename, num);
    ec = App::GetGfxScene()->GetSceneManager()->createEntity(entname, meshname, actor->GetGfxActor()->GetResourceGroup());
    snode = App::GetGfxScene()->GetSceneManager()->getRootSceneNode()->createChildSceneNode();
    snode->attachObject(ec);
 
    updatePosition(0.0);
 
    free(vertices);
    free(faces);
}
 
void Airbrake::updatePosition(float amount)
{
    ratio = amount;
    // Visual update moved from here to `GfxActor::UpdateAirbrakes()`
}
 
void Airbrake::applyForce()
{
    //tropospheric model valid up to 11.000m (33.000ft)
    float altitude = noderef->AbsPosition.y;
    //float sea_level_temperature=273.15+15.0; //in Kelvin
    float sea_level_pressure = 101325; //in Pa
    //float airtemperature=sea_level_temperature-altitude*0.0065; //in Kelvin
    float airpressure = sea_level_pressure * pow(1.0 - 0.0065 * altitude / 288.15, 5.24947); //in Pa
    float airdensity = airpressure * 0.0000120896;//1.225 at sea level
 
    Vector3 wind = -noderef->Velocity;
    float wspeed = wind.length();
 
    Vector3 drag = (1.2 * area * sin(fabs(ratio * maxangle / 57.3)) * 0.5 * airdensity * wspeed / 4.0) * wind;
    noderef->Forces += drag;
    nodex->Forces += drag;
    nodey->Forces += drag;
    nodea->Forces += drag;
}