EditorEntity.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code 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 3 of the License, or
(at your option) any later version.

Doom 3 Source Code 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "qe3.h"
#include "../../renderer/tr_local.h"
#include "../../renderer/model_local.h" // for idRenderModelMD5
int g_entityId = 1;

#define CURVE_TAG "curve_"

extern void Brush_Resize(brush_t *b, idVec3 vMin, idVec3 vMax);

int     GetNumKeys(entity_t *ent)
{
//      int iCount = 0;
//      for (epair_t* ep=ent->epairs ; ep ; ep=ep->next)
//      {
//              iCount++;
//      }

        int iCount = ent->epairs.GetNumKeyVals();
        return iCount;
}

const char *GetKeyString(entity_t *ent, int iIndex)
{
//      for (epair_t* ep=ent->epairs ; ep ; ep=ep->next)
//      {
//              if (!iIndex--)
//                      return ep->key;
//      }
//
//      assert(0);
//      return NULL;
        
        if ( iIndex < GetNumKeys(ent) )
        {
                return ent->epairs.GetKeyVal(iIndex)->GetKey().c_str();
        }

        assert(0);
        return NULL;
}


/*
 =======================================================================================================================
 =======================================================================================================================
 */
const char *ValueForKey(entity_t *ent, const char *key) {
        return ent->epairs.GetString(key);
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void TrackMD3Angles(entity_t *e, const char *key, const char *value) {
        if ( idStr::Icmp(key, "angle") != 0 ) {
                return;
        }

        if ((e->eclass->fixedsize && e->eclass->nShowFlags & ECLASS_MISCMODEL) || EntityHasModel(e)) {
                float   a = FloatForKey(e, "angle");
                float   b = atof(value);
                if (a != b) {
                        idVec3  vAngle;
                        vAngle[0] = vAngle[1] = 0;
                        vAngle[2] = -a;
                        Brush_Rotate(e->brushes.onext, vAngle, e->origin, true);
                        vAngle[2] = b;
                        Brush_Rotate(e->brushes.onext, vAngle, e->origin, true);
                }
        }
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void SetKeyValue(entity_t *ent, const char *key, const char *value, bool trackAngles) {
        if (ent == NULL) {
                return;
        }

        if (!key || !key[0]) {
                return;
        }

        if (trackAngles) {
                TrackMD3Angles(ent, key, value);
        }

        ent->epairs.Set(key, value);
        GetVectorForKey(ent, "origin", ent->origin);

        // update sound in case this key was relevent
        Entity_UpdateSoundEmitter( ent );
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void SetKeyVec3(entity_t *ent, const char *key, idVec3 v) {
        if (ent == NULL) {
                return;
        }

        if (!key || !key[0]) {
                return;
        }

        idStr str;
        sprintf(str, "%g %g %g", v.x, v.y, v.z);
        ent->epairs.Set(key, str);
        GetVectorForKey(ent, "origin", ent->origin);
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void SetKeyMat3(entity_t *ent, const char *key, idMat3 m) {
        if (ent == NULL) {
                return;
        }

        if (!key || !key[0]) {
                return;
        }

        idStr str;
        
        sprintf(str, "%g %g %g %g %g %g %g %g %g",m[0][0],m[0][1],m[0][2],m[1][0],m[1][1],m[1][2],m[2][0],m[2][1],m[2][2]);
        
        ent->epairs.Set(key, str);
        GetVectorForKey(ent, "origin", ent->origin);
}



/*
 =======================================================================================================================
 =======================================================================================================================
 */
void DeleteKey(entity_t *ent, const char *key) {
        ent->epairs.Delete(key);
        if (stricmp(key, "rotation") == 0) {
                ent->rotation.Identity();
        }
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
float FloatForKey(entity_t *ent, const char *key) {
        const char      *k;

        k = ValueForKey(ent, key);
        if (k && *k) {
                return atof(k);
        }

        return 0.0;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
int IntForKey(entity_t *ent, const char *key) {
        const char      *k;

        k = ValueForKey(ent, key);
        return atoi(k);
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
bool GetVectorForKey(entity_t *ent, const char *key, idVec3 &vec) {
        const char      *k;
        k = ValueForKey(ent, key);
        if (k && strlen(k) > 0) {
                sscanf(k, "%f %f %f", &vec[0], &vec[1], &vec[2]);
                return true;
        }
        else {
                vec[0] = vec[1] = vec[2] = 0;
        }

        return false;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
bool GetVector4ForKey(entity_t *ent, const char *key, idVec4 &vec) {
        const char      *k;
        k = ValueForKey(ent, key);
        if (k && strlen(k) > 0) {
                sscanf(k, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
                return true;
        }
        else {
                vec[0] = vec[1] = vec[2] = vec[3] = 0;
        }

        return false;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
bool GetFloatForKey(entity_t *ent, const char *key, float *f) {
        const char      *k;
        k = ValueForKey(ent, key);
        if (k && strlen(k) > 0) {
                *f = atof(k);
                return true;
        }

        *f = 0;
        return false;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
bool GetMatrixForKey(entity_t *ent, const char *key, idMat3 &mat) {
        const char      *k;
        k = ValueForKey(ent, key);
        if (k && strlen(k) > 0) {
                sscanf
                (
                        k,
                        "%f %f %f %f %f %f %f %f %f ",
                        &mat[0][0],
                        &mat[0][1],
                        &mat[0][2],
                        &mat[1][0],
                        &mat[1][1],
                        &mat[1][2],
                        &mat[2][0],
                        &mat[2][1],
                        &mat[2][2]
                );
                return true;
        }
        else {
                mat.Identity();
        }

        return false;
}

/*
 =======================================================================================================================
    Entity_FreeEpairs Frees the entity epairs.
 =======================================================================================================================
 */
void Entity_FreeEpairs(entity_t *e) {
        e->epairs.Clear();
}

/*
 =======================================================================================================================
    Entity_AddToList
 =======================================================================================================================
 */
void Entity_AddToList(entity_t *e, entity_t *list) {
        if (e->next || e->prev) {
                Error("Entity_AddToList: allready linked");
        }

        e->next = list->next;
        list->next->prev = e;
        list->next = e;
        e->prev = list;
}

/*
 =======================================================================================================================
    Entity_RemoveFromList
 =======================================================================================================================
 */
void Entity_RemoveFromList(entity_t *e) {
        if ( !e->next || !e->prev ) {
                Error("Entity_RemoveFromList: not linked");
        }

        e->next->prev = e->prev;
        e->prev->next = e->next;
        e->next = e->prev = NULL;
}

/*
 =======================================================================================================================
    Entity_Free Frees the entity and any brushes is has. The entity is removed from the global entities list.
 =======================================================================================================================
 */
void Entity_Free( entity_t *e ) {

        while ( e->brushes.onext != &e->brushes ) {
                Brush_Free(e->brushes.onext);
        }

        if ( e->next ) {
                e->next->prev = e->prev;
                e->prev->next = e->next;
        }

        Entity_FreeEpairs( e );

        delete e;
}

/*
 =======================================================================================================================
    Entity_MemorySize
 =======================================================================================================================
 */

int Entity_MemorySize( entity_t *e ) 
{
        brush_t         *b;
        int                     size;

        size = sizeof( entity_t ) + e->epairs.Size();
        for( b = e->brushes.onext; b != &e->brushes; b = b->onext )
        {
                size += Brush_MemorySize( b );
}
        return( size );
}

/*
 =======================================================================================================================
    ParseEpair
 =======================================================================================================================
 */

struct EpairFixup {
        const char *name;
        int type;
};


const EpairFixup FloatFixups[] = {
        { "origin", 1 },
        { "rotation", 2 },
        { "_color", 1 },
        { "falloff", 0 },
        { "light", 0 },
        { "light_target", 1 },
        { "light_up", 1 },
        { "light_right", 1 },
        { "light_start", 1 },
        { "light_center", 1 },
        { "light_end", 1 },
        { "light_radius", 1 },
        { "light_origin", 1 }
};

const int FixupCount = sizeof(FloatFixups) / sizeof(EpairFixup);

void FixFloats(idDict *dict) {
        int count = dict->GetNumKeyVals();
        for (int i = 0; i < count; i++) {
                const idKeyValue *kv = dict->GetKeyVal(i);
                for (int j = 0; j < FixupCount; j++) {
                        if (kv->GetKey().Icmp(FloatFixups[j].name) == 0) {
                                idStr val;
                                if (FloatFixups[j].type == 1) {
                                        idVec3 v;
                                        sscanf(kv->GetValue().c_str(), "%f %f %f", &v.x, &v.y, &v.z);
                                        sprintf(val, "%g %g %g", v.x, v.y, v.z);
                                } else if (FloatFixups[j].type == 2) {
                                        idMat3 mat;
                                        sscanf(kv->GetValue().c_str(),  "%f %f %f %f %f %f %f %f %f ",&mat[0][0],&mat[0][1],&mat[0][2],&mat[1][0],&mat[1][1],&mat[1][2],&mat[2][0],&mat[2][1],&mat[2][2]);
                                        sprintf(val, "%g %g %g %g %g %g %g %g %g",mat[0][0],mat[0][1],mat[0][2],mat[1][0],mat[1][1],mat[1][2],mat[2][0],mat[2][1],mat[2][2]);
                                } else {
                                        float f = atof(kv->GetValue().c_str());
                                        sprintf(val, "%g", f);
                                }
                                dict->Set(kv->GetKey(), val);
                                break;
                        }
                }
        }
}

void ParseEpair(idDict *dict) {
        idStr key = token;
        GetToken(false);
        idStr val = token;
        
        if (key.Length() > 0) {
                dict->Set(key, val);
        }
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
bool EntityHasModel(entity_t *ent) {
        if (ent) {
                const char      *model = ValueForKey(ent, "model");
                const char      *name = ValueForKey(ent, "name");
                if (model && *model) {
                        if ( idStr::Icmp(model, name) ) {
                                return true;
                        }
                }
        }

        return false;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
entity_t *Entity_New() {
        entity_t *ent = new entity_t;
        
        ent->prev = ent->next = NULL;
        ent->brushes.prev = ent->brushes.next = NULL;
        ent->brushes.oprev = ent->brushes.onext = NULL;
        ent->brushes.owner = NULL;
        ent->undoId = 0;
        ent->redoId = 0;
        ent->entityId = g_entityId++;
        ent->origin.Zero();
        ent->eclass = NULL;
        ent->md3Class = NULL;
        ent->lightOrigin.Zero();
        ent->lightRotation.Identity();
        ent->trackLightOrigin = false;
        ent->rotation.Identity();
        ent->lightDef = -1;
        ent->modelDef = -1;
        ent->soundEmitter = NULL;
        ent->curve = NULL;
        return ent;
}

void Entity_UpdateCurveData( entity_t *ent ) {
        
        if ( ent == NULL || ent->curve == NULL ) {
                return;
        }

        const idKeyValue *kv = ent->epairs.MatchPrefix( CURVE_TAG );
        if ( kv == NULL ) { 
                if ( ent->curve ) {
                        delete ent->curve;
                        ent->curve = NULL;
                        if ( g_qeglobals.d_select_mode == sel_editpoint ) {
                                g_qeglobals.d_select_mode = sel_brush;
                        }
                }
                return;
        }

        int c = ent->curve->GetNumValues();
        idStr str = va( "%i ( ", c );
        idVec3 v;
        for ( int i = 0; i < c; i++ ) {
                v = ent->curve->GetValue( i );
                str += " ";
                str += v.ToString();
                str += " ";
        }
        str += " )";

        ent->epairs.Set( kv->GetKey(), str );

}

idCurve<idVec3> *Entity_MakeCurve( entity_t *ent ) {
        const idKeyValue *kv = ent->epairs.MatchPrefix( CURVE_TAG );
        if ( kv ) {
                idStr str = kv->GetKey().Right( kv->GetKey().Length() - strlen( CURVE_TAG ) );
                if ( str.Icmp( "CatmullRomSpline" ) == 0 ) {
                        return new idCurve_CatmullRomSpline<idVec3>();
                } else if ( str.Icmp( "Nurbs" ) == 0 ) {
                        return new idCurve_NURBS<idVec3>();
                }
        }
        return NULL;
}

void Entity_SetCurveData( entity_t *ent ) {

        ent->curve = Entity_MakeCurve( ent );
        const idKeyValue *kv = ent->epairs.MatchPrefix( CURVE_TAG );
        if ( kv && ent->curve ) {
                idLexer lex;
                lex.LoadMemory( kv->GetValue(), kv->GetValue().Length(), "_curve" );
                int numPoints = lex.ParseInt();
                if ( numPoints > 0 ) {
                        float *fp = new float[numPoints * 3];
                        lex.Parse1DMatrix( numPoints * 3, fp );
                        int time = 0;
                        for ( int i = 0; i < numPoints * 3; i += 3 ) {
                                idVec3 v;
                                v.x = fp[i];
                                v.y = fp[i+1];
                                v.z = fp[i+2];
                                ent->curve->AddValue( time, v );
                                time += 100;
                        }
                        delete []fp;
                }
        }

}

entity_t *Entity_PostParse(entity_t *ent, brush_t *pList) {
        bool            has_brushes;
        eclass_t        *e;
        brush_t         *b;
        idVec3          mins, maxs, zero;
        idBounds bo;

        zero.Zero();

        Entity_SetCurveData( ent );

        if (ent->brushes.onext == &ent->brushes) {
                has_brushes = false;
        }
        else {
                has_brushes = true;
        }

        bool needsOrigin = !GetVectorForKey(ent, "origin", ent->origin);
        const char      *pModel = ValueForKey(ent, "model");

        const char *cp = ValueForKey(ent, "classname");

        if (strlen(cp)) {
                e = Eclass_ForName(cp, has_brushes);
        } else {
                const char *cp2 = ValueForKey(ent, "name");
                if (strlen(cp2)) {
                        char buff[1024];
                        strcpy(buff, cp2);
                        int len = strlen(buff);
                        while ((isdigit(buff[len-1]) || buff[len-1] == '_') && len > 0) {
                                buff[len-1] = '\0';
                                len--;
                        }
                        e = Eclass_ForName(buff, has_brushes);
                        SetKeyValue(ent, "classname", buff, false);
                } else {
                        e = Eclass_ForName("", has_brushes);
                }
        }

        idStr str;
        
        if (e->defArgs.GetString("model", "", str) && e->entityModel == NULL) {
                e->entityModel = gameEdit->ANIM_GetModelFromEntityDef( &e->defArgs );
        }
        
        ent->eclass = e;

        bool hasModel = EntityHasModel(ent);

        if (hasModel) {
                ent->eclass->defArgs.GetString("model", "", str);
                if (str.Length()) {
                        hasModel = false;
                        ent->epairs.Delete("model");
                }
        }

        if (e->nShowFlags & ECLASS_WORLDSPAWN) {
                ent->origin.Zero();
                needsOrigin = false;
                ent->epairs.Delete( "model" );
        } else if (e->nShowFlags & ECLASS_LIGHT) {
                if (GetVectorForKey(ent, "light_origin", ent->lightOrigin)) {
                        GetMatrixForKey(ent, "light_rotation", ent->lightRotation);
                        ent->trackLightOrigin = true;
                } else if (hasModel) {
                        SetKeyValue(ent, "light_origin", ValueForKey(ent, "origin"));
                        ent->lightOrigin = ent->origin;
                        if (GetMatrixForKey(ent, "rotation", ent->lightRotation)) {
                                SetKeyValue(ent, "light_rotation", ValueForKey(ent, "rotation"));
                        }
                        ent->trackLightOrigin = true;
                }
        } else if ( e->nShowFlags & ECLASS_ENV ) {
                // need to create an origin from the bones here
                idVec3 org;
                idAngles ang;
                bo.Clear();
                bool hasBody = false;
                const idKeyValue *arg = ent->epairs.MatchPrefix( "body ", NULL );
                while ( arg ) {
                        sscanf( arg->GetValue(), "%f %f %f %f %f %f", &org.x, &org.y, &org.z, &ang.pitch, &ang.yaw, &ang.roll );
                        bo.AddPoint( org );
                        arg = ent->epairs.MatchPrefix( "body ", arg );
                        hasBody = true;
                }
                if (hasBody) {
                        ent->origin = bo.GetCenter();
                }
        }

        if (e->fixedsize || hasModel) {                 // fixed size entity
                if (ent->brushes.onext != &ent->brushes) {
                        for (b = ent->brushes.onext; b != &ent->brushes; b = b->onext) {
                                b->entityModel = true;
                        }
                }

                if (hasModel) {
                        // model entity
                        idRenderModel *modelHandle = renderModelManager->FindModel( pModel );

                        if ( dynamic_cast<idRenderModelPrt*>( modelHandle ) || dynamic_cast<idRenderModelLiquid*>( modelHandle ) ) {
                                bo.Zero();
                                bo.ExpandSelf( 12.0f );
                        } else {
                                bo = modelHandle->Bounds( NULL );
                        }

                        VectorCopy(bo[0], mins);
                        VectorCopy(bo[1], maxs);
                        for (int i = 0; i < 3; i++) {
                                if (mins[i] == maxs[i]) {
                                        mins[i]--;
                                        maxs[i]++;
                                }
                        }
                        VectorAdd(mins, ent->origin, mins);
                        VectorAdd(maxs, ent->origin, maxs);
                        b = Brush_Create(mins, maxs, &e->texdef);
                        b->modelHandle = modelHandle;

                        float           yaw = 0;
                        bool            convertAngles = GetFloatForKey(ent, "angle", &yaw);
                        extern void Brush_Rotate(brush_t *b, idMat3 matrix, idVec3 origin, bool bBuild);
                        extern void Brush_Rotate(brush_t *b, idVec3 rot, idVec3 origin, bool bBuild);
                        
                        if (convertAngles) {
                                idVec3  rot(0, 0, yaw);
                                Brush_Rotate(b, rot, ent->origin, false);
                        }

                        if (GetMatrixForKey(ent, "rotation", ent->rotation)) {
                                idBounds bo2;
                                bo2.FromTransformedBounds(bo, ent->origin, ent->rotation);
                                b->owner = ent;
                                Brush_Resize(b, bo2[0], bo2[1]);
                        }
                        Entity_LinkBrush(ent, b);
                }

                if (!hasModel || (ent->eclass->nShowFlags & ECLASS_LIGHT && hasModel)) {
                        // create a custom brush
                        if (ent->trackLightOrigin) {
                                mins = e->mins + ent->lightOrigin;
                                maxs = e->maxs + ent->lightOrigin;
                        } else {
                                mins = e->mins + ent->origin;
                                maxs = e->maxs + ent->origin;
                        }

                        b = Brush_Create(mins, maxs, &e->texdef);
                        GetMatrixForKey(ent, "rotation", ent->rotation);
                        Entity_LinkBrush(ent, b);
                        b->trackLightOrigin = ent->trackLightOrigin;
                        if ( e->texdef.name == NULL ) {
                                brushprimit_texdef_t bp;
                                texdef_t td;
                                td.SetName( ent->eclass->defMaterial );
                                Brush_SetTexture( b, &td, &bp, false );
                        }
                }
        } else {        // brush entity
                if (ent->brushes.next == &ent->brushes) {
                        printf("Warning: Brush entity with no brushes\n");
                }

                if (!needsOrigin) {
                        idStr cn = ValueForKey(ent, "classname");
                        idStr name = ValueForKey(ent, "name");
                        idStr model = ValueForKey(ent, "model");
                        if (cn.Icmp("func_static") == 0) {
                                if (name.Icmp(model) == 0) {
                                        needsOrigin = true;
                                }
                        }
                }

                if (needsOrigin) {
                        idVec3  mins, maxs, mid;
                        int             i;
                        char    text[32];
                        mins[0] = mins[1] = mins[2] = 999999;
                        maxs[0] = maxs[1] = maxs[2] = -999999;

                        // add in the origin
                        for (b = ent->brushes.onext; b != &ent->brushes; b = b->onext) {
                                Brush_Build(b, true, false, false);
                                for (i = 0; i < 3; i++) {
                                        if (b->mins[i] < mins[i]) {
                                                mins[i] = b->mins[i];
                                        }

                                        if (b->maxs[i] > maxs[i]) {
                                                maxs[i] = b->maxs[i];
                                        }
                                }
                        }

                        for (i = 0; i < 3; i++) {
                                ent->origin[i] = (mins[i] + ((maxs[i] - mins[i]) / 2));
                        }

                        sprintf(text, "%i %i %i", (int)ent->origin[0], (int)ent->origin[1], (int)ent->origin[2]);
                        SetKeyValue(ent, "origin", text);
                }

                if (!(e->nShowFlags & ECLASS_WORLDSPAWN)) {
                        if (e->defArgs.FindKey("model") == NULL && (pModel == NULL || (pModel && strlen(pModel) == 0))) {
                                SetKeyValue(ent, "model", ValueForKey(ent, "name"));
                        }
                }
                else {
                        DeleteKey(ent, "origin");
                }
        }

        // add all the brushes to the main list
        if (pList) {
                for (b = ent->brushes.onext; b != &ent->brushes; b = b->onext) {
                        b->next = pList->next;
                        pList->next->prev = b;
                        b->prev = pList;
                        pList->next = b;
                }
        }

        FixFloats(&ent->epairs);

        return ent;

}

/*
 =======================================================================================================================
    Entity_Parse If onlypairs is set, the classname info will not be looked up, and the entity will not be added to the
    global list. Used for parsing the project.
 =======================================================================================================================
 */
entity_t *Entity_Parse(bool onlypairs, brush_t *pList) {
        entity_t        *ent;

        if (!GetToken(true)) {
                return NULL;
        }

        if (strcmp(token, "{")) {
                Error("ParseEntity: { not found");
        }

        ent = Entity_New();
        ent->brushes.onext = ent->brushes.oprev = &ent->brushes;
        ent->origin.Zero();

        int n = 0;
        do {
                if (!GetToken(true)) {
                        Warning("ParseEntity: EOF without closing brace");
                        return NULL;
                }

                if (!strcmp(token, "}")) {
                        break;
                }

                if (!strcmp(token, "{")) {
                        GetVectorForKey(ent, "origin", ent->origin);
                        brush_t *b = Brush_Parse(ent->origin);
                        if (b != NULL) {
                                b->owner = ent;

                                // add to the end of the entity chain
                                b->onext = &ent->brushes;
                                b->oprev = ent->brushes.oprev;
                                ent->brushes.oprev->onext = b;
                                ent->brushes.oprev = b;
                        }
                        else {
                                break;
                        }
                }
                else {
                        ParseEpair(&ent->epairs);
                }
        } while (1);

        if (onlypairs) {
                return ent;
        }

        return Entity_PostParse(ent, pList);
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void VectorMidpoint(idVec3 va, idVec3 vb, idVec3 &out) {
        for (int i = 0; i < 3; i++) {
                out[i] = va[i] + ((vb[i] - va[i]) / 2);
        }
}

/*
 =======================================================================================================================
    Entity_Write
 =======================================================================================================================
 */
void Entity_Write(entity_t *e, FILE *f, bool use_region) {
        brush_t *b;
        idVec3  origin;
        char    text[128];
        int             count;

        // if none of the entities brushes are in the region, don't write the entity at all
        if (use_region) {
                // in region mode, save the camera position as playerstart
                if (!strcmp(ValueForKey(e, "classname"), "info_player_start")) {
                        fprintf(f, "{\n");
                        fprintf(f, "\"classname\" \"info_player_start\"\n");
                        fprintf
                        (
                                f,
                                "\"origin\" \"%i %i %i\"\n",
                                (int)g_pParentWnd->GetCamera()->Camera().origin[0],
                                (int)g_pParentWnd->GetCamera()->Camera().origin[1],
                                (int)g_pParentWnd->GetCamera()->Camera().origin[2]
                        );
                        fprintf(f, "\"angle\" \"%i\"\n", (int)g_pParentWnd->GetCamera()->Camera().angles[YAW]);
                        fprintf(f, "}\n");
                        return;
                }

                for (b = e->brushes.onext; b != &e->brushes; b = b->onext) {
                        if (!Map_IsBrushFiltered(b)) {
                                break;  // got one
                        }
                }

                if (b == &e->brushes) {
                        return;         // nothing visible
                }
        }

        if (e->eclass->nShowFlags & ECLASS_PLUGINENTITY) {
                // NOTE: the whole brush placement / origin stuff is a mess
                VectorCopy(e->origin, origin);
                sprintf(text, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
                SetKeyValue(e, "origin", text);
        }

        // if fixedsize, calculate a new origin based on the current brush position
        else if (e->eclass->fixedsize || EntityHasModel(e)) {
                if (!GetVectorForKey(e, "origin", origin)) {
                        VectorSubtract(e->brushes.onext->mins, e->eclass->mins, origin);
                        sprintf(text, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
                        SetKeyValue(e, "origin", text);
                }
        }

        fprintf(f, "{\n");

        count = e->epairs.GetNumKeyVals();
        for (int j = 0; j < count; j++) {
                fprintf(f, "\"%s\" \"%s\"\n", e->epairs.GetKeyVal(j)->GetKey().c_str(), e->epairs.GetKeyVal(j)->GetValue().c_str());
        }

        if (!EntityHasModel(e)) {
                count = 0;
                for (b = e->brushes.onext; b != &e->brushes; b = b->onext) {
                        if (e->eclass->fixedsize && !b->entityModel) {
                                continue;
                        }
                        if (!use_region || !Map_IsBrushFiltered(b)) {
                                fprintf(f, "// brush %i\n", count);
                                count++;
                                Brush_Write( b, f, e->origin, ( g_PrefsDlg.m_bNewMapFormat != FALSE ) );
                        }
                }
        }

        fprintf(f, "}\n");
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
bool IsBrushSelected(brush_t *bSel) {
        for (brush_t * b = selected_brushes.next; b != NULL && b != &selected_brushes; b = b->next) {
                if (b == bSel) {
                        return true;
                }
        }

        return false;
}

//
// =======================================================================================================================
//    Entity_WriteSelected
// =======================================================================================================================
//
void Entity_WriteSelected(entity_t *e, FILE *f) {
        brush_t *b;
        idVec3  origin;
        char    text[128];
        int             count;

        for (b = e->brushes.onext; b != &e->brushes; b = b->onext) {
                if (IsBrushSelected(b)) {
                        break;  // got one
                }
        }

        if (b == &e->brushes) {
                return;         // nothing selected
        }

        // if fixedsize, calculate a new origin based on the current brush position
        if (e->eclass->fixedsize || EntityHasModel(e)) {
                if (!GetVectorForKey(e, "origin", origin)) {
                        VectorSubtract(e->brushes.onext->mins, e->eclass->mins, origin);
                        sprintf(text, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
                        SetKeyValue(e, "origin", text);
                }
        }

        fprintf(f, "{\n");
        
        count = e->epairs.GetNumKeyVals();
        for (int j = 0; j < count; j++) {
                fprintf(f, "\"%s\" \"%s\"\n", e->epairs.GetKeyVal(j)->GetKey().c_str(), e->epairs.GetKeyVal(j)->GetValue().c_str());
        }

        if (!EntityHasModel(e)) {
                count = 0;
                for (b = e->brushes.onext; b != &e->brushes; b = b->onext) {
                        if (e->eclass->fixedsize && !b->entityModel) {
                                continue;
                        }
                        if (IsBrushSelected(b)) {
                                fprintf(f, "// brush %i\n", count);
                                count++;
                                Brush_Write( b, f, e->origin, ( g_PrefsDlg.m_bNewMapFormat != FALSE ) );
                        }
                }
        }

        fprintf(f, "}\n");
}

//
// =======================================================================================================================
//    Entity_WriteSelected to a CMemFile
// =======================================================================================================================
//
void Entity_WriteSelected(entity_t *e, CMemFile *pMemFile) {
        brush_t *b;
        idVec3  origin;
        char    text[128];
        int             count;

        for (b = e->brushes.onext; b != &e->brushes; b = b->onext) {
                if (IsBrushSelected(b)) {
                        break;  // got one
                }
        }

        if (b == &e->brushes) {
                return;         // nothing selected
        }

        // if fixedsize, calculate a new origin based on the current brush position
        if (e->eclass->fixedsize || EntityHasModel(e)) {
                if (!GetVectorForKey(e, "origin", origin)) {
                        VectorSubtract(e->brushes.onext->mins, e->eclass->mins, origin);
                        sprintf(text, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
                        SetKeyValue(e, "origin", text);
                }
        }

        MemFile_fprintf(pMemFile, "{\n");

        count = e->epairs.GetNumKeyVals();
        for (int j = 0; j < count; j++) {
                MemFile_fprintf(pMemFile, "\"%s\" \"%s\"\n", e->epairs.GetKeyVal(j)->GetKey().c_str(), e->epairs.GetKeyVal(j)->GetValue().c_str());
        }

        if (!EntityHasModel(e)) {
                count = 0;
                for (b = e->brushes.onext; b != &e->brushes; b = b->onext) {
                        if (e->eclass->fixedsize && !b->entityModel) {
                                continue;
                        }
                        if (IsBrushSelected(b)) {
                                MemFile_fprintf(pMemFile, "// brush %i\n", count);
                                count++;
                                Brush_Write( b, pMemFile, e->origin, ( g_PrefsDlg.m_bNewMapFormat != FALSE ) );
                        }
                }
        }

        MemFile_fprintf(pMemFile, "}\n");
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void Entity_SetName(entity_t *e, const char *name) {
        CString oldName = ValueForKey(e, "name");
        CString oldModel = ValueForKey(e, "model");
        SetKeyValue(e, "name", name);
        if (oldName == oldModel) {
                SetKeyValue(e, "model", name);
        }
}

extern bool Entity_NameIsUnique(const char *name);

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void Entity_Name(entity_t *e, bool force) {
        const char      *name = ValueForKey(e, "name");

        if (!force && name && name[0]) {
                return;
        }

        if (name && name[0] && Entity_NameIsUnique(name)) {
                return;
        }

        bool    setModel = false;
        if (name[0]) {
                const char      *model = ValueForKey(e, "model");
                if (model[0]) {
                        if ( idStr::Icmp(model, name) == 0 ) {
                                setModel = true;
                        }
                }
        }

        const char *eclass = ValueForKey(e, "classname");
        if (eclass && eclass[0]) {
                idStr str = cvarSystem->GetCVarString( "radiant_nameprefix" );
                int id = Map_GetUniqueEntityID(str, eclass);
                if (str.Length()) {
                        SetKeyValue(e, "name", va("%s_%s_%i", str.c_str(), eclass, id));
                } else {
                        SetKeyValue(e, "name", va("%s_%i", eclass, id));
                }
                if (setModel) {
                        if (str.Length()) {
                                SetKeyValue(e, "model", va("%s_%s_%i", str.c_str(), eclass, id));
                        } else {
                                SetKeyValue(e, "model", va("%s_%i",  eclass, id));
                        }
                }
        }
}

/*
 =======================================================================================================================
    Entity_Create Creates a new entity out of the selected_brushes list. If the entity class is fixed size, the brushes
    are only used to find a midpoint. Otherwise, the brushes have their ownership transfered to the new entity.
 =======================================================================================================================
 */
entity_t *Entity_Create(eclass_t *c, bool forceFixed) {
        entity_t        *e;
        brush_t         *b;
        idVec3          mins, maxs, origin;
        char            text[32];
        texdef_t td;
        brushprimit_texdef_t bp;

        // check to make sure the brushes are ok
        for (b = selected_brushes.next; b != &selected_brushes; b = b->next) {
                if (b->owner != world_entity) {
                        Sys_Status("Entity NOT created, brushes not all from world\n");
                        Sys_Beep();
                        return NULL;
                }
        }

        idStr str;
        if (c->defArgs.GetString("model", "", str) && c->entityModel == NULL) {
                c->entityModel = gameEdit->ANIM_GetModelFromEntityDef( &c->defArgs );
        }

        // create it
        e = Entity_New();
        e->brushes.onext = e->brushes.oprev = &e->brushes;
        e->eclass = c;
        e->epairs.Copy(c->args);
        SetKeyValue(e, "classname", c->name);
        Entity_Name(e, false);

        // add the entity to the entity list
        Entity_AddToList(e, &entities);

        if (c->fixedsize) {
                //
                // just use the selection for positioning b = selected_brushes.next; for (i=0 ;
                // i<3 ; i++) { e->origin[i] = b->mins[i] - c->mins[i]; }
                //
                Select_GetMid(e->origin);
                VectorCopy(e->origin, origin);

                // create a custom brush
                VectorAdd(c->mins, e->origin, mins);
                VectorAdd(c->maxs, e->origin, maxs);

                b = Brush_Create(mins, maxs, &c->texdef);

                Entity_LinkBrush(e, b);

                if (c->defMaterial.Length()) {
                        td.SetName(c->defMaterial);
                        Brush_SetTexture(b, &td, &bp, false);
                }


                // delete the current selection
                Select_Delete();

                // select the new brush
                b->next = b->prev = &selected_brushes;
                selected_brushes.next = selected_brushes.prev = b;

                Brush_Build(b);
        }
        else {

                Select_GetMid(origin);

                // change the selected brushes over to the new entity
                for (b = selected_brushes.next; b != &selected_brushes; b = b->next) {
                        Entity_UnlinkBrush(b);
                        Entity_LinkBrush(e, b);
                        Brush_Build(b); // so the key brush gets a name
                        if (c->defMaterial.Length()) {
                                td.SetName(c->defMaterial);
                                Brush_SetTexture(b, &td, &bp, false);
                        }

                }

                //for (int i = 0; i < 3; i++) {
                //      origin[i] = vMin[i] + vMax[i] * 0.5;
                //}

                if (!forceFixed) {
                        SetKeyValue(e, "model", ValueForKey(e, "name"));
                }
        }

        sprintf(text, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
        SetKeyValue(e, "origin", text);
        VectorCopy(origin, e->origin);

        Sys_UpdateWindows(W_ALL);
        return e;
}

void Brush_MakeDirty(brush_t *b) {
        for (face_t *f = b->brush_faces; f; f = f->next) {
                f->dirty = true;
        }
}
/*
 =======================================================================================================================
    Entity_LinkBrush
 =======================================================================================================================
 */
void Entity_LinkBrush(entity_t *e, brush_t *b) {
        if (b->oprev || b->onext) {
                Error("Entity_LinkBrush: Allready linked");
        }

        Brush_MakeDirty(b);

        b->owner = e;

        b->onext = e->brushes.onext;
        b->oprev = &e->brushes;
        e->brushes.onext->oprev = b;
        e->brushes.onext = b;
}

/*
 =======================================================================================================================
    Entity_UnlinkBrush
 =======================================================================================================================
 */
void Entity_UnlinkBrush(brush_t *b) {
        // if (!b->owner || !b->onext || !b->oprev)
        if (!b->onext || !b->oprev) {
                Error("Entity_UnlinkBrush: Not currently linked");
        }

        b->onext->oprev = b->oprev;
        b->oprev->onext = b->onext;
        b->onext = b->oprev = NULL;
        b->owner = NULL;
}

/*
 =======================================================================================================================
    Entity_Clone
 =======================================================================================================================
 */
entity_t *Entity_Clone(entity_t *e) {
        entity_t        *n;

        n = Entity_New();
        n->brushes.onext = n->brushes.oprev = &n->brushes;
        n->eclass = e->eclass;
        n->rotation = e->rotation;
        n->origin = e->origin;

        // add the entity to the entity list
        Entity_AddToList(n, &entities);

        n->epairs  = e->epairs;

        return n;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
int GetUniqueTargetId(int iHint) {
        int                     iMin, iMax, i;
        BOOL            fFound;
        entity_t        *pe;

        fFound = FALSE;
        pe = entities.next;
        iMin = 0;
        iMax = 0;

        for (; pe != NULL && pe != &entities; pe = pe->next) {
                i = IntForKey(pe, "target");
                if (i) {
                        iMin = Min(i, iMin);
                        iMax = Max(i, iMax);
                        if (i == iHint) {
                                fFound = TRUE;
                        }
                }
        }

        if (fFound) {
                return iMax + 1;
        }
        else {
                return iHint;
        }
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
entity_t *FindEntity(const char *pszKey, const char *pszValue) {
        entity_t        *pe;

        pe = entities.next;

        for (; pe != NULL && pe != &entities; pe = pe->next) {
                if (!strcmp(ValueForKey(pe, pszKey), pszValue)) {
                        return pe;
                }
        }

        return NULL;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
entity_t *FindEntityInt(const char *pszKey, int iValue) {
        entity_t        *pe;

        pe = entities.next;

        for (; pe != NULL && pe != &entities; pe = pe->next) {
                if (IntForKey(pe, pszKey) == iValue) {
                        return pe;
                }
        }

        return NULL;
}

/*
====================
Entity_UpdateSoundEmitter

Deletes the soundEmitter if the entity should not emit a sound due
to it not having one, being filtered away, or the sound mode being turned off.

Creates or updates the soundEmitter if needed
====================
*/
void Entity_UpdateSoundEmitter( entity_t *ent ) {
        bool    playing = false;

        // if an entity doesn't have any brushes at all, don't do anything
        // if the brush isn't displayed (filtered or culled), don't do anything
        if ( g_pParentWnd->GetCamera()->GetSoundMode() 
                && ent->brushes.onext != &ent->brushes && !FilterBrush(ent->brushes.onext) ) {
                // check for sounds
                const char *v = ValueForKey( ent, "s_shader" );
                if ( v[0] ) {
                        refSound_t      sound;

                        gameEdit->ParseSpawnArgsToRefSound( &ent->epairs, &sound );
                        if ( !sound.waitfortrigger ) {  // waitfortrigger will not start playing immediately
                                if ( !ent->soundEmitter ) {
                                        ent->soundEmitter = g_qeglobals.sw->AllocSoundEmitter();
                                }
                                playing = true;
                                ent->soundEmitter->UpdateEmitter( ent->origin, 0, &sound.parms );
                                // always play on a single channel, so updates always override
                                ent->soundEmitter->StartSound( sound.shader, SCHANNEL_ONE );
                        }
                }
        }

        // delete the soundEmitter if not used
        if ( !playing && ent->soundEmitter ) {
                ent->soundEmitter->Free( true );
                ent->soundEmitter = NULL;
        }

}