Tutorial *90*

Well, after giving coloured light to the Quake worlds I have created, I received an email from Alien_Hunter. He pointed out to me, that even though the worlds have coloured lighting, it does not effect the models that are in the world. I hate to do a job and not complete it, so here is the solution to this problem.
Please Note :
  • You must have completed the Coloured Dynamic Lights and the Coloured Static Lights tutorials before doing this one.
  • Some code in RecursiveLightPoint is from Alien_Hunter (thanks).
  • You must run the program with the -lm_4 switch to get all of these coloured lighting tutorials to work. [ed: Unless you hardcode the gl_lightmap_format in GL_BuildLightMaps (gl_rsurf.c)]
  • People that have followed the interpolation tutorials, will already have modified some of the functions that we must change in this tutorial. If that is your case, I have clearly commented where my code changes begin and end, so you should be able to just copy and paste my changes to your code without too many hassles. Remember to change the interpolated drawing function as well as the normal one. [ed: It's easier to just replace the functions within, and re-add the few lines of coded needed for interpolation. At least for model & animation interpolation. In Gl_DrawAliasBlendedFrame, remember to use d[0] not shadedots :]

    The light for alias models, is calculated in R_LightPoint, which calls RecursiveLightPoint to do the work, so that is as good a place to start as any. The idea behind this tutorial, is to change the calculating of light, so as to return the RGBA components, so that we can apply them to our models.

    The easiest way to do this without disturbing too much of id's code, is to change the R_LightPoint, and RecursiveLightPoint functions to return int*'s instead of int's, that way we can return the full RGBA array. So let's get started...

    In gl_rlight.c replace RecursiveLightPoint with the following version
    
    
    // CSL - [email protected]
    
    // No idea what "r" stands for so...
    
    static int      myr[4];
    
    int *RecursiveLightPoint (mnode_t *node, vec3_t start, vec3_t end)
    
    // CSL
    
    {
    
        // CSL - [email protected]
    
        // "r[3]" is the old "r"
    
        int         *r = myr;
    
        // CSL
    
        float       front, back, frac;
    
        int         side;
    
        mplane_t    *plane;
    
        vec3_t      mid;
    
        msurface_t  *surf;
    
        int         s, t, ds, dt;
    
        int         i;
    
        mtexinfo_t  *tex;
    
        byte        *lightmap;
    
        unsigned    scale;
    
        int         maps;
    
    
    
        // CSL - [email protected]
    
        r[0] = 0; r[1] = 0; r[2] = 0; r[3] = 0;
    
        // CSL
    
    
    
        if (node->contents < 0)
    
        {
    
            // CSL - [email protected]
    
            // didn't hit anything
    
            r[3] = -1;
    
            return r;
    
            // CSL
    
        }
    
    
    
    // calculate mid point
    
    
    
    // FIXME: optimize for axial
    
        plane = node->plane;
    
        front = DotProduct (start, plane->normal) - plane->dist;
    
        back = DotProduct (end, plane->normal) - plane->dist;
    
        side = front < 0;
    
    
    
        if ( (back < 0) == side)
    
            return RecursiveLightPoint (node->children[side], start, end);
    
    
    
        frac = front / (front-back);
    
        mid[0] = start[0] + (end[0] - start[0])*frac;
    
        mid[1] = start[1] + (end[1] - start[1])*frac;
    
        mid[2] = start[2] + (end[2] - start[2])*frac;
    
    
    
    // go down front side
    
        r = RecursiveLightPoint (node->children[side], start, mid);
    
        // CSL - [email protected]
    
        if (r[3] >= 0)
    
        // CSL
    
            return r;       // hit something
    
    
    
        if ( (back < 0) == side )
    
        {
    
            // CSL - [email protected]
    
            // didn't hit anything
    
            r[3] = -1;
    
            return r;
    
            // CSL
    
        }
    
    
    
    // check for impact on this node
    
        VectorCopy (mid, lightspot);
    
        lightplane = plane;
    
    
    
        surf = cl.worldmodel->surfaces + node->firstsurface;
    
        for (i=0 ; i<node->numsurfaces ; i++, surf++)
    
        {
    
            if (surf->flags & SURF_DRAWTILED)
    
                continue;   // no lightmaps
    
    
    
            tex = surf->texinfo;
    
    
    
            s = DotProduct (mid, tex->vecs[0]) + tex->vecs[0][3];
    
            t = DotProduct (mid, tex->vecs[1]) + tex->vecs[1][3];;
    
    
    
            if (s < surf->texturemins[0] ||
    
            t < surf->texturemins[1])
    
                continue;
    
    
    
            ds = s - surf->texturemins[0];
    
            dt = t - surf->texturemins[1];
    
    
    
            if ( ds > surf->extents[0] || dt > surf->extents[1] )
    
                continue;
    
    
    
            if (!surf->samples)
    
            {
    
                // CSL - [email protected]
    
                return r;
    
                // CSL
    
            }
    
    
    
            ds >>= 4;
    
            dt >>= 4;
    
    
    
            lightmap = surf->samples;
    
            if (lightmap)
    
            {
    
                // CSL - [email protected]
    
                if (bspextensions)
    
                    lightmap += (dt * ((surf->extents[0]>>4)+1) + ds) * 4;
    
                else
    
                    lightmap += dt * ((surf->extents[0]>>4)+1) + ds;
    
                // CSL
    
    
    
                for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ; maps++)
    
                {
    
                    scale = d_lightstylevalue[surf->styles[maps]];
    
                    // CSL - [email protected]
    
                    if (bspextensions)
    
                    {
    
                        // Calculate effect of coloured lights on alias model
    
                        r[0] += lightmap[0] * scale;
    
                        r[1] += lightmap[1] * scale;
    
                        r[2] += lightmap[2] * scale;
    
                        r[3] += lightmap[3] * scale;
    
                        lightmap += (((surf->extents[0]>>4)+1) * ((surf->extents[1]>>4)+1)) * 4;
    
                    }
    
                    else
    
                    {
    
                        // No coloured lights to play with :(
    
                        r[3] += *lightmap * scale;
    
                        lightmap += ((surf->extents[0]>>4)+1) * ((surf->extents[1]>>4)+1);
    
                    }
    
                    // CSL
    
                }
    
    
    
                // CSL - [email protected]
    
                if (!bspextensions)
    
                {
    
                    r[0] = 0; r[1] = 0; r[2] = 0;
    
                }
    
                else
    
                {
    
                    // Faster to assign each, than with a loop
    
                    r[0] >>= 8;
    
                    r[1] >>= 8;
    
                    r[2] >>= 8;
    
                }
    
                r[3] >>= 8;
    
                // CSL
    
            }
    
            return r;
    
        }
    
    
    
        // go down back side
    
        return RecursiveLightPoint (node->children[!side], mid, end);
    
    }
    
    
    That function, will now return the RGBA compenents of the colours that are effecting this point in space. It does not take into account dynamic lights, just those colours from the lightmaps (dynamic lights are taken care of whilst preparing to draw the model). Now that RecursiveLightPoint returns the correct values, R_LightPoint must be changed, to return the RGBA components as well.

    In gl_rlight.c replace R_LightPoint with the following version
    
    
    // CSL - [email protected]
    
    int *R_LightPoint (vec3_t p)
    
    // CSL
    
    {
    
        vec3_t      end;
    
        // CSL - [email protected]
    
        // "r[3]" is old "r"
    
        int         *r = myr;
    
        // CSL
    
    
    
        if (!cl.worldmodel->lightdata)
    
        {
    
            // CSL - [email protected]
    
            r[0] = 255; r[1] = 255; r[2] = 255; r[3] = 255;
    
            return r;
    
            // return 255;
    
            // CSL
    
        }
    
    
    
        end[0] = p[0];
    
        end[1] = p[1];
    
        end[2] = p[2] - 2048;
    
    
    
        r = RecursiveLightPoint (cl.worldmodel->nodes, p, end);
    
    
    
        // CSL - [email protected]
    
        if (r[3] == -1)
    
            r[3] = 0;
    
        // CSL
    
    
    
        return r;
    
    }
    
    
    Now that R_LightPoint returns the correct RGBA components of the lightmap colours effecting the point in space, we must change the way that they are interpreted when they are returned.

    To start with, the old variable that handled the shading of models, was shadelight. shadelight stored the intensity of light at a point in space, and we want to store the intensity as well as the colour. So we must search through the file gl_rmain.c, and replace all references to shadelight with the appropriate new variable. To start with, let's declare the new variable.

    In gl_rmain.c Replace :
    
    
    float   shadelight, ambientlight;
    
    
    With :
    
    
    // CSL - [email protected]
    
    float   shadelight[4];
    
    // CSL
    
    float   ambientlight;
    
    
    Now, R_LightPoint is called from 2 functions, R_DrawAliasModel, and R_DrawViewModel. We must go into each of these functions and correct them for our new versions of these functions, and also for our new definition of shadelight.

    In gl_rmain.c replace R_DrawAliasModel with the following version
    
    
    void R_DrawAliasModel (entity_t *e)
    
    {
    
        int         i;
    
        // CSL - [email protected]
    
        int         *j;
    
        // CSL
    
        int         lnum;
    
        vec3_t      dist;
    
        float       add;
    
        model_t     *clmodel;
    
        vec3_t      mins, maxs;
    
        aliashdr_t  *paliashdr;
    
        trivertx_t  *verts, *v;
    
        int         index;
    
        float       s, t, an;
    
        int         anim;
    
    
    
        clmodel = currententity->model;
    
    
    
        VectorAdd (currententity->origin, clmodel->mins, mins);
    
        VectorAdd (currententity->origin, clmodel->maxs, maxs);
    
    
    
        if (R_CullBox (mins, maxs))
    
            return;
    
    
    
    
    
        VectorCopy (currententity->origin, r_entorigin);
    
        VectorSubtract (r_origin, r_entorigin, modelorg);
    
    
    
        //
    
        // get lighting information
    
        //
    
    
    
        // CSL - [email protected]
    
        j = R_LightPoint (currententity->origin);
    
        // Can't assign int* to float[4]...damn
    
        shadelight[0] = (float) j[0]; shadelight[1] = (float) j[1];
    
        shadelight[2] = (float) j[2]; shadelight[3] = (float) j[3];
    
        ambientlight = shadelight[3];
    
        // CSL
    
    
    
        // allways give the gun some light
    
        if (e == &cl.viewent && ambientlight < 24)
    
        {
    
            // CSL - [email protected]
    
            ambientlight = shadelight[3] = 24;
    
            // CSL
    
        }
    
    
    
        for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
    
        {
    
            if (cl_dlights[lnum].die >= cl.time)
    
            {
    
                VectorSubtract (currententity->origin,
    
                                cl_dlights[lnum].origin,
    
                                dist);
    
                add = cl_dlights[lnum].radius - Length(dist);
    
    
    
                if (add > 0) {
    
                    ambientlight += add;
    
                    //ZOID models should be affected by dlights as well
    
                    // CSL - [email protected]
    
                    shadelight[0] += cl_dlights[lnum].colour[0];
    
                    shadelight[1] += cl_dlights[lnum].colour[1];
    
                    shadelight[2] += cl_dlights[lnum].colour[2];
    
                    shadelight[3] += add;
    
                    // CSL
    
                }
    
            }
    
        }
    
    
    
        // clamp lighting so it doesn't overbright as much
    
        if (ambientlight > 128)
    
            ambientlight = 128;
    
        // CSL - [email protected]
    
        if (ambientlight + shadelight[3] > 192)
    
            shadelight[3] = 192 - ambientlight;
    
        // CSL
    
    
    
        // ZOID: never allow players to go totally black
    
        i = currententity - cl_entities;
    
        if (i >= 1 && i<=cl.maxclients /* && !strcmp (currententity->model->name, "progs/player.mdl") */)
    
            if (ambientlight < 8)
    
                // CSL - [email protected]
    
                ambientlight = shadelight[3] = 8;
    
                // CSL
    
    
    
        // HACK HACK HACK -- no fullbright colors, so make torches full light
    
        if (!strcmp (clmodel->name, "progs/flame2.mdl")
    
            || !strcmp (clmodel->name, "progs/flame.mdl") )
    
            // CSL - [email protected]
    
            ambientlight = shadelight[3] = 256;
    
            // CSL
    
    
    
        shadedots = r_avertexnormal_dots[((int)(e->angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1)];
    
        // CSL - [email protected]
    
        shadelight[3] = shadelight[3] / 200.0;
    
        // CSL - [email protected]
    
    
    
        an = e->angles[1]/180*M_PI;
    
        shadevector[0] = cos(-an);
    
        shadevector[1] = sin(-an);
    
        shadevector[2] = 1;
    
        VectorNormalize (shadevector);
    
    
    
        //
    
        // locate the proper data
    
        //
    
        paliashdr = (aliashdr_t *)Mod_Extradata (currententity->model);
    
    
    
        c_alias_polys += paliashdr->numtris;
    
    
    
        //
    
        // draw all the triangles
    
        //
    
    
    
        GL_DisableMultitexture();
    
    
    
        glPushMatrix ();
    
    
    
        R_RotateForEntity (e);
    
    
    
        if (!strcmp (clmodel->name, "progs/eyes.mdl") && gl_doubleeyes.value) {
    
            glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2] - (22 + 8));
    
    // double size of eyes, since they are really hard to see in gl
    
            glScalef (paliashdr->scale[0]*2, paliashdr->scale[1]*2, paliashdr->scale[2]*2);
    
        } else {
    
            glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2]);
    
            glScalef (paliashdr->scale[0], paliashdr->scale[1], paliashdr->scale[2]);
    
        }
    
    
    
        anim = (int)(cl.time*10) & 3;
    
        GL_Bind(paliashdr->gl_texturenum[currententity->skinnum][anim]);
    
    
    
        // we can't dynamically colormap textures, so they are cached
    
        // seperately for the players.  Heads are just uncolored.
    
        if (currententity->colormap != vid.colormap && !gl_nocolors.value)
    
        {
    
            i = currententity - cl_entities;
    
            if (i >= 1 && i<=cl.maxclients /* && !strcmp (currententity->model->name, "progs/player.mdl") */)
    
                GL_Bind(playertextures - 1 + i);
    
        }
    
    
    
        if (gl_smoothmodels.value)
    
            glShadeModel (GL_SMOOTH);
    
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    
    
    
        if (gl_affinemodels.value)
    
            glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
    
    
    
        R_SetupAliasFrame (currententity->frame, paliashdr);
    
    
    
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    
    
    
        glShadeModel (GL_FLAT);
    
        if (gl_affinemodels.value)
    
            glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    
    
    
        glPopMatrix ();
    
    
    
        if (r_shadows.value)
    
        {
    
            glPushMatrix ();
    
    
    
            R_RotateForEntity (e);
    
    
    
            glDisable (GL_TEXTURE_2D);
    
            glEnable (GL_BLEND);
    
            glColor4f (0,0,0,0.5);
    
    
    
            GL_DrawAliasShadow (paliashdr, lastposenum);
    
    
    
            glEnable (GL_TEXTURE_2D);
    
            glDisable (GL_BLEND);
    
            glColor4f (1,1,1,1);
    
            glPopMatrix ();
    
        }
    
    }
    
    
    Then in gl_rmain.c replace R_DrawViewModel with the following version
    
    
    void R_DrawViewModel (void)
    
    {
    
        float       ambient[4], diffuse[4];
    
        // CSL - [email protected]
    
        int         *j;
    
        int         shadelight[4];
    
        // CSL
    
        int         lnum;
    
        vec3_t      dist;
    
        float       add;
    
        dlight_t    *dl;
    
        int         ambientlight;
    
        float old_interpolate_model_transform;
    
    
    
        if (!r_drawviewmodel.value)
    
            return;
    
    
    
        if (chase_active.value)
    
            return;
    
    
    
        if (envmap)
    
            return;
    
    
    
        if (!r_drawentities.value)
    
            return;
    
    
    
        if (cl.items & IT_INVISIBILITY)
    
            return;
    
    
    
        if (cl.stats[STAT_HEALTH] <= 0)
    
            return;
    
    
    
        currententity = &cl.viewent;
    
        if (!currententity->model)
    
            return;
    
    
    
        j = R_LightPoint (currententity->origin);
    
    
    
        // CSL - [email protected]
    
        if (j[3] < 24)
    
            j[3] = 24;      // allways give some light on gun
    
        ambientlight = j[3];
    
        // Can't assign int* to int[4]...damn
    
        shadelight[0] = j[0]; shadelight[1] = j[1];
    
        shadelight[2] = j[2]; shadelight[3] = j[3];
    
        // CSL
    
    
    
    // add dynamic lights
    
        for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
    
        {
    
            dl = &cl_dlights[lnum];
    
            if (!dl->radius)
    
                continue;
    
            if (!dl->radius)
    
                continue;
    
            if (dl->die < cl.time)
    
                continue;
    
    
    
            VectorSubtract (currententity->origin, dl->origin, dist);
    
            add = dl->radius - Length(dist);
    
            if (add > 0)
    
            {
    
                // CSL - [email protected]
    
                shadelight[0] += dl->colour[0];
    
                shadelight[1] += dl->colour[1];
    
                shadelight[2] += dl->colour[2];
    
                shadelight[3] += add;
    
                // CSL
    
                ambientlight += add;
    
            }
    
        }
    
    
    
        ambient[0] = ambient[1] = ambient[2] = ambient[3] = (float)ambientlight / 128;
    
        // CSL - [email protected]
    
        diffuse[0] = diffuse[1] = diffuse[2] = diffuse[3] = (float)shadelight[3] / 128;
    
        // CSL
    
    
    
        // hack the depth range to prevent view model from poking into walls
    
        glDepthRange (gldepthmin, gldepthmin + 0.3*(gldepthmax-gldepthmin));
    
    
    
        R_DrawAliasModel (currententity);
    
    
    
        glDepthRange (gldepthmin, gldepthmax);
    
    }
    
    
    There is only one thing left to do, and that is to change how the models are drawn, so that our new shadelight varible, can effect the colour as well as the intensity. For those that have completed the interpolation tutorial, this is the code that will need to be placed in your new drawing function, if you want the interpolated models to be drawn with coloured lighting as well.
    In gl_rmain.c in GL_DrawAliasFrame Replace :
    
    
    		l = shadedots[verts->lightnormalindex] * shadelight;
    
    		glColor3f (l, l, l);
    
    
    With :
    
    
    		// CSL - [email protected]
    
                    l = shadedots[verts->lightnormalindex] * shadelight[3];
    
                    if (shadelight[0] || shadelight[1] || shadelight[2])
    
                        glColor3f (l*shadelight[0], l*shadelight[1], l*shadelight[2]);
    
                    else
    
                        glColor3f (l, l, l);
    
                    // CSL
    
    
    Well that is it. I am sure, now that everyone has seen how easy it has been to add cool new features to the Quake engine, that we will see no end of great new mods out there. If anyone does anything fantastic with this coloured lighting code, I would love to hear about it, so feel free to contact me.

    As far as I can tell, that has just been the last tutorial in the coloured lighting series. If I have missed anything that needs to be done to make this a complete effect, make sure you tell me, I hate leaving things unfinished. Any problems, comments or corrections, mail me at [email protected]
    editors note:
    some people were having problems with this tutorial and this fix was send in to fix it: In gl_rmain.c in GL_DrawAliasFrame Replace :
    
    
    		// CSL - [email protected]
    
                    l = shadedots[verts->lightnormalindex] * shadelight[3];
    
                    if (shadelight[0] || shadelight[1] || shadelight[2])
    
                        glColor3f (l*shadelight[0], l*shadelight[1], l*shadelight[2]);
    
                    else
    
                        glColor3f (l, l, l);
    
                    // CSL
    
    
    with:
    
    
    		// CSL - [email protected]
    
                    l = shadedots[verts->lightnormalindex] * shadelight[3];
    
                    if (shadelight[0] || shadelight[1] || shadelight[2])
    
                        glColor3f (l+(shadelight[0]/255), l+(shadelight[1]/255), l+(shadelight[2]/255));
    
                    else
    
                        glColor3f (l, l, l);
    
                    // CSL
    
    
    Thanks go out to Jacques Krige for fixing this.


 
Sign up
Login:
Passwd:
[Remember Me]