FlexFactory.h

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
    Copyright 2013-2020 Petr Ohlidal
 
    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/>.
*/
 
 
 
 
#pragma once
 
#include "BitFlags.h"
#include "ForwardDeclarations.h"
#include "Locator_t.h"
#include "RigDef_Prerequisites.h"
 
#include <OgreVector3.h>
#include <OgreColourValue.h>
#include <vector>
 
namespace RoR
{
 
 
 
struct FlexBodyRecordHeader
{
    int            vertex_count;
    int            node_center;
    int            node_x;
    int            node_y;
    Ogre::Vector3  center_offset;
    int            camera_mode;
    int            shared_buf_num_verts;
    int            num_submesh_vbufs;
    BitMask_t      flags = 0;
 
    static const BitMask_t IS_FAULTY                = BITMASK(1);
    static const BitMask_t USES_SHARED_VERTEX_DATA  = BITMASK(2);
    static const BitMask_t HAS_TEXTURE              = BITMASK(3);
    static const BitMask_t HAS_TEXTURE_BLEND        = BITMASK(4);
};
 
struct FlexBodyCacheData
{
    FlexBodyCacheData():
        dst_pos(nullptr),
        src_normals(nullptr),
        src_colors(nullptr),
        locators(nullptr)
    {}
 
    // NOTE: No freeing of memory needed, pointers will be copied to FlexBody instances.
 
    FlexBodyRecordHeader header;
 
    Ogre::Vector3*    dst_pos;
    Ogre::Vector3*    src_normals;
    Ogre::ARGB*       src_colors;
    Locator_t*        locators; 
};
 
class FlexBodyFileIO
{
public:
    enum ResultCode
    {
        RESULT_CODE_OK,
        RESULT_CODE_GENERAL_ERROR,
        RESULT_CODE_ERR_FOPEN_FAILED,
        RESULT_CODE_ERR_SIGNATURE_MISMATCH,
        RESULT_CODE_ERR_VERSION_MISMATCH,
        RESULT_CODE_ERR_CACHE_NUMBER_UNDEFINED,
        RESULT_CODE_FREAD_OUTPUT_INCOMPLETE,
        RESULT_CODE_FWRITE_OUTPUT_INCOMPLETE
    };
 
    static const char*        SIGNATURE;
    static const unsigned int FILE_FORMAT_VERSION = 1;
 
    FlexBodyFileIO();
 
    std::vector<FlexBody*> &  GetList();
    inline void               AddItemToSave(FlexBody* fb)     { m_items_to_save.push_back(fb); }
    inline FlexBodyCacheData* GetLoadedItem(unsigned index)   { return & m_loaded_items[index]; }
    ResultCode                SaveFile();
    ResultCode                LoadFile();
 
private:
    struct FlexBodyFileMetadata
    {
        unsigned int   file_format_version;
        unsigned int   num_flexbodies;
    };
 
    void        OpenFile(const char* fopen_mode);
    void        WriteToFile(void* source, size_t length);
    void        ReadFromFile(void* dest, size_t length);
    inline void CloseFile()                                 { if (m_file != nullptr) { fclose(m_file); } }
                
    void        WriteSignature();
    void         ReadAndCheckSignature();
 
    void        WriteMetadata();
    void         ReadMetadata(FlexBodyFileMetadata* meta);
 
    void        WriteFlexbodyHeader(FlexBody*          flexbody);
    void         ReadFlexbodyHeader(FlexBodyCacheData* flexbody);
 
    void        WriteFlexbodyLocatorList(FlexBody*          flexbody);
    void         ReadFlexbodyLocatorList(FlexBodyCacheData* flexbody);
 
    void        WriteFlexbodyNormalsBuffer(FlexBody*          flexbody);
    void         ReadFlexbodyNormalsBuffer(FlexBodyCacheData* flexbody);
 
    void        WriteFlexbodyPositionsBuffer(FlexBody*          flexbody);
    void         ReadFlexbodyPositionsBuffer(FlexBodyCacheData* flexbody);
 
    void        WriteFlexbodyColorsBuffer(FlexBody*          flexbody);
    void         ReadFlexbodyColorsBuffer(FlexBodyCacheData* flexbody);
 
    std::vector<FlexBody*>          m_items_to_save;
    std::vector<FlexBodyCacheData>  m_loaded_items;
    FILE*                           m_file;
    unsigned int                    m_fileformat_version;
    int                             m_cache_entry_number;
};
 
class FlexFactory
{
public:
    FlexFactory() {}
 
    FlexFactory(ActorSpawner* spawner);
 
    FlexBody* CreateFlexBody(
        FlexbodyID_t flexbody_id,
        const NodeNum_t ref_node, 
        const NodeNum_t x_node, 
        const NodeNum_t y_node, 
        Ogre::Vector3 offset,
        Ogre::Vector3 rotation, 
        std::vector<unsigned int> & node_indices,
        const std::string& mesh_name,
        const std::string& resource_group_name);
 
    FlexMeshWheel* CreateFlexMeshWheel(
        unsigned int wheel_index,
        int axis_node_1_index,
        int axis_node_2_index,
        int nstart,
        int nrays,
        float rim_radius,
        bool rim_reverse,
        std::string const & rim_mesh_name,
        std::string const & rim_mesh_rg,
        std::string const & tire_material_name,
        std::string const & tire_material_rg);
 
    void  CheckAndLoadFlexbodyCache();
    void  SaveFlexbodiesToCache();
 
private:
 
    ActorSpawner*             m_rig_spawner;
 
    FlexBodyFileIO          m_flexbody_cache;
    bool                    m_is_flexbody_cache_enabled;
    bool                    m_is_flexbody_cache_loaded;
    unsigned int            m_flexbody_cache_next_index;
};
 
 
} // namespace RoR