patch.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena 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 2 of the License,
or (at your option) any later version.

Quake III Arena 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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
#include "qbsp.h"


void PrintCtrl( vec3_t ctrl[9] ) {
    int     i, j;

    for ( i = 0 ; i < 3 ; i++ ) {
        for ( j = 0 ; j < 3 ; j++ ) {
            _printf("(%5.2f %5.2f %5.2f) ", ctrl[i*3+j][0], ctrl[i*3+j][1], ctrl[i*3+j][2] );
        }
        _printf("\n");
    }
}

/*
================
DrawSurfaceForMesh
================
*/
mapDrawSurface_t    *DrawSurfaceForMesh( mesh_t *m ) {
    mapDrawSurface_t    *ds;
    int             i, j;
    mesh_t          *copy;

    // to make valid normals for patches with degenerate edges,
    // we need to make a copy of the mesh and put the aproximating
    // points onto the curve
    copy = CopyMesh( m );
    PutMeshOnCurve( *copy );
    MakeMeshNormals( *copy );
    for ( j = 0 ; j < m->width ; j++ ) {
        for ( i = 0 ; i < m->height ; i++ ) {
            VectorCopy( copy->verts[i*m->width+j].normal, m->verts[i*m->width+j].normal );
        }
    }
    FreeMesh( copy );

    ds = AllocDrawSurf();
    ds->mapBrush = NULL;
    ds->side = NULL;

    ds->patch = qtrue;
    ds->patchWidth = m->width;
    ds->patchHeight = m->height;
    ds->numVerts = ds->patchWidth * ds->patchHeight;
    ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) );
    memcpy( ds->verts, m->verts, ds->numVerts * sizeof( *ds->verts ) );

    ds->lightmapNum = -1;
    ds->fogNum = -1;

    return ds;
}

/*
=================
ParsePatch

Creates a mapDrawSurface_t from the patch text
=================
*/
void ParsePatch( void ) {
    vec_t       info[5];
    int         i, j;
    parseMesh_t *pm;
    char        texture[MAX_QPATH];
    char        shader[MAX_QPATH];
    mesh_t      m;
    drawVert_t  *verts;
  epair_t *ep;

    MatchToken( "{" );

    // get texture
    GetToken (qtrue);
    strcpy( texture, token );

    // save the shader name for retexturing
    if ( numMapIndexedShaders == MAX_MAP_BRUSHSIDES ) {
        Error( "MAX_MAP_BRUSHSIDES" );
    }
    strcpy( mapIndexedShaders[numMapIndexedShaders], texture );
    numMapIndexedShaders++;


    Parse1DMatrix( 5, info );
    m.width = info[0];
    m.height = info[1];
    m.verts = verts = malloc( m.width * m.height * sizeof( m.verts[0] ) );

    if ( m.width < 0 || m.width > MAX_PATCH_SIZE
        || m.height < 0 || m.height > MAX_PATCH_SIZE ) {
        Error("ParsePatch: bad size");
    }

    MatchToken( "(" );
    for ( j = 0 ; j < m.width ; j++ ) {
        MatchToken( "(" );
        for ( i = 0 ; i < m.height ; i++ ) {
            Parse1DMatrix( 5, verts[i*m.width+j].xyz );
        }
        MatchToken( ")" );
    }
    MatchToken( ")" );

  // if brush primitives format, we may have some epairs to ignore here
  GetToken(qtrue);
  if (g_bBrushPrimit!=BPRIMIT_OLDBRUSHES && strcmp(token,"}"))
  {
    // NOTE: we leak that!
    ep = ParseEpair();
  }
  else
    UnGetToken();

    MatchToken( "}" );
    MatchToken( "}" );

    if ( noCurveBrushes ) {
        return;
    }

    // find default flags and values
    pm = malloc( sizeof( *pm ) );
    memset( pm, 0, sizeof( *pm ) );

    sprintf( shader, "textures/%s", texture );
    pm->shaderInfo = ShaderInfoForShader( shader ); 
    pm->mesh = m;

    // link to the entity
    pm->next = mapent->patches;
    mapent->patches = pm;
}


void GrowGroup_r( int patchNum, int patchCount, const byte *bordering, byte *group ) {
    int     i;
    const byte *row;

    if ( group[patchNum] ) {
        return;
    }
    group[patchNum] = 1;
    row = bordering + patchNum * patchCount;
    for ( i = 0 ; i < patchCount ; i++ ) {
        if ( row[i] ) {
            GrowGroup_r( i, patchCount, bordering, group );
        }
    }
}


/*
=====================
PatchMapDrawSurfs

Any patches that share an edge need to choose their
level of detail as a unit, otherwise the edges would
pull apart.
=====================
*/
void PatchMapDrawSurfs( entity_t *e ) {
    parseMesh_t         *pm;
    parseMesh_t         *check, *scan;
    mapDrawSurface_t    *ds;
    int                 patchCount, groupCount;
    int                 i, j, k, l, c1, c2;
    drawVert_t          *v1, *v2;
    vec3_t              bounds[2];
    byte                *bordering;
    parseMesh_t         *meshes[MAX_MAP_DRAW_SURFS];
    qboolean            grouped[MAX_MAP_DRAW_SURFS];
    byte                group[MAX_MAP_DRAW_SURFS];

    qprintf( "----- PatchMapDrawSurfs -----\n" );

    patchCount = 0;
    for ( pm = e->patches ; pm ; pm = pm->next  ) {
        meshes[patchCount] = pm;
        patchCount++;
    }

    if ( !patchCount ) {
        return;
    }
    bordering = malloc( patchCount * patchCount );
    memset( bordering, 0, patchCount * patchCount );

    // build the bordering matrix
    for ( k = 0 ; k < patchCount ; k++ ) {
        bordering[k*patchCount+k] = 1;

        for ( l = k+1 ; l < patchCount ; l++ ) {
            check = meshes[k];
            scan = meshes[l];
            c1 = scan->mesh.width * scan->mesh.height;
            v1 = scan->mesh.verts;

            for ( i = 0 ; i < c1 ; i++, v1++ ) {
                c2 = check->mesh.width * check->mesh.height;
                v2 = check->mesh.verts;
                for ( j = 0 ; j < c2 ; j++, v2++ ) {
                    if ( fabs( v1->xyz[0] - v2->xyz[0] ) < 1.0
                        && fabs( v1->xyz[1] - v2->xyz[1] ) < 1.0
                        && fabs( v1->xyz[2] - v2->xyz[2] ) < 1.0 ) {
                        break;
                    }
                }
                if ( j != c2 ) {
                    break;
                }
            }
            if ( i != c1 ) {
                // we have a connection
                bordering[k*patchCount+l] =
                bordering[l*patchCount+k] = 1;
            } else {
                // no connection
                bordering[k*patchCount+l] =
                bordering[l*patchCount+k] = 0;
            }

        }
    }

    // build groups
    memset( grouped, 0, sizeof(grouped) );
    groupCount = 0;
    for ( i = 0 ; i < patchCount ; i++ ) {
        if ( !grouped[i] ) {
            groupCount++;
        }

        // recursively find all patches that belong in the same group
        memset( group, 0, patchCount );
        GrowGroup_r( i, patchCount, bordering, group );

        // bound them
        ClearBounds( bounds[0], bounds[1] );
        for ( j = 0 ; j < patchCount ; j++ ) {
            if ( group[j] ) {
                grouped[j] = qtrue;
                scan = meshes[j];
                c1 = scan->mesh.width * scan->mesh.height;
                v1 = scan->mesh.verts;
                for ( k = 0 ; k < c1 ; k++, v1++ ) {
                    AddPointToBounds( v1->xyz, bounds[0], bounds[1] );
                }
            }
        }

        // create drawsurf
        scan = meshes[i];
        scan->grouped = qtrue;
        ds = DrawSurfaceForMesh( &scan->mesh );
        ds->shaderInfo = scan->shaderInfo;
        VectorCopy( bounds[0], ds->lightmapVecs[0] );
        VectorCopy( bounds[1], ds->lightmapVecs[1] );
    }

    qprintf( "%5i patches\n", patchCount );
    qprintf( "%5i patch LOD groups\n", groupCount );
}

---