root/trunk/x42view.net/Helpers.TextureUtils.cs

/******************************************************************************
        x42view.net - .x42 viewer and auditing tool
        Copyright (C) 2007 HermitWorks Entertainment Corporation

        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.
                51 Franklin Street, Fifth Floor
                Boston, MA  02110-1301, USA.
******************************************************************************/

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace x42view
{
        partial class Helpers
        {
                private static Vector3 UnpackVector( byte x, byte y, byte z )
                {
                        const float s = 1.0F / 0xFF;

                        return new Vector3(
                                x * s * 2 - 1,
                                y * s * 2 - 1,
                                z * s * 2 - 1 );
                }

                private static unsafe void DownsampleSurface( byte *dst, int dstPitch,
                        byte *src, int srcPitch, int dstW, int dstH, int cx, int cy, int cz,
                        int ca, int nc )
                {
                        for( int y = 0; y < dstH; y++ )
                        {
                                byte* dstR = dst + dstPitch * y;

                                byte* srcR0 = src + srcPitch * (y * 2 + 0);
                                byte* srcR1 = src + srcPitch * (y * 2 + 1);

                                for( int x = 0; x < dstW; x++ )
                                {
                                        byte* d = dstR + nc * x;

                                        byte* s0 = srcR0 + nc * (x * 2 + 0);
                                        byte* s1 = srcR0 + nc * (x * 2 + 1);
                                        byte* s2 = srcR1 + nc * (x * 2 + 0);
                                        byte* s3 = srcR1 + nc * (x * 2 + 1);

                                        Vector3 sv0 = UnpackVector( s0[cx], s0[cy], s0[cz] );
                                        Vector3 sv1 = UnpackVector( s1[cx], s1[cy], s1[cz] );
                                        Vector3 sv2 = UnpackVector( s2[cx], s2[cy], s2[cz] );
                                        Vector3 sv3 = UnpackVector( s3[cx], s3[cy], s3[cz] );

                                        Vector3 avgV = Vector3.Normalize( sv0 + sv1 + sv2 + sv3 ) *
                                                0.5F + new Vector3( 0.5F, 0.5F, 0.5F );

                                        const float s = 0xFF;

                                        d[cx] = (byte)(avgV.X * s);
                                        d[cy] = (byte)(avgV.Y * s);
                                        d[cz] = (byte)(avgV.Z * s);

                                        if( ca != -1 )
                                        {
                                                int avgA = (int)s0[ca] + (int)s1[ca] + (int)s2[ca] + (int)s3[ca];
                                                avgA /= 4;

                                                d[ca] = (byte)avgA;
                                        }
                                }
                        }
                }

                public static unsafe void GenerateNormalMapMips( Texture tex )
                {
                        int cx, cy, cz, ca, nc;
                        SurfaceDescription desc = tex.GetLevelDescription( 0 );

                        switch( desc.Format )
                        {
                        case Format.A8R8G8B8:
                                cx = 2;
                                cy = 1;
                                cz = 0;
                                ca = 3;
                                nc = 4;
                                break;

                        case Format.A8B8G8R8:
                                cx = 0;
                                cy = 1;
                                cz = 2;
                                ca = 3;
                                nc = 4;
                                break;

                        case Format.R8G8B8:
                                cx = 0;
                                cy = 1;
                                cz = 2;
                                ca = -1;
                                nc = 3;
                                break;

                        case Format.X8R8G8B8:
                                cx = 1;
                                cy = 2;
                                cz = 3;
                                ca = -1;
                                nc = 4;
                                break;

                        default:
                                throw new NotSupportedException( "Unsupported normal map format." );
                        }

                        int w = desc.Width;
                        int h = desc.Height;

                        for( int i = 1; i < tex.LevelCount; i++ )
                        {
                                w = Math.Max( w / 2, 1 );
                                h = Math.Max( h / 2, 1 );

                                using( Surface dst = tex.GetSurfaceLevel( i ) )
                                using( Surface src = tex.GetSurfaceLevel( i - 1 ) )
                                {                       
                                        int dstPitch;
                                        GraphicsStream sDst = dst.LockRectangle( LockFlags.None, out dstPitch );

                                        int srcPitch;
                                        GraphicsStream sSrc = src.LockRectangle( LockFlags.None, out srcPitch );

                                        try
                                        {
                                                DownsampleSurface( (byte*)sDst.InternalDataPointer, dstPitch,
                                                        (byte*)sSrc.InternalDataPointer, srcPitch, w, h, cx, cy, cz, ca, nc );
                                        }
                                        finally
                                        {
                                                src.UnlockRectangle();
                                                dst.UnlockRectangle();
                                        }
                                }
                        }
                }
        }
}