Image_program.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.

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

/*

all uncompressed
uncompressed normal maps

downsample images

16 meg Dynamic cache

Anisotropic texturing

Trilinear on all
Trilinear on normal maps, bilinear on others
Bilinear on all


Manager

->List
->Print
->Reload( bool force )

*/

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

// tr_imageprogram.c

#include "tr_local.h"

/*

Anywhere that an image name is used (diffusemaps, bumpmaps, specularmaps, lights, etc),
an imageProgram can be specified.

This allows load time operations, like heightmap-to-normalmap conversion and image
composition, to be automatically handled in a way that supports timestamped reloads.

*/

/*
=================
R_HeightmapToNormalMap

it is not possible to convert a heightmap into a normal map
properly without knowing the texture coordinate stretching.
We can assume constant and equal ST vectors for walls, but not for characters.
=================
*/
static void R_HeightmapToNormalMap( byte *data, int width, int height, float scale ) {
        int             i, j;
        byte    *depth;

        scale = scale / 256;

        // copy and convert to grey scale
        j = width * height;
        depth = (byte *)R_StaticAlloc( j );
        for ( i = 0 ; i < j ; i++ ) {
                depth[i] = ( data[i*4] + data[i*4+1] + data[i*4+2] ) / 3;
        }

        idVec3  dir, dir2;
        for ( i = 0 ; i < height ; i++ ) {
                for ( j = 0 ; j < width ; j++ ) {
                        int             d1, d2, d3, d4;
                        int             a1, a2, a3, a4;

                        // FIXME: look at five points?

                        // look at three points to estimate the gradient
                        a1 = d1 = depth[ ( i * width + j ) ];
                        a2 = d2 = depth[ ( i * width + ( ( j + 1 ) & ( width - 1 ) ) ) ];
                        a3 = d3 = depth[ ( ( ( i + 1 ) & ( height - 1 ) ) * width + j ) ];
                        a4 = d4 = depth[ ( ( ( i + 1 ) & ( height - 1 ) ) * width + ( ( j + 1 ) & ( width - 1 ) ) ) ];

                        d2 -= d1;
                        d3 -= d1;

                        dir[0] = -d2 * scale;
                        dir[1] = -d3 * scale;
                        dir[2] = 1;
                        dir.NormalizeFast();

                        a1 -= a3;
                        a4 -= a3;

                        dir2[0] = -a4 * scale;
                        dir2[1] = a1 * scale;
                        dir2[2] = 1;
                        dir2.NormalizeFast();
        
                        dir += dir2;
                        dir.NormalizeFast();

                        a1 = ( i * width + j ) * 4;
                        data[ a1 + 0 ] = (byte)(dir[0] * 127 + 128);
                        data[ a1 + 1 ] = (byte)(dir[1] * 127 + 128);
                        data[ a1 + 2 ] = (byte)(dir[2] * 127 + 128);
                        data[ a1 + 3 ] = 255;
                }
        }


        R_StaticFree( depth );
}


/*
=================
R_ImageScale
=================
*/
static void R_ImageScale( byte *data, int width, int height, float scale[4] ) {
        int             i, j;
        int             c;

        c = width * height * 4;

        for ( i = 0 ; i < c ; i++ ) {
                j = (byte)(data[i] * scale[i&3]);
                if ( j < 0 ) {
                        j = 0;
                } else if ( j > 255 ) {
                        j = 255;
                }
                data[i] = j;
        }
}

/*
=================
R_InvertAlpha
=================
*/
static void R_InvertAlpha( byte *data, int width, int height ) {
        int             i;
        int             c;

        c = width * height* 4;

        for ( i = 0 ; i < c ; i+=4 ) {
                data[i+3] = 255 - data[i+3];
        }
}

/*
=================
R_InvertColor
=================
*/
static void R_InvertColor( byte *data, int width, int height ) {
        int             i;
        int             c;

        c = width * height* 4;

        for ( i = 0 ; i < c ; i+=4 ) {
                data[i+0] = 255 - data[i+0];
                data[i+1] = 255 - data[i+1];
                data[i+2] = 255 - data[i+2];
        }
}


/*
===================
R_AddNormalMaps

===================
*/
static void R_AddNormalMaps( byte *data1, int width1, int height1, byte *data2, int width2, int height2 ) {
        int             i, j;
        byte    *newMap;

        // resample pic2 to the same size as pic1
        if ( width2 != width1 || height2 != height1 ) {
                newMap = R_Dropsample( data2, width2, height2, width1, height1 );
                data2 = newMap;
        } else {
                newMap = NULL;
        }

        // add the normal change from the second and renormalize
        for ( i = 0 ; i < height1 ; i++ ) {
                for ( j = 0 ; j < width1 ; j++ ) {
                        byte    *d1, *d2;
                        idVec3  n;
                        float   len;

                        d1 = data1 + ( i * width1 + j ) * 4;
                        d2 = data2 + ( i * width1 + j ) * 4;

                        n[0] = ( d1[0] - 128 ) / 127.0;
                        n[1] = ( d1[1] - 128 ) / 127.0;
                        n[2] = ( d1[2] - 128 ) / 127.0;

                        // There are some normal maps that blend to 0,0,0 at the edges
                        // this screws up compression, so we try to correct that here by instead fading it to 0,0,1
                        len = n.LengthFast();
                        if ( len < 1.0f ) {
                                n[2] = idMath::Sqrt(1.0 - (n[0]*n[0]) - (n[1]*n[1]));
                        }

                        n[0] += ( d2[0] - 128 ) / 127.0;
                        n[1] += ( d2[1] - 128 ) / 127.0;
                        n.Normalize();

                        d1[0] = (byte)(n[0] * 127 + 128);
                        d1[1] = (byte)(n[1] * 127 + 128);
                        d1[2] = (byte)(n[2] * 127 + 128);
                        d1[3] = 255;
                }
        }

        if ( newMap ) {
                R_StaticFree( newMap );
        }
}

/*
================
R_SmoothNormalMap
================
*/
static void R_SmoothNormalMap( byte *data, int width, int height ) {
        byte    *orig;
        int             i, j, k, l;
        idVec3  normal;
        byte    *out;
        static float    factors[3][3] = {
                { 1, 1, 1 },
                { 1, 1, 1 },
                { 1, 1, 1 }
        };

        orig = (byte *)R_StaticAlloc( width * height * 4 );
        memcpy( orig, data, width * height * 4 );

        for ( i = 0 ; i < width ; i++ ) {
                for ( j = 0 ; j < height ; j++ ) {
                        normal = vec3_origin;
                        for ( k = -1 ; k < 2 ; k++ ) {
                                for ( l = -1 ; l < 2 ; l++ ) {
                                        byte    *in;

                                        in = orig + ( ((j+l)&(height-1))*width + ((i+k)&(width-1)) ) * 4;

                                        // ignore 000 and -1 -1 -1
                                        if ( in[0] == 0 && in[1] == 0 && in[2] == 0 ) {
                                                continue;
                                        }
                                        if ( in[0] == 128 && in[1] == 128 && in[2] == 128 ) {
                                                continue;
                                        }

                                        normal[0] += factors[k+1][l+1] * ( in[0] - 128 );
                                        normal[1] += factors[k+1][l+1] * ( in[1] - 128 );
                                        normal[2] += factors[k+1][l+1] * ( in[2] - 128 );
                                }
                        }
                        normal.Normalize();
                        out = data + ( j * width + i ) * 4;
                        out[0] = (byte)(128 + 127 * normal[0]);
                        out[1] = (byte)(128 + 127 * normal[1]);
                        out[2] = (byte)(128 + 127 * normal[2]);
                }
        }

        R_StaticFree( orig );
}


/*
===================
R_ImageAdd

===================
*/
static void R_ImageAdd( byte *data1, int width1, int height1, byte *data2, int width2, int height2 ) {
        int             i, j;
        int             c;
        byte    *newMap;

        // resample pic2 to the same size as pic1
        if ( width2 != width1 || height2 != height1 ) {
                newMap = R_Dropsample( data2, width2, height2, width1, height1 );
                data2 = newMap;
        } else {
                newMap = NULL;
        }


        c = width1 * height1 * 4;

        for ( i = 0 ; i < c ; i++ ) {
                j = data1[i] + data2[i];
                if ( j > 255 ) {
                        j = 255;
                }
                data1[i] = j;
        }

        if ( newMap ) {
                R_StaticFree( newMap );
        }
}


// we build a canonical token form of the image program here
static char parseBuffer[MAX_IMAGE_NAME];

/*
===================
AppendToken
===================
*/
static void AppendToken( idToken &token ) {
        // add a leading space if not at the beginning
        if ( parseBuffer[0] ) {
                idStr::Append( parseBuffer, MAX_IMAGE_NAME, " " );
        }
        idStr::Append( parseBuffer, MAX_IMAGE_NAME, token.c_str() );
}

/*
===================
MatchAndAppendToken
===================
*/
static void MatchAndAppendToken( idLexer &src, const char *match ) {
        if ( !src.ExpectTokenString( match ) ) {
                return;
        }
        // a matched token won't need a leading space
        idStr::Append( parseBuffer, MAX_IMAGE_NAME, match );
}

/*
===================
R_ParseImageProgram_r

If pic is NULL, the timestamps will be filled in, but no image will be generated
If both pic and timestamps are NULL, it will just advance past it, which can be
used to parse an image program from a text stream.
===================
*/
static bool R_ParseImageProgram_r( idLexer &src, byte **pic, int *width, int *height,
                                                                  ID_TIME_T *timestamps, textureDepth_t *depth ) {
        idToken         token;
        float           scale;
        ID_TIME_T               timestamp;

        src.ReadToken( &token );
        AppendToken( token );

        if ( !token.Icmp( "heightmap" ) ) {
                MatchAndAppendToken( src, "(" );

                if ( !R_ParseImageProgram_r( src, pic, width, height, timestamps, depth ) ) {
                        return false;
                }

                MatchAndAppendToken( src, "," );

                src.ReadToken( &token );
                AppendToken( token );
                scale = token.GetFloatValue();
                
                // process it
                if ( pic ) {
                        R_HeightmapToNormalMap( *pic, *width, *height, scale );
                        if ( depth ) {
                                *depth = TD_BUMP;
                        }
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        if ( !token.Icmp( "addnormals" ) ) {
                byte    *pic2;
                int             width2, height2;

                MatchAndAppendToken( src, "(" );

                if ( !R_ParseImageProgram_r( src, pic, width, height, timestamps, depth ) ) {
                        return false;
                }

                MatchAndAppendToken( src, "," );

                if ( !R_ParseImageProgram_r( src, pic ? &pic2 : NULL, &width2, &height2, timestamps, depth ) ) {
                        if ( pic ) {
                                R_StaticFree( *pic );
                                *pic = NULL;
                        }
                        return false;
                }
                
                // process it
                if ( pic ) {
                        R_AddNormalMaps( *pic, *width, *height, pic2, width2, height2 );
                        R_StaticFree( pic2 );
                        if ( depth ) {
                                *depth = TD_BUMP;
                        }
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        if ( !token.Icmp( "smoothnormals" ) ) {
                MatchAndAppendToken( src, "(" );

                if ( !R_ParseImageProgram_r( src, pic, width, height, timestamps, depth ) ) {
                        return false;
                }

                if ( pic ) {
                        R_SmoothNormalMap( *pic, *width, *height );
                        if ( depth ) {
                                *depth = TD_BUMP;
                        }
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        if ( !token.Icmp( "add" ) ) {
                byte    *pic2;
                int             width2, height2;

                MatchAndAppendToken( src, "(" );

                if ( !R_ParseImageProgram_r( src, pic, width, height, timestamps, depth ) ) {
                        return false;
                }

                MatchAndAppendToken( src, "," );

                if ( !R_ParseImageProgram_r( src, pic ? &pic2 : NULL, &width2, &height2, timestamps, depth ) ) {
                        if ( pic ) {
                                R_StaticFree( *pic );
                                *pic = NULL;
                        }
                        return false;
                }
                
                // process it
                if ( pic ) {
                        R_ImageAdd( *pic, *width, *height, pic2, width2, height2 );
                        R_StaticFree( pic2 );
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        if ( !token.Icmp( "scale" ) ) {
                float   scale[4];
                int             i;

                MatchAndAppendToken( src, "(" );

                R_ParseImageProgram_r( src, pic, width, height, timestamps, depth );

                for ( i = 0 ; i < 4 ; i++ ) {
                        MatchAndAppendToken( src, "," );
                        src.ReadToken( &token );
                        AppendToken( token );
                        scale[i] = token.GetFloatValue();
                }

                // process it
                if ( pic ) {
                        R_ImageScale( *pic, *width, *height, scale );
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        if ( !token.Icmp( "invertAlpha" ) ) {
                MatchAndAppendToken( src, "(" );

                R_ParseImageProgram_r( src, pic, width, height, timestamps, depth );

                // process it
                if ( pic ) {
                        R_InvertAlpha( *pic, *width, *height );
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        if ( !token.Icmp( "invertColor" ) ) {
                MatchAndAppendToken( src, "(" );

                R_ParseImageProgram_r( src, pic, width, height, timestamps, depth );

                // process it
                if ( pic ) {
                        R_InvertColor( *pic, *width, *height );
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        if ( !token.Icmp( "makeIntensity" ) ) {
                int             i;

                MatchAndAppendToken( src, "(" );

                R_ParseImageProgram_r( src, pic, width, height, timestamps, depth );

                // copy red to green, blue, and alpha
                if ( pic ) {
                        int             c;
                        c = *width * *height * 4;
                        for ( i = 0 ; i < c ; i+=4 ) {
                                (*pic)[i+1] = 
                                (*pic)[i+2] = 
                                (*pic)[i+3] = (*pic)[i];
                        }
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        if ( !token.Icmp( "makeAlpha" ) ) {
                int             i;

                MatchAndAppendToken( src, "(" );

                R_ParseImageProgram_r( src, pic, width, height, timestamps, depth );

                // average RGB into alpha, then set RGB to white
                if ( pic ) {
                        int             c;
                        c = *width * *height * 4;
                        for ( i = 0 ; i < c ; i+=4 ) {
                                (*pic)[i+3] = ( (*pic)[i+0] + (*pic)[i+1] + (*pic)[i+2] ) / 3;
                                (*pic)[i+0] = 
                                (*pic)[i+1] = 
                                (*pic)[i+2] = 255;
                        }
                }

                MatchAndAppendToken( src, ")" );
                return true;
        }

        // if we are just parsing instead of loading or checking,
        // don't do the R_LoadImage
        if ( !timestamps && !pic ) {
                return true;
        }

        // load it as an image
        R_LoadImage( token.c_str(), pic, width, height, &timestamp, true );

        if ( timestamp == -1 ) {
                return false;
        }

        // add this to the timestamp
        if ( timestamps ) {
                if ( timestamp > *timestamps ) {
                        *timestamps = timestamp;
                }
        }

        return true;
}


/*
===================
R_LoadImageProgram
===================
*/
void R_LoadImageProgram( const char *name, byte **pic, int *width, int *height, ID_TIME_T *timestamps, textureDepth_t *depth ) {
        idLexer src;

        src.LoadMemory( name, strlen(name), name );
        src.SetFlags( LEXFL_NOFATALERRORS | LEXFL_NOSTRINGCONCAT | LEXFL_NOSTRINGESCAPECHARS | LEXFL_ALLOWPATHNAMES );

        parseBuffer[0] = 0;
        if ( timestamps ) {
                *timestamps = 0;
        }

        R_ParseImageProgram_r( src, pic, width, height, timestamps, depth );

        src.FreeSource();
}

/*
===================
R_ParsePastImageProgram
===================
*/
const char *R_ParsePastImageProgram( idLexer &src ) {
        parseBuffer[0] = 0;
        R_ParseImageProgram_r( src, NULL, NULL, NULL, NULL, NULL );
        return parseBuffer;
}