patches.cpp

Go to the documentation of this file.

/*
Copyright (C) 1997-2001 Id Software, Inc.

This program 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.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "lighting.h"
#include "bsp.h"
#include "../../shared/images.h"

static vec3_t texture_reflectivity[MAX_MAP_TEXINFO];
patch_t* face_patches[MAX_MAP_FACES];

/*
===================================================================
TEXTURE LIGHT VALUES
===================================================================
*/

void CalcTextureReflectivity (void)
{
    int j, texels = 0;
    char path[MAX_QPATH];
    int color[3];
    SDL_Surface* surf;

    /* always set index 0 even if no textures */
    VectorSet(texture_reflectivity[0], 0.5, 0.5, 0.5);

    VectorSet(color, 0, 0, 0);

    for (int i = 0; i < curTile->numtexinfo; i++) {
        /* see if an earlier texinfo already got the value */
        for (j = 0; j < i; j++) {
            if (Q_streq(curTile->texinfo[i].texture, curTile->texinfo[j].texture)) {
                VectorCopy(texture_reflectivity[j], texture_reflectivity[i]);
                break;
            }
        }
        if (j != i) /* earlier texinfo found, continue */
            continue;

        /* load the image file */
        Com_sprintf(path, sizeof(path), "textures/%s", curTile->texinfo[i].texture);
        if (!(surf = Img_LoadImage(path))) {
            Verb_Printf(VERB_NORMAL, "Couldn't load %s\n", path);
            VectorSet(texture_reflectivity[i], 0.5, 0.5, 0.5);
            continue;
        }

        /* calculate average color */
        texels = surf->w * surf->h;
        color[0] = color[1] = color[2] = 0;

        for(j = 0; j < texels; j++){
            const byte* pos = (byte*)surf->pixels + j * 4;
            color[0] += *pos++; /* r */
            color[1] += *pos++; /* g */
            color[2] += *pos++; /* b */
        }

        Verb_Printf(VERB_EXTRA, "Loaded %s (%dx%d)\n", curTile->texinfo[i].texture, surf->w, surf->h);

        SDL_FreeSurface(surf);

        for(j = 0; j < 3; j++){
            const float r = color[j] / texels / 255.0;
            texture_reflectivity[i][j] = r;
        }
    }
}


static winding_t* WindingFromFace (const dBspSurface_t* f)
{
    winding_t* w = AllocWinding(f->numedges);
    w->numpoints = f->numedges;

    for (int i = 0; i < f->numedges; i++) {
        const int se = curTile->surfedges[f->firstedge + i];
        int v;
        if (se < 0)
            v = curTile->edges[-se].v[1];
        else
            v = curTile->edges[se].v[0];

        dBspVertex_t* dv = &curTile->vertexes[v];
        VectorCopy(dv->point, w->p[i]);
    }

    RemoveColinearPoints(w);

    return w;
}

static inline bool HasLight (const dBspSurface_t* f)
{
    const dBspTexinfo_t* tex;

    tex = &curTile->texinfo[f->texinfo];
    return (tex->surfaceFlags & SURF_LIGHT) && tex->value;
}

static inline void EmissiveLight (patch_t* patch)
{
    const dBspTexinfo_t* tex = &curTile->texinfo[patch->face->texinfo];
    const vec_t* ref = texture_reflectivity[patch->face->texinfo];

    VectorScale(ref, tex->value, patch->light);
}

static void BuildPatch (int fn, winding_t* w)
{
    patch_t* patch;
    dBspPlane_t* plane;

    patch = Mem_AllocType(patch_t);

    face_patches[fn] = patch;

    patch->face = &curTile->faces[fn];
    patch->winding = w;

    /* resolve the normal */
    plane = &curTile->planes[patch->face->planenum];

    if (patch->face->side)
        VectorNegate(plane->normal, patch->normal);
    else
        VectorCopy(plane->normal, patch->normal);

    WindingCenter(w, patch->origin);

    /* nudge the origin out along the normal */
    VectorMA(patch->origin, 2.0, patch->normal, patch->origin);

    patch->area = WindingArea(w);

    if (patch->area < 1.0)  /* clamp area */
        patch->area = 1.0;

    EmissiveLight(patch);  /* surface light */
}

static entity_t* EntityForModel (int modnum)
{
    char name[16];

    Com_sprintf(name, sizeof(name), "*%i", modnum);
    /* search the entities for one using modnum */
    for (int i = 0; i < num_entities; i++) {
        const char* s = ValueForKey(&entities[i], "model");
        if (Q_streq(s, name))
            return &entities[i];
    }

    /* return the world */
    return &entities[0];
}

void BuildPatches (void)
{
    OBJZERO(face_patches);

    for (int i = 0; i < curTile->nummodels; i++) {
        const dBspModel_t* mod = &curTile->models[i];
        const entity_t* ent = EntityForModel(i);
        vec3_t origin;
        /* bmodels with origin brushes (like func_door) need to be offset into their
         * in-use position */
        GetVectorForKey(ent, "origin", origin);

        for (int j = 0; j < mod->numfaces; j++) {
            const int facenum = mod->firstface + j;
            dBspSurface_t* f = &curTile->faces[facenum];

            /* store the origin in case of moving bmodels (e.g. func_door) */
            VectorCopy(origin, face_offset[facenum]);

            if (!HasLight(f))  /* no light */
                continue;

            winding_t* w = WindingFromFace(f);

            for (int k = 0; k < w->numpoints; k++)
                VectorAdd(w->p[k], origin, w->p[k]);

            BuildPatch(facenum, w);
        }
    }
}

/*
=======================================================================
SUBDIVIDE
=======================================================================
*/

#define PATCH_SUBDIVIDE 64

static void FinishSubdividePatch (patch_t* patch, patch_t* newp)
{
    VectorCopy(patch->normal, newp->normal);

    VectorCopy(patch->light, newp->light);

    patch->area = WindingArea(patch->winding);

    if (patch->area < 1.0)
        patch->area = 1.0;

    newp->area = WindingArea(newp->winding);

    if (newp->area < 1.0)
        newp->area = 1.0;

    WindingCenter(patch->winding, patch->origin);
    /* nudge the patch origin out along the normal */
    VectorMA(patch->origin, 2.0, patch->normal, patch->origin);

    WindingCenter(newp->winding, newp->origin);
    /* nudge the patch origin out along the normal */
    VectorMA(newp->origin, 2.0, newp->normal, newp->origin);
}

static void SubdividePatch(patch_t* patch)
{
    winding_t* w, *o1, *o2;
    vec3_t mins, maxs;
    vec3_t split;
    vec_t dist;
    int i;
    patch_t* newp;

    w = patch->winding;
    WindingBounds(w, mins, maxs);

    VectorClear(split);

    for (i = 0; i < 3; i++) {
        if (floor((mins[i] + 1) / PATCH_SUBDIVIDE) < floor((maxs[i] - 1) / PATCH_SUBDIVIDE)) {
            split[i] = 1.0;
            break;
        }
    }
    /* no splitting needed */
    if (i == 3)
        return;

    /* split the winding */
    dist = PATCH_SUBDIVIDE * (1 + floor((mins[i] + 1) / PATCH_SUBDIVIDE));
    ClipWindingEpsilon(w, split, dist, ON_EPSILON, &o1, &o2);

    /* create a new patch */
    newp = Mem_AllocType(patch_t);

    newp->next = patch->next;
    patch->next = newp;

    patch->winding = o1;
    newp->winding = o2;

    FinishSubdividePatch(patch, newp);

    SubdividePatch(patch);
    SubdividePatch(newp);
}

void SubdividePatches (void)
{
    for (int i = 0; i < MAX_MAP_FACES; i++) {
        patch_t* p = face_patches[i];

        if (p)  /* break it up */
            SubdividePatch(p);
    }
}

void FreePatches (void)
{
    for (int i = 0; i < MAX_MAP_FACES; i++) {
        patch_t* p = face_patches[i];
        while (p) {
            patch_t* pnext = p->next;
            Mem_Free(p);
            p = pnext;
        }
    }
}