eclasslib.h

Go to the documentation of this file.

/*
 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
 For a list of contributors, see the accompanying CONTRIBUTORS file.

 This file is part of GtkRadiant.

 GtkRadiant is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 GtkRadiant 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 GtkRadiant; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined (INCLUDED_ECLASSLIB_H)
#define INCLUDED_ECLASSLIB_H

#include <stdio.h>
#include <stdlib.h>
#include <list>
#include <map>
#include <vector>

#include "ieclass.h"
#include "irender.h"

#include "string/string.h"

typedef Vector3 Colour3;

class ListAttributeType
{
        typedef std::pair<std::string, std::string> ListItem;
        typedef std::vector<ListItem> ListItems;
        ListItems m_items;
    public:

        typedef ListItems::const_iterator const_iterator;
        const_iterator begin () const
        {
            return m_items.begin();
        }
        const_iterator end () const
        {
            return m_items.end();
        }

        const ListItem& operator[] (std::size_t i) const
        {
            return m_items[i];
        }
        const_iterator findValue (const std::string& value) const
        {
            for (ListItems::const_iterator i = m_items.begin(); i != m_items.end(); ++i) {
                if (value == i->second)
                    return i;
            }
            return m_items.end();
        }

        void push_back (const std::string& name, const std::string& value)
        {
            m_items.push_back(ListItems::value_type(name, value));
        }
};

class EntityClassAttribute
{
    public:
        std::string m_type; 
        std::string m_name; 
        std::string m_value; 
        std::string m_description; 
        bool m_mandatory; 
        EntityClassAttribute ()
        {
        }
        EntityClassAttribute (const char* type, const char* name, bool mandatory = false, const char* value = "",
                const char* description = "") :
            m_type(type), m_name(name), m_value(value), m_description(description), m_mandatory(mandatory)
        {
        }
};

typedef std::pair<std::string, EntityClassAttribute> EntityClassAttributePair;
typedef std::list<EntityClassAttributePair> EntityClassAttributes;
typedef std::list<std::string> StringList;

inline const char* EntityClassAttributePair_getName (const EntityClassAttributePair& attributePair)
{
    if (!attributePair.second.m_name.empty()) {
        return attributePair.second.m_name.c_str();
    }
    return attributePair.first.c_str();
}

inline const char* EntityClassAttributePair_getDescription (const EntityClassAttributePair& attributePair)
{
    if (!attributePair.second.m_description.empty()) {
        return attributePair.second.m_description.c_str();
    }
    return EntityClassAttributePair_getName(attributePair);
}

class EntityClass
{
    public:
        std::string m_name;
        StringList m_parent;
        bool fixedsize;
        Vector3 mins;
        Vector3 maxs;

        Colour3 color;
        Shader* m_state_fill;
        Shader* m_state_wire;
        Shader* m_state_blend;

        std::string m_comments;
        char flagnames[MAX_FLAGS][32];

        std::string m_modelpath; 
        std::string m_skin;

        void (*free) (EntityClass*);

        EntityClassAttributes m_attributes;

        const char* name () const
        {
            return m_name.c_str();
        }
        const char* comments () const
        {
            return m_comments.c_str();
        }
        const std::string& modelpath () const
        {
            return m_modelpath;
        }
        const char* skin () const
        {
            return m_skin.c_str();
        }

        EntityClassAttribute *getAttribute (const std::string& attributeName) const
        {
            for (EntityClassAttributes::const_iterator i = m_attributes.begin(); i != m_attributes.end(); ++i) {
                if (attributeName == i->first) {
                    return const_cast<EntityClassAttribute*> (&(*i).second);
                }
            }
            return NULL;
        }

        const std::string getDefaultForAttribute (const std::string& attributeName) const
        {
            EntityClassAttribute *attrib = getAttribute(attributeName);
            //use value if it is set to something
            if (attrib && attrib->m_value.length() > 0)
                return attrib->m_value;
            // TODO retrieve some default value from entity definition instead of that empty value
            return "";
        }
};

inline const char* EntityClass_valueForKey (const EntityClass& entityClass, const std::string& key)
{
    for (EntityClassAttributes::const_iterator i = entityClass.m_attributes.begin(); i
            != entityClass.m_attributes.end(); ++i) {
        if (key == (*i).first) {
            return (*i).second.m_value.c_str();
        }
    }
    return "";
}

inline EntityClassAttributePair& EntityClass_insertAttribute (EntityClass& entityClass, const char* key,
        const EntityClassAttribute& attribute = EntityClassAttribute())
{
    entityClass.m_attributes.push_back(EntityClassAttributePair(key, attribute));
    return entityClass.m_attributes.back();
}

inline void buffer_write_colour_fill (char buffer[128], const Colour3& colour)
{
    sprintf(buffer, "(%g %g %g)", colour[0], colour[1], colour[2]);
}

inline void buffer_write_colour_wire (char buffer[128], const Colour3& colour)
{
    sprintf(buffer, "<%g %g %g>", colour[0], colour[1], colour[2]);
}

inline void buffer_write_colour_blend (char buffer[128], const Colour3& colour)
{
    sprintf(buffer, "[%g %g %g]", colour[0], colour[1], colour[2]);
}

inline Shader* colour_capture_state_fill (const Colour3& colour)
{
    char buffer[128];
    buffer_write_colour_fill(buffer, colour);
    return GlobalShaderCache().capture(buffer);
}

inline void colour_release_state_fill (const Colour3& colour)
{
    char buffer[128];
    buffer_write_colour_fill(buffer, colour);
    GlobalShaderCache().release(buffer);
}

inline Shader* colour_capture_state_wire (const Colour3& colour)
{
    char buffer[128];
    buffer_write_colour_wire(buffer, colour);
    return GlobalShaderCache().capture(buffer);
}

inline void colour_release_state_wire (const Colour3& colour)
{
    char buffer[128];
    buffer_write_colour_wire(buffer, colour);
    GlobalShaderCache().release(buffer);
}

inline Shader* colour_capture_state_blend (const Colour3& colour)
{
    char buffer[128];
    buffer_write_colour_blend(buffer, colour);
    return GlobalShaderCache().capture(buffer);
}

inline void colour_release_state_blend (const Colour3& colour)
{
    char buffer[128];
    buffer_write_colour_blend(buffer, colour);
    GlobalShaderCache().release(buffer);
}

inline void eclass_capture_state (EntityClass* eclass)
{
    eclass->m_state_fill = colour_capture_state_fill(eclass->color);
    eclass->m_state_wire = colour_capture_state_wire(eclass->color);
    eclass->m_state_blend = colour_capture_state_blend(eclass->color);
}

inline void eclass_release_state (EntityClass* eclass)
{
    colour_release_state_fill(eclass->color);
    colour_release_state_wire(eclass->color);
    colour_release_state_blend(eclass->color);
}

// eclass constructor
inline EntityClass* Eclass_Alloc ()
{
    EntityClass* e = new EntityClass;

    e->fixedsize = false;
    memset(e->flagnames, 0, MAX_FLAGS * 32);

    e->maxs = Vector3(-1, -1, -1);
    e->mins = Vector3(1, 1, 1);
    e->color = Vector3(1, 1, 1);

    e->free = 0;

    return e;
}

// eclass destructor
inline void Eclass_Free (EntityClass* e)
{
    eclass_release_state(e);

    delete e;
}

inline bool classname_equal (const std::string& classname, const std::string& other)
{
    return string_equal(classname, other);
}

inline EntityClass* EClass_Create (const std::string& name, const Vector3& colour, const std::string& comments)
{
    EntityClass *e = Eclass_Alloc();
    e->free = &Eclass_Free;

    e->m_name = name;

    e->color = colour;
    eclass_capture_state(e);

    e->m_comments = comments;

    return e;
}

inline EntityClass* EClass_Create_FixedSize (const std::string& name, const Vector3& colour, const Vector3& mins,
        const Vector3& maxs, const std::string& comments)
{
    EntityClass *e = Eclass_Alloc();
    e->free = &Eclass_Free;

    e->m_name = name;

    e->color = colour;
    eclass_capture_state(e);

    e->fixedsize = true;

    e->mins = mins;
    e->maxs = maxs;

    e->m_comments = comments;

    return e;
}

const Vector3 smallbox[2] = { Vector3(-8, -8, -8), Vector3(8, 8, 8), };

inline EntityClass *EntityClass_Create_Default (const std::string& name, bool has_brushes)
{
    // create a new class for it
    if (has_brushes) {
        return EClass_Create(name, Vector3(0.0f, 0.5f, 0.0f), "Not found in source.");
    } else {
        return EClass_Create_FixedSize(name, Vector3(0.0f, 0.5f, 0.0f), smallbox[0], smallbox[1],
                "Not found in source.");
    }
}

#endif