src/external/3rd/application/UiBuilder/DDSCanvasGenerator.cpp

   1 #include "FirstUiBuilder.h"
   2 #include "DDSCanvasGenerator.h"
   3
   4 #include "UIDirect3DTextureCanvas.h"
   5 #include "UIDirect3DPrimaryCanvas.h"
   6 #include "UIOutputStream.h"
   7
   8 #include <cstdio>
   9
  10 #include "FileLocator.h"
  11
  12 DDSCanvasGenerator::DDSCanvasGenerator( const UINarrowString &Filename ) :
  13 mFilename (Filename)
  14 {
  15
  16 #if SWG_HACK
  17         if (_strnicmp ("../texture/", mFilename.c_str (), 4) != 0)
  18                 mFilename = "../texture/" + mFilename;
  19 #endif
  20
  21         if (_strnicmp (".dds", mFilename.substr (mFilename.length () - 4).c_str (), 4) != 0)
  22                 mFilename += ".dds";
  23
  24         UINarrowString result;
  25
  26         if (FileLocator::gFileLocator ().findFile (mFilename.c_str (), result))
  27         {
  28                 mFilename = result;
  29         }
  30 }
  31
  32 DDSCanvasGenerator::~DDSCanvasGenerator()
  33 {
  34 }
  35
  36 bool DDSCanvasGenerator::GenerateOnto( UICanvas &DestinationCanvas ) const
  37 {
  38         FILE                                    *fp;
  39         unsigned char *p;
  40
  41         fp = fopen( mFilename.c_str(), "rb" );
  42
  43         if( !fp )
  44         {
  45                 *GetUIOutputStream() << "Error opening '" << mFilename.c_str() << "'.\n";
  46                 return false;
  47         }
  48
  49         fseek( fp, 0, SEEK_END );
  50         long len = ftell(fp);
  51
  52         p = new unsigned char[len];
  53
  54         fseek( fp, 0, SEEK_SET );
  55
  56         if( !p )
  57         {
  58                 fclose( fp );
  59                 return false;
  60         }
  61
  62         fread( p, 1, len, fp );
  63         fclose( fp );
  64
  65         bool rv = InitializeCanvasFromMemory( DestinationCanvas, p );
  66
  67         if (!rv)
  68                 *GetUIOutputStream() << "FAILED TO InitializeCanvasFromMemory '" << mFilename.c_str() << "'\n";
  69
  70         delete p;
  71         return rv;
  72 }
  73
  74 #if WIN32
  75
  76 #include <windows.h>
  77 #include "UIDirectDrawCanvas.h"
  78
  79 bool DDSCanvasGenerator::GetSize( UISize &Out ) const
  80 {
  81         DWORD           dwMagic;
  82         DDSURFACEDESC2  ddsd;
  83         FILE                                     *fp;
  84
  85         fp = fopen( mFilename.c_str(), "rb" );
  86
  87         if( !fp )
  88         {
  89                 *GetUIOutputStream() << "Error opening '" << mFilename.c_str() << "'\n";
  90                 return false;
  91         }
  92
  93         fread( &dwMagic, sizeof(DWORD), 1, fp );
  94         if( dwMagic != MAKEFOURCC('D','D','S',' ') )
  95         {
  96                 *GetUIOutputStream() << "File '" << mFilename.c_str() << "' is not an S3 compressed texture.\n";
  97                 fclose( fp );
  98                 return false;
  99         }
 100
 101         if( !fread( &ddsd, sizeof( ddsd ), 1, fp ) )
 102         {
 103                 *GetUIOutputStream() << "Error reading '" << mFilename.c_str() << "'\n";
 104                 fclose( fp );
 105                 return false;
 106         }
 107
 108         fclose( fp );
 109         Out.x = ddsd.dwWidth;
 110         Out.y = ddsd.dwHeight;
 111         return true;
 112 }
 113
 114 bool DDSCanvasGenerator::InitializeCanvasFromMemory( UICanvas &DestinationCanvas, unsigned char *pbase ) const
 115 {
 116         assert( DestinationCanvas.IsA( TUIDirect3DTextureCanvas ) );
 117
 118         DWORD                                                                            dwMagic = *(DWORD *)pbase;
 119         DDSURFACEDESC2                                   ddsd    = *(LPDDSURFACEDESC2)(pbase + sizeof( DWORD ));
 120         void                                                                            *pdata   = pbase + sizeof( DWORD ) + sizeof( DDSURFACEDESC2 );
 121         UIDirect3DTextureCanvas  InMemoryCanvas( UISize( ddsd.dwWidth, ddsd.dwHeight ), true );
 122         UIDirect3DTextureCanvas *pDestCanvas = reinterpret_cast<UIDirect3DTextureCanvas *>( &DestinationCanvas );
 123
 124         if( dwMagic != MAKEFOURCC('D','D','S',' ') )
 125         {
 126                 *GetUIOutputStream() << "  :::   NOT A DDS\n";
 127                 return false;
 128         }
 129
 130         ddsd.ddsCaps.dwCaps  |= DDSCAPS_SYSTEMMEMORY;
 131         ddsd.dwMipMapCount    = 0;
 132         ddsd.ddsCaps.dwCaps  &= ~( DDSCAPS_MIPMAP | DDSCAPS_COMPLEX );
 133         ddsd.dwFlags         &= ~(DDSD_PITCH | DDSD_MIPMAPCOUNT | DDSD_LINEARSIZE);
 134
 135         if( !InMemoryCanvas.CreateFromSurfaceDescription( &ddsd ) )
 136         {
 137                 *GetUIOutputStream() << "  :::   FAILED TO CREATE FROM SURFACE DESCRIPTION\n";
 138                 return false;
 139         }
 140
 141         if( FAILED( InMemoryCanvas.GetSurface()->Lock( 0, &ddsd, DDLOCK_WAIT, 0 ) ) )
 142         {
 143                 *GetUIOutputStream() << "  :::   FAILED TO LOCK";
 144                 return false;
 145         }
 146
 147         if( ddsd.dwFlags & DDSD_LINEARSIZE )
 148                 memcpy( ddsd.lpSurface, pdata, ddsd.dwLinearSize );
 149         else
 150         {
 151                 BYTE* pDest   = (BYTE*)ddsd.lpSurface;
 152                 BYTE* pSource = (BYTE*)pdata;
 153                 DWORD dwBytesPerRow = ddsd.dwWidth * ddsd.ddpfPixelFormat.dwRGBBitCount / 8;
 154
 155                 for( DWORD yp = 0; yp < ddsd.dwHeight; yp++ )
 156                 {
 157                         memcpy( pDest, pSource,dwBytesPerRow );
 158                         pDest   += ddsd.lPitch;
 159                         pSource += dwBytesPerRow;
 160                 }
 161         }
 162
 163         if( FAILED( InMemoryCanvas.GetSurface()->Unlock( NULL ) ) )
 164         {
 165                 *GetUIOutputStream() << "  :::   FAILED TO UNLOCK SURFACE\n";
 166                 return false;
 167         }
 168
 169         DDSURFACEDESC2 ddsdHardwareSurface = ddsd;
 170
 171         if( !pDestCanvas->GetRenderCanvas()->MatchPixelFormat( &ddsd.ddpfPixelFormat, &ddsdHardwareSurface.ddpfPixelFormat ) )
 172         {
 173                 *GetUIOutputStream() << "  :::   FAILED TO MATCH PIXEL FORMAT\n";
 174                 return false;
 175         }
 176
 177         ddsdHardwareSurface.ddsCaps.dwCaps &= ~DDSCAPS_SYSTEMMEMORY;
 178         ddsdHardwareSurface.ddsCaps.dwCaps |=  DDSCAPS_VIDEOMEMORY;
 179
 180         if( !pDestCanvas->CreateFromSurfaceDescription( &ddsdHardwareSurface ) )
 181         {
 182                 *GetUIOutputStream() << "  :::   FAILED TO CREATE FROM SURFACE DESCRIPTION\n";
 183                 return false;
 184         }
 185
 186         pDestCanvas->BltFrom( &InMemoryCanvas, UIPoint(0,0), UIPoint(0,0), UISize( ddsd.dwWidth, ddsd.dwHeight ) );
 187         return true;
 188 }
 189
 190 #endif