Subversion Repositories spk

/*
  defines the bod_bob_parser - class that can parse bod format and create
  bob_dom_bob object
*/

#ifndef BOD_BOB_PARSER_INCLUDED
#define BOD_BOB_PARSER_INCLUDED

#include "bob_dom_bob.h"
#include "bod_text_parser.h"
#include "token_stream.h"
#include "settings.h"
#include "bod_parser_base.h"

#include "../common/ptr_list.h"
#include "geometry.h"

class bod_bob_parser : public bod_parser_base
{
        private:
                struct SameVertices;
                struct SameSG_UVs;
                
                struct uv_coord : geometry::point2d<double>
                {
                        friend SameSG_UVs;
                        private:
                                static geometry::point2d<double> NULL_COORDS;
                                
                                bool isNull () const { return *this==NULL_COORDS; }
                                
                        public:
                                SameSG_UVs *parent;
                                int vertexIndex;
                                
                                uv_coord(SameSG_UVs *p, double x, double y)
                                        : geometry::point2d<double>(x,y), parent(p) { }
                                        
                                bob_vertex * createBOBVertex()
                                {
                                        bob_vertex *v=new bob_vertex(parent->parent->x, parent->parent->y, parent->parent->z);
                                        v->sgbits=parent->sgbits;
                                        if(!isNull()){
                                                v->textureCoords.x=x;
                                                v->textureCoords.y=y;
                                                v->flags|=bob_vertex::FLAG_UV;
                                        }
                                        return v;
                                }
                };

                struct SameSG_UVs : public ptr_list<ext::simple_list<uv_coord*> >
                {
                        public:
                                SameVertices *parent;
                                int sgbits;
                                
                                SameSG_UVs (SameVertices *p, int sg)
                                        : sgbits(sg) { parent=p; }
                                
                                uv_coord * findUV(double x, double y)
                                {
                                        for(iterator &it=begin(); it!=end(); ++it){
                                                if(it->x==x && it->y==y)
                                                        return *it;
                                        }
                                        return 0;
                                }
                                uv_coord * createUV(double x, double y)
                                {
                                        uv_coord *uv=new uv_coord(this, x,y);
                                        push_back(uv);
                                        return uv;
                                }
                                
                                uv_coord * findNullUV()
                                {
                                        return findUV(uv_coord::NULL_COORDS.x, uv_coord::NULL_COORDS.y);
                                }
                                
                                uv_coord * createNullUV()
                                {
                                        return createUV(uv_coord::NULL_COORDS.x, uv_coord::NULL_COORDS.y);
                                }
                };

                struct SameVertices : public vertex, public ptr_list<ext::simple_list<SameSG_UVs*> >
                {
                        SameVertices(int x, int y, int z)
                        {
                                this->x=conversion::vertex_bod2bob(x);
                                this->y=conversion::vertex_bod2bob(y);
                                this->z=conversion::vertex_bod2bob(z);
                        }
                        
                        SameSG_UVs * findTextureCoords(int sgbits)
                        {
                                for(iterator &it=begin(); it!=end(); ++it){
                                        //if(it->sgbits==sgbits) return *it;
                                        /* changed and not tested - taken from max2msh by mindblast */
                                        if(it->sgbits & sgbits) return *it;
                                }
                                SameSG_UVs *uvs=new SameSG_UVs(this, sgbits);
                                push_back(uvs);
                                return uvs;
                        }

                };

        protected:
                const Settings *m_settings;

                bool checkImmediatePlacement(const bod_bob_parser::token *token1, const bod_bob_parser::token *token2);

        private:
                typedef ext::simple_list<SameVertices*> VertexList;
                typedef ptr_list<ext::array<SameVertices*> > VertexArray;
                typedef ptr_list<ext::array<bob_weight*> > WeightArray;

                const bob_materials *m_materials;
                VertexArray m_vertices;
                WeightArray m_weights;

        private:
                bool loadMatRGB(token_stream& is, bob_material5::rgb& rgb);
                bool loadMatPair(token_stream& is, bob_material5::pair& pair);
                bool loadMatPair(token_stream& is, bob_material6::Small::pair& pair);
                bool loadMat(bob_material5 *mat, token_stream &is);
                bool loadMat(bob_material6 *mat, token_stream &is);
                bool loadMaterial(bob_dom_bob *bob, token_stream& is);
                bool loadBody(bob_dom_bob *bob, token_stream& is);
                bool loadVertices(bob_body *body, token_stream& is, VertexList& points);
                bool loadPart(bob_body *body, token_stream& is);
                bool loadFace(int matIdx, bob_body& body, bob_part& part, token_stream& is);
                bool flagsFromString(token_stream& is, int& flags);
                
                void computeVertexTangents(bob_body& body);
                
                material6_value * loadMat6Value(token_stream& is);

                bool loadMaterial6Small(bob_material6 *mat, token_stream &is);
                bool loadMaterial6Big(bob_material6 *mat, token_stream &is);

                bool loadSpecialValues(bob_vertex *points[3], token_stream& is);
                bool loadSpecialPointValues(token_stream& is, bob_vertex *point);
                bool loadFaceNormal(token_stream& is, bob_vertex *points[3]);

                bool loadBones(bob_body *body, token_stream& is);
                bool loadWeights(bob_body *body, token_stream& is);

                bool loadCollisionBoxData(token_stream& is, bob_part& part);

                void deleteTempData()
                {
                        m_vertices.clear();
                        m_weights.clear();
                }

        public:

                bod_bob_parser(const Settings *settings) { m_settings=settings; }
                ~bod_bob_parser() { deleteTempData(); }

                bob_dom_bob * loadBOB(token_stream& is, bool bEmbedded);

                bool compile(token_stream& is, obinaryfilestream& os, bool bEmbedded);
};

#endif //!defined(BOD_BOB_PARSER_INCLUDED)