fog.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"


int         c_fogFragment;
int         c_fogPatchFragments;

/*
====================
DrawSurfToMesh
====================
*/
mesh_t  *DrawSurfToMesh( mapDrawSurface_t *ds ) {
    mesh_t      *m;

    m = malloc( sizeof( *m ) );
    m->width = ds->patchWidth;
    m->height = ds->patchHeight;
    m->verts = malloc( sizeof(m->verts[0]) * m->width * m->height );
    memcpy( m->verts, ds->verts, sizeof(m->verts[0]) * m->width * m->height );

    return m;
}


/*
====================
SplitMeshByPlane
====================
*/
void SplitMeshByPlane( mesh_t *in, vec3_t normal, float dist, mesh_t **front, mesh_t **back ) {
    int     w, h, split;
    float   d[MAX_PATCH_SIZE][MAX_PATCH_SIZE];
    drawVert_t  *dv, *v1, *v2;
    int     c_front, c_back, c_on;
    mesh_t  *f, *b;
    int     i;
    float   frac;
    int     frontAprox, backAprox;

    for ( i = 0 ; i < 2 ; i++ ) {
        dv = in->verts;
        c_front = 0;
        c_back = 0;
        c_on = 0;
        for ( h = 0 ; h < in->height ; h++ ) {
            for ( w = 0 ; w < in->width ; w++, dv++ ) {
                d[h][w] = DotProduct( dv->xyz, normal ) - dist;
                if ( d[h][w] > ON_EPSILON ) {
                    c_front++;
                } else if ( d[h][w] < -ON_EPSILON ) {
                    c_back++;
                } else {
                    c_on++;
                }
            }
        }

        *front = NULL;
        *back = NULL;

        if ( !c_front ) {
            *back = in;
            return;
        }
        if ( !c_back ) {
            *front = in;
            return;
        }

        // find a split point
        split = -1;
        for ( w = 0 ; w < in->width -1 ; w++ ) {
            if ( ( d[0][w] < 0 ) != ( d[0][w+1] < 0 ) ) {
                if ( split == -1 ) {
                    split = w;
                    break;
                }
            }
        }

        if ( split == -1 ) {
            if ( i == 1 ) {
                qprintf( "No crossing points in patch\n");
                *front = in;
                return;
            }

            in = TransposeMesh( in );
            InvertMesh( in );
            continue;
        }

        // make sure the split point stays the same for all other rows
        for ( h = 1 ; h < in->height ; h++ ) {
            for ( w = 0 ; w < in->width -1 ; w++ ) {
                if ( ( d[h][w] < 0 ) != ( d[h][w+1] < 0 ) ) {
                    if ( w != split ) {
                        _printf( "multiple crossing points for patch -- can't clip\n");
                        *front = in;
                        return;
                    }
                }
            }
            if ( ( d[h][split] < 0 ) == ( d[h][split+1] < 0 ) ) {
                _printf( "differing crossing points for patch -- can't clip\n");
                *front = in;
                return;
            }
        }

        break;
    }


    // create two new meshes
    f = malloc( sizeof( *f ) );
    f->width = split + 2;
    if ( ! (f->width & 1) ) {
        f->width++;
        frontAprox = 1;
    } else {
        frontAprox = 0;
    }
    if ( f->width > MAX_PATCH_SIZE ) {
        Error( "MAX_PATCH_SIZE after split");
    }
    f->height = in->height;
    f->verts = malloc( sizeof(f->verts[0]) * f->width * f->height );

    b = malloc( sizeof( *b ) );
    b->width = in->width - split;
    if ( ! (b->width & 1) ) {
        b->width++;
        backAprox = 1;
    } else {
        backAprox = 0;
    }
    if ( b->width > MAX_PATCH_SIZE ) {
        Error( "MAX_PATCH_SIZE after split");
    }
    b->height = in->height;
    b->verts = malloc( sizeof(b->verts[0]) * b->width * b->height );

    if ( d[0][0] > 0 ) {
        *front = f;
        *back = b;
    } else {
        *front = b;
        *back = f;
    }

    // distribute the points
    for ( w = 0 ; w < in->width ; w++ ) {
        for ( h = 0 ; h < in->height ; h++ ) {
            if ( w <= split ) {
                f->verts[ h * f->width + w ] = in->verts[ h * in->width + w ];
            } else {
                b->verts[ h * b->width + w - split + backAprox ] = in->verts[ h * in->width + w ];
            }
        }
    }

    // clip the crossing line
    for ( h = 0 ; h < in->height ; h++ ) {
        dv = &f->verts[ h * f->width + split + 1 ];
        v1 = &in->verts[ h * in->width + split ];
        v2 = &in->verts[ h * in->width + split + 1 ];
        frac = d[h][split] / ( d[h][split] - d[h][split+1] );
        for ( i = 0 ; i < 10 ; i++ ) {
            dv->xyz[i] = v1->xyz[i] + frac * ( v2->xyz[i] - v1->xyz[i] );
        }
        dv->xyz[10] = 0;//set all 4 colors to 0 
        if ( frontAprox ) {
            f->verts[ h * f->width + split + 2 ] = *dv;
        }
        b->verts[ h * b->width ] = *dv;
        if ( backAprox ) {
            b->verts[ h * b->width + 1 ] = *dv;
        }
    }

    /*
PrintMesh( in );
_printf("\n");
PrintMesh( f );
_printf("\n");
PrintMesh( b );
_printf("\n");
    */

    FreeMesh( in );
}


/*
====================
ChopPatchByBrush
====================
*/
qboolean ChopPatchByBrush( mapDrawSurface_t *ds, bspbrush_t *b ) {
    int         i, j;
    side_t      *s;
    plane_t     *plane;
    mesh_t      *outside[MAX_BRUSH_SIDES];
    int         numOutside;
    mesh_t      *m, *front, *back;
    mapDrawSurface_t    *newds;

    m = DrawSurfToMesh( ds );
    numOutside = 0;

    // only split by the top and bottom planes to avoid
    // some messy patch clipping issues

    for ( i = 4 ; i <= 5 ; i++ ) {
        s = &b->sides[ i ];
        plane = &mapplanes[ s->planenum ];

        SplitMeshByPlane( m, plane->normal, plane->dist, &front, &back );

        if ( !back ) {
            // nothing actually contained inside
            for ( j = 0 ; j < numOutside ; j++ ) {
                FreeMesh( outside[j] );
            }
            return qfalse;
        }
        m = back;

        if ( front ) {
            if ( numOutside == MAX_BRUSH_SIDES ) {
                Error( "MAX_BRUSH_SIDES" );
            }
            outside[ numOutside ] = front;
            numOutside++;
        }
    }

    // all of outside fragments become seperate drawsurfs
    c_fogPatchFragments += numOutside;
    for ( i = 0 ; i < numOutside ; i++ ) {
        newds = DrawSurfaceForMesh( outside[ i ] );
        newds->shaderInfo = ds->shaderInfo;
        FreeMesh( outside[ i ] );
    }

    // replace ds with m
    ds->patchWidth = m->width;
    ds->patchHeight = m->height;
    ds->numVerts = m->width * m->height;
    free( ds->verts );
    ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) );
    memcpy( ds->verts, m->verts, ds->numVerts * sizeof( *ds->verts ) );

    FreeMesh( m );

    return qtrue;
}

//===============================================================================

/*
====================
WindingFromDrawSurf
====================
*/
winding_t   *WindingFromDrawSurf( mapDrawSurface_t *ds ) {
    winding_t   *w;
    int         i;

    w = AllocWinding( ds->numVerts );
    w->numpoints = ds->numVerts;
    for ( i = 0 ; i < ds->numVerts ; i++ ) {
        VectorCopy( ds->verts[i].xyz, w->p[i] );
    }
    return w;
}

/*
====================
ChopFaceByBrush

There may be a fragment contained in the brush
====================
*/
qboolean ChopFaceByBrush( mapDrawSurface_t *ds, bspbrush_t *b ) {
    int         i, j;
    side_t      *s;
    plane_t     *plane;
    winding_t   *w;
    winding_t   *front, *back;
    winding_t   *outside[MAX_BRUSH_SIDES];
    int         numOutside;
    mapDrawSurface_t    *newds;
    drawVert_t      *dv;
    shaderInfo_t    *si;
    float       mins[2];

    // brush primitive :
    // axis base
    vec3_t      texX,texY;
    vec_t       x,y;

    w = WindingFromDrawSurf( ds );
    numOutside = 0;

    for ( i = 0 ; i < b->numsides ; i++ ) {
        s = &b->sides[ i ];
        if ( s->backSide ) {
            continue;
        }
        plane = &mapplanes[ s->planenum ];

        // handle coplanar outfacing (don't fog)
        if ( ds->side->planenum == s->planenum ) {
            return qfalse;
        }

        // handle coplanar infacing (keep inside)
        if ( ( ds->side->planenum ^ 1 ) == s->planenum ) {
            continue;
        }

        // general case
        ClipWindingEpsilon( w, plane->normal, plane->dist, ON_EPSILON,
            &front, &back );
        FreeWinding( w );
        if ( !back ) {
            // nothing actually contained inside
            for ( j = 0 ; j < numOutside ; j++ ) {
                FreeWinding( outside[j] );
            }
            return qfalse;
        }
        if ( front ) {
            if ( numOutside == MAX_BRUSH_SIDES ) {
                Error( "MAX_BRUSH_SIDES" );
            }
            outside[ numOutside ] = front;
            numOutside++;
        }
        w = back;
    }

    // all of outside fragments become seperate drawsurfs
    // linked to the same side
    c_fogFragment += numOutside;
    s = ds->side;

    for ( i = 0 ; i < numOutside ; i++ ) {
        newds = DrawSurfaceForSide( ds->mapBrush, s, outside[i] );
        FreeWinding( outside[i] );
    }


    // replace ds->verts with the verts for w
    ds->numVerts = w->numpoints;
    free( ds->verts );

    ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) );
    memset( ds->verts, 0, ds->numVerts * sizeof( *ds->verts ) );

    si = s->shaderInfo;

    mins[0] = 9999;
    mins[1] = 9999;

    // compute s/t coordinates from brush primitive texture matrix
    // compute axis base
    ComputeAxisBase( mapplanes[s->planenum].normal, texX, texY );

    for ( j = 0 ; j < w->numpoints ; j++ ) {
        dv = ds->verts + j;
        VectorCopy( w->p[j], dv->xyz );
    
        if (g_bBrushPrimit==BPRIMIT_OLDBRUSHES)
        {
            // calculate texture s/t
            dv->st[0] = s->vecs[0][3] + DotProduct( s->vecs[0], dv->xyz );
            dv->st[1] = s->vecs[1][3] + DotProduct( s->vecs[1], dv->xyz );  
            dv->st[0] /= si->width;
            dv->st[1] /= si->height;
        }
        else
        {
            // calculate texture s/t from brush primitive texture matrix
            x = DotProduct( dv->xyz, texX );
            y = DotProduct( dv->xyz, texY );
            dv->st[0]=s->texMat[0][0]*x+s->texMat[0][1]*y+s->texMat[0][2];
            dv->st[1]=s->texMat[1][0]*x+s->texMat[1][1]*y+s->texMat[1][2];
        }

        if ( dv->st[0] < mins[0] ) {
            mins[0] = dv->st[0];
        }
        if ( dv->st[1] < mins[1] ) {
            mins[1] = dv->st[1];
        }

        // copy normal
        VectorCopy ( mapplanes[s->planenum].normal, dv->normal );
    }

    // adjust the texture coordinates to be as close to 0 as possible
    if ( !si->globalTexture ) {
        mins[0] = floor( mins[0] );
        mins[1] = floor( mins[1] );
        for ( i = 0 ; i < w->numpoints ; i++ ) {
            dv = ds->verts + i;
            dv->st[0] -= mins[0];
            dv->st[1] -= mins[1];
        }
    }

    return qtrue;
}

//===============================================================================


/*
=====================
FogDrawSurfs

Call after the surface list has been pruned, 
before tjunction fixing
before lightmap allocation
=====================
*/
void FogDrawSurfs( void ) {
    int                 i, j, k;
    mapDrawSurface_t    *ds;
    bspbrush_t          *b;
    vec3_t              mins, maxs;
    int                 c_fogged;
    int                 numBaseDrawSurfs;
    dfog_t              *fog;

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

    c_fogged = 0;
    c_fogFragment = 0;

    // find all fog brushes
    for ( b = entities[0].brushes ; b ; b = b->next ) {
        if ( !(b->contents & CONTENTS_FOG) ) {
            continue;
        }

        if ( numFogs == MAX_MAP_FOGS ) {
            Error( "MAX_MAP_FOGS" );
        }
        fog = &dfogs[numFogs];
        numFogs++;
        fog->brushNum = b->outputNumber;

        // find a side with a valid shaderInfo
        // non-axial fog columns may have bevel planes that need to be skipped
        for ( i = 0 ; i < b->numsides ; i++ ) {
            if ( b->sides[i].shaderInfo && (b->sides[i].shaderInfo->contents & CONTENTS_FOG) ) {
                strcpy( fog->shader, b->sides[i].shaderInfo->shader );
                break;
            }
        }
        if ( i == b->numsides ) {
            continue;       // shouldn't happen
        }

        fog->visibleSide = -1;

        // clip each surface into this, but don't clip any of
        // the resulting fragments to the same brush
        numBaseDrawSurfs = numMapDrawSurfs;
        for ( i = 0 ; i < numBaseDrawSurfs ; i++ ) {
            ds = &mapDrawSurfs[i];

            // bound the drawsurf
            ClearBounds( mins, maxs );
            for ( j = 0 ; j < ds->numVerts ; j++ ) {
                AddPointToBounds( ds->verts[j].xyz, mins, maxs );
            }

            // check against the fog brush
            for ( k = 0 ; k < 3 ; k++ ) {
                if ( mins[k] > b->maxs[k] ) {
                    break;
                }
                if ( maxs[k] < b->mins[k] ) {
                    break;
                }
            }
            if ( k < 3 ) {
                continue;       // bboxes don't intersect
            }

            if ( ds->mapBrush == b ) {
                int     s;

                s = ds->side - b->sides;
                if ( s <= 6 ) { // not one of the reversed inside faces
                    // this is a visible fog plane
                    if ( fog->visibleSide != -1 ) {
                        _printf( "WARNING: fog brush %i has multiple visible sides\n", b->brushnum );
                    }
                    fog->visibleSide = s;
                }
            }

            if ( ds->miscModel ) {
                // we could write splitting code for trimodels if we wanted to...
                c_fogged++;
                ds->fogNum = numFogs - 1;
            } else if ( ds->patch ) {
                if ( ChopPatchByBrush( ds, b ) ) {
                    c_fogged++;
                    ds->fogNum = numFogs - 1;
                }
            } else {
                if ( ChopFaceByBrush( ds, b ) ) {
                    c_fogged++;
                    ds->fogNum = numFogs - 1;
                }
            }
        }
    }

    // split the drawsurfs by the fog brushes

    qprintf( "%5i fogs\n", numFogs );
    qprintf( "%5i fog polygon fragments\n", c_fogFragment );
    qprintf( "%5i fog patch fragments\n", c_fogPatchFragments );
    qprintf( "%5i fogged drawsurfs\n", c_fogged );
}

---