#include "StdAfx.h"
#include <assert.h>							// assert()
#include <Dbghelp.h>						// GetTimestampForLoadedLibrary

#include "IRCLog.h"								// IRCLog
#include "IConfig.h"						// IConfig
#include "PathUtil.h"						// ReplaceExtension

#include "ImageCompiler.h"			// CImageCompiler
#include "UserDialog.h"					// CUserDialog
#include "ICfgFile.h"						// ICfgFile

#include <ddraw.h>

#include "neuquant.h"

#include "ImageObject.h"
#include <commctrl.h>								// TCITEM

#define CCERROR		m_pCC->pError
#define CCLOG			m_pCC->pLog


struct SPixelFormats
{
	int iBitsPerPixel;
	char *szAlpha;
	D3DFORMAT DxtNo;
	char *szName;
	char *szUncompressedAltName;
	char *szDescription;
	bool bCompressed;
};



// *.dds /targetroot:c:\mastercd2 /reduce:1 /userdialog=0

static SPixelFormats g_pixelformats[]=
{
// Unsigned Formats (Data in an unsigned format must be positive. Unsigned formats use combinations of
// (R)ed, (G)reen, (B)lue, (A)lpha, (L)uminance, and (P)alette data.
// Palette data is also referred to as color indexed data because the data is used to index a color palette.)

		{ 24,"0",			D3DFMT_R8G8B8,			"R8G8B8",			"X8R8G8B8",		"24-bit RGB pixel format with 8 bits per channel",false },
		{ 32,"8",			D3DFMT_A8R8G8B8,		"A8R8G8B8",		"A8R8G8B8",		"32-bit ARGB pixel format with alpha, using 8 bits per channel",false },
		{ 32,"0",			D3DFMT_X8R8G8B8,		"X8R8G8B8",		"X8R8G8B8",		"32-bit RGB pixel format, where 8 bits are reserved for each color",false },
		{ 16,"0",			D3DFMT_R5G6B5,			"R5G6B5",			"X8R8G8B8",		"16-bit RGB pixel format with 5 bits red, 6 bits green, and 5 bits blue",false },
		{ 16,"1",			D3DFMT_A1R5G5B5,		"A1R5G5B5",		"A8R8G8B8",		"16-bit ARGB using 5 bits for each color and 1 bit for alpha",false },
		{ 16,"0",			D3DFMT_X1R5G5B5,		"X1R5G5B5",		"X8R8G8B8",		"16-bit RGB using 5 bits for each color",false },
		{ 16,"4",			D3DFMT_A4R4G4B4,		"A4R4G4B4",		"A8R8G8B8",		"16-bit ARGB with 4 bits for each channel",false },
		{ 16,"0",			D3DFMT_X4R4G4B4,		"X4R4G4B4",		"X8R8G8B8",		"16-bit RGB using 4 bits for each color",false },
		{ 8, "8",			D3DFMT_A8,					"A8",					"A8",					"8-bit alpha only",false },
		{ 8, "0",			D3DFMT_R3G3B2,			"R3G3B2",			"X8R8G8B8",		"8-bit RGB using 3 bits red, 3 bits green, and 2 bits blue",false },
//	{ 16,"8",			D3DFMT_A8R3G3B2,		"A8R3G3B2",		"A8R8G8B8",		"16-bit ARGB texture format using 8 bits for alpha, 3 bits each for red and green, and 2 bits for blue",false },
//	{ 32,"2",			D3DFMT_A2B10G10R10,	"A2B10G10R10","A2B10G10R10","32-bit pixel format using 10 bits for each color and 2 bits for alpha",false },
//	{ 32,"0",			D3DFMT_G16R16,			"G16R16",			"G16R16",			"32-bit pixel format using 16 bits each for green and red",false },
//	{ 8, "8",			D3DFMT_A8P8,				"A8P8",				"A8P8",				"8-bit color indexed with 8 bits of alpha",false },
		{ 8, "0",			D3DFMT_P8,					"P8",					"X8R8G8B8",		"8-bit color indexed",false },
		{ 8, "0",			D3DFMT_L8,					"L8",					"L8",					"8-bit luminance only",false },
//	{ 16,"8",			D3DFMT_A8L8,				"A8L8",				"A8L8",				"16-bit using 8 bits each for alpha and luminance",false },
//	{ 8, "4",			D3DFMT_A4L4,				"A4L4",				"A8L8",				"8-bit using 4 bits each for alpha and luminance",false },

// Signed Formats (Data in a signed format can be both positive and negative. Signed formats use combinations of (U), (V), (W), and (Q) data.) -----------------------------------------

		{ 16,"0",			D3DFMT_V8U8,				"V8U8",				"V8U8",				"16-bit signed bump-map format using 8 bits each for u and v data",false },
//	{ 32,"0",			D3DFMT_Q8W8V8U8,		"Q8W8V8U8",		"Q8W8V8U8",		"32-bit signed bump-map format using 8 bits for each channel",false },
//		{ 32,"0",			D3DFMT_V16U16,			"V16U16",			"V16U16",			"32-bit signed bump-map format using 16 bits for each channel",false },
//	{ 32,"0",			D3DFMT_W11V11U10,		"W11V11U10",	"W11V11U10",	"32-bit bump-map format using 11 bits each for w and v, and 10 bits for u",false },

// Mixed Formats (Data in mixed formats can contain a combination of unsigned data and signed data.) -----------------------------------------

//	{ 16,"0",			D3DFMT_L6V5U5,			"L6V5U5",			"X8L8V8U8",		"16-bit signed/unsigned bump-map format with luminance using 6 bits for luminance, and 5 bits each for u and v",false },
//	{ 32,"0",			D3DFMT_X8L8V8U8,		"X8L8V8U8",		"X8L8V8U8",		"32-bit signed/unsigned bump-map format with luminance using 8 bits for each channel",false },
//	{ 32,"2",			D3DFMT_A2W10V10U10,	"A2W10V10U10","A2W10V10U10","32-bit signed/unsigned bump-map format using 2 bits for alpha and 10 bits each for w, v, and u",false },

// FourCC Formats (Data in a FourCC format is compressed data.) -----------------------------------------

//	{ 16,"0",			D3DFMT_UYVY,				"UYVY",				"A8R8G8B8",		"UYVY compressed format (PC98 compliance)",true },
//	{ 16,"0",			D3DFMT_YUY2,				"YUY2",				"A8R8G8B8",		"YUY2 compressed format (PC98 compliance)",true },
		{ 8, "0/1",		D3DFMT_DXT1,				"DXT1",				"A8R8G8B8",		"DXT1 compression texture format",true },
//	{ 16,"4p",		D3DFMT_DXT2,				"DXT2",				"A8R8G8B8",		"DXT2 compression texture format",true },
		{ 16,"4",			D3DFMT_DXT3,				"DXT3",				"A8R8G8B8",		"DXT3 compression texture format",true },
//	{ 16,"3of8p",	D3DFMT_DXT4,				"DXT4",				"A8R8G8B8",		"DXT4 compression texture format",true },
		{ 16,"3of8",	D3DFMT_DXT5,				"DXT5",				"A8R8G8B8",		"DXT5 compression texture format",true }
};




// constructor
CImageCompiler::CImageCompiler()
{
	m_pd3ddev=0;
	m_pd3d=0;
	m_ptexOrig=0;
	m_pNewImage=NULL;
	m_dwOrigWidth=0;
	m_dwOrigHeight=0;
	m_dwDepth=0;
	m_dwCubeMapFlags=0;
	m_pCC=0;
	m_iOrigPixelFormatNo=0;
	m_hWnd=0;
}


// destructor
CImageCompiler::~CImageCompiler()
{
	DeInit();

	assert(!m_pd3ddev);
	assert(!m_pd3d);
	assert(!m_ptexOrig);
	assert(!m_pNewImage);
}



void CImageCompiler::DeInit( void )
{
	ReleasePpo(&m_ptexOrig);
	if(m_pNewImage) delete m_pNewImage;

	ReleasePpo(&m_pd3ddev);
	ReleasePpo(&m_pd3d);

	UnregisterClass("skeleton", g_hInst);
}


bool CImageCompiler::Save( const char *lpszPathName )
{
	if(!m_pNewImage)
	{
		CCLOG->LogError("CImageCompiler::Save failed (conversion failed?)");
		return(false);
	}
	
	if(!m_pNewImage->Save(lpszPathName))
	{
		CCLOG->LogError("CImageCompiler::Save failed (file IO?)");
		return false;
	};
	
	/*
	//LPDIRECT3DTEXTURE9 pmiptexSrc = (LPDIRECT3DTEXTURE9)ptexSrc;
	LPDIRECT3DSURFACE9 psurf = NULL;
	DXERRORCHECK(((LPDIRECT3DTEXTURE9)m_ptexNew)->GetSurfaceLevel(0, &psurf));

	D3DSURFACE_DESC sd;
	psurf->GetDesc(&sd);
	
	switch(sd.Format)
	{
		case D3DFMT_P8:
			if(!m_pPalette)
			{
				CCLOG->LogError("CImageCompiler::Save missing palette??");
				return(false);
			};
			if(!SavePaletizedTexture(lpszPathName, (LPDIRECT3DTEXTURE9)m_ptexNew, sd))
			{
				CCLOG->LogError("CImageCompiler::Save palettized texture failed");
				return(false);
			};	
			free(m_pPalette);
			m_pPalette = NULL;
			break;		
		
		default:
			if( FAILED( D3DXSaveTextureToFile( lpszPathName, D3DXIFF_DDS, m_ptexNew, NULL ) ) )
			{
				CCLOG->LogError("CImageCompiler::Save D3DXSaveTextureToFile failed (file IO?)");
				return(false);
			};
			break;
	};
	*/

	return true;
}


LRESULT CALLBACK MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	return DefWindowProc(hWnd,msg,wParam,lParam);
}


bool CImageCompiler::Init( HWND inhWnd )
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX); 

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= (WNDPROC)MainWndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= g_hInst;
	wcex.hIcon			= 0;
	wcex.hCursor		= 0;
	wcex.hbrBackground	= 0;
	wcex.lpszMenuName	= 0;
	wcex.lpszClassName	= "skeleton";
	wcex.hIconSm		= 0;

	RegisterClassEx(&wcex);

  m_hWnd = CreateWindow(
      "skeleton", "the title",
      WS_OVERLAPPEDWINDOW,
      0, 0, 400, 400,
      NULL, NULL, g_hInst, NULL);

   // return if error on CreateWindow
  if(m_hWnd == NULL)
		return false;

	 // show the window
//  ShowWindow(m_hWnd, SW_SHOWNORMAL);
//  UpdateWindow(m_hWnd);




	InitCommonControls();
	// Initialize DirectDraw
	m_pd3d = Direct3DCreate9(D3D_SDK_VERSION);
	if (m_pd3d == NULL)
	{
		CCLOG->LogError("Direct3DCreate9 failed");
		return false;
	}

	HRESULT hr;
	D3DDEVTYPE devType;

	ZeroMemory(&m_presentParams, sizeof(m_presentParams));
	m_presentParams.Windowed = TRUE;
	m_presentParams.SwapEffect = D3DSWAPEFFECT_COPY;
	m_presentParams.BackBufferWidth = 256;
	m_presentParams.BackBufferHeight = 256;
	m_presentParams.BackBufferFormat = D3DFMT_UNKNOWN;

	//devType = D3DDEVTYPE_REF; 
	devType = D3DDEVTYPE_HAL; 

	hr = m_pd3d->CreateDevice(D3DADAPTER_DEFAULT, devType,m_hWnd, 
		D3DCREATE_SOFTWARE_VERTEXPROCESSING, &m_presentParams, &m_pd3ddev);
	if (FAILED(hr))
		return false;

	D3DCAPS9 Caps;
	m_pd3ddev->GetDeviceCaps(&Caps);
	if (Caps.PrimitiveMiscCaps & D3DPMISCCAPS_NULLREFERENCE)
		return false;

	return(true);
}





bool CImageCompiler::Load( const char * lpszPathName )
{
	D3DXIMAGE_INFO imageinfo;
	D3DXIMAGE_INFO imageinfo2;

	if( FAILED( D3DXGetImageInfoFromFile( lpszPathName, &imageinfo ) ) )
	{
		CCLOG->LogError("D3DXGetImageInfoFromFile failed");
		return FALSE;
	}

	HRESULT hRes;

	switch( imageinfo.ResourceType )
	{
	case D3DRTYPE_TEXTURE:
		hRes=D3DXCreateTextureFromFileEx( m_pd3ddev, lpszPathName, 
			imageinfo.Width, imageinfo.Height, imageinfo.MipLevels, 0,
			imageinfo.Format, D3DPOOL_DEFAULT, D3DX_FILTER_NONE, D3DX_FILTER_NONE, 0, 
			&imageinfo2, NULL, (LPDIRECT3DTEXTURE9*)&m_ptexOrig );

		if(FAILED(hRes))
		{
			CCLOG->LogError("D3DXCreateTextureFromFileEx failed (power of two?) '%s'",DXGetErrorString9(hRes));
			return false;
		}
		m_dwOrigWidth = imageinfo2.Width;
		m_dwOrigHeight = imageinfo2.Height;
		m_dwDepth = 0;

		if( imageinfo.ImageFileFormat == D3DXIFF_BMP )
		{
			/* Baustelle			// Look for "foo_a.bmp" for alpha channel
			CString strPath = lpszPathName;
			int i = strPath.ReverseFind('.');
			HRESULT hr;
			strPath = strPath.Left(i) + "_a.bmp";
			CFileStatus status;
			if (CFile::GetStatus(strPath, status))
			{
			// Make sure there's an alpha channel to load alpha image into
			if (FAILED(EnsureAlpha(&m_ptexOrig)))
			return false;

			LPDIRECT3DSURFACE9 psurf;

			hr = ((LPDIRECT3DTEXTURE9)m_ptexOrig)->GetSurfaceLevel(0, &psurf);
			if (FAILED(hr))
			return false;

			hr = LoadAlphaIntoSurface(strPath, psurf);
			ReleasePpo(&psurf);
			if (FAILED(hr))
			return false;
			}
			*/
		}
		break;

	case D3DRTYPE_VOLUMETEXTURE:
		if( FAILED( D3DXCreateVolumeTextureFromFileEx( m_pd3ddev, lpszPathName, 
			imageinfo.Width, imageinfo.Height, imageinfo.Depth, imageinfo.MipLevels,
			0, imageinfo.Format, D3DPOOL_MANAGED, D3DX_FILTER_NONE, D3DX_FILTER_NONE,
			0, &imageinfo2, NULL, (LPDIRECT3DVOLUMETEXTURE9*)&m_ptexOrig ) ) )
		{
			CCLOG->LogError("D3DXCreateVolumeTextureFromFileEx failed");
			return false;
		}
		m_dwOrigWidth = imageinfo2.Width;
		m_dwOrigHeight = imageinfo2.Height;
		m_dwDepth = imageinfo2.Depth;
		break;

	case D3DRTYPE_CUBETEXTURE:
		if( FAILED( D3DXCreateCubeTextureFromFileEx( m_pd3ddev, lpszPathName, 
			imageinfo.Width, imageinfo.MipLevels, 0, imageinfo.Format, 
			D3DPOOL_MANAGED, D3DX_FILTER_NONE, D3DX_FILTER_NONE, 
			0, &imageinfo2, NULL, (LPDIRECT3DCUBETEXTURE9*)&m_ptexOrig ) ) )
		{
			CCLOG->LogError("D3DXCreateCubeTextureFromFileEx failed");
			return false;
		}
		m_dwOrigWidth = imageinfo2.Width;
		m_dwOrigHeight = imageinfo2.Height;
		m_dwDepth = 0;
		m_dwCubeMapFlags = DDS_CUBEMAP_ALLFACES;
		break;

	default:
		CCLOG->LogError("ERROR_COULDNTLOADFILE");
		return false;
	}

	return true;
}



LPDIRECT3DBASETEXTURE9 CImageCompiler::CreateUncompressedMipMaps( const DWORD indwFilter, const DWORD indwReduceResolution,
		const bool inbRemoveMips ) 
{
	D3DFORMAT fmt;
	HRESULT hr;
	LPDIRECT3DTEXTURE9 pmiptex = NULL;
	LPDIRECT3DCUBETEXTURE9 pcubetex = NULL;
	LPDIRECT3DVOLUMETEXTURE9 pvoltex = NULL;
	LPDIRECT3DTEXTURE9 pmiptexNew = NULL;
	LPDIRECT3DCUBETEXTURE9 pcubetexNew = NULL;
	LPDIRECT3DVOLUMETEXTURE9 pvoltexNew = NULL;
	LPDIRECT3DSURFACE9 psurfSrc;
	LPDIRECT3DSURFACE9 psurfDest;
	LPDIRECT3DVOLUME9 pvolSrc;
	LPDIRECT3DVOLUME9 pvolDest;

	if (IsVolumeMap())
		pvoltex = (LPDIRECT3DVOLUMETEXTURE9)m_ptexOrig;
	else if (IsCubeMap())
		pcubetex = (LPDIRECT3DCUBETEXTURE9)m_ptexOrig;
	else
		pmiptex = (LPDIRECT3DTEXTURE9)m_ptexOrig;

	if (pvoltex != NULL)
	{
		D3DVOLUME_DESC vd;
		pvoltex->GetLevelDesc(0, &vd);
		fmt = vd.Format;
	}
	else if (pcubetex != NULL)
	{
		D3DSURFACE_DESC sd;
		pcubetex->GetLevelDesc(0, &sd);
		fmt = sd.Format;
	}
	else
	{
		D3DSURFACE_DESC sd;
		pmiptex->GetLevelDesc(0, &sd);
		fmt = sd.Format;
	}

	// if possible do the mipmaps without compression
	{
		int iInputNo=GetNoFromD3DFormat(fmt);

		if(iInputNo!=-1)																										// format is recognized
			fmt=g_pixelformats[GetPixelFormatUncompressed(iInputNo)].DxtNo;		// use an uncompressed format
	}

	DWORD dwW,dwH;

	DWORD dwNumNewMips = max(_CalcMipCount(m_dwOrigWidth,m_dwOrigHeight)-indwReduceResolution,1);
	if(inbRemoveMips)dwNumNewMips=1;

	dwW=max(m_dwOrigWidth>>indwReduceResolution,1);
	dwH=max(m_dwOrigHeight>>indwReduceResolution,1);


	// Create destination mipmap surface - same format as source
	if (pvoltex != NULL)
	{
		if (FAILED(hr = m_pd3ddev->CreateVolumeTexture(dwW, dwH, m_dwDepth, dwNumNewMips, 0, fmt, D3DPOOL_SYSTEMMEM, &pvoltexNew, NULL)))
			{	assert(0);return(0); }

		hr = pvoltex->GetVolumeLevel(0, &pvolSrc);
		hr = pvoltexNew->GetVolumeLevel(0, &pvolDest);
		hr = D3DXLoadVolumeFromVolume(pvolDest, NULL, NULL, pvolSrc, NULL, NULL, 
			indwFilter, 0);
		ReleasePpo(&pvolSrc);
		ReleasePpo(&pvolDest);
		hr = D3DXFilterVolumeTexture(pvoltexNew, NULL, 0, indwFilter);
		assert(pvoltexNew);
		return((LPDIRECT3DBASETEXTURE9)pvoltexNew);
	}
	else if (pmiptex != NULL)
	{
		HRESULT hr = m_pd3ddev->CreateTexture(dwW, dwH, dwNumNewMips, 0, fmt, D3DPOOL_MANAGED, &pmiptexNew, NULL);
		DXERRORCHECK("CreateTexture",hr);
		if (FAILED(hr))
		{	
			CCLOG->LogError("CreateTexture failed (size is not power of two?)");
			assert(0);return(0); 
		}

		hr = pmiptex->GetSurfaceLevel(0, &psurfSrc);
		hr = pmiptexNew->GetSurfaceLevel(0, &psurfDest);
		hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
			indwFilter, 0);
		ReleasePpo(&psurfSrc);
		ReleasePpo(&psurfDest);
		hr = D3DXFilterTexture(pmiptexNew, NULL, 0, indwFilter);
		assert(pmiptexNew);
		return((LPDIRECT3DBASETEXTURE9)pmiptexNew);
	}
	else
	{
		if (FAILED(hr = m_pd3ddev->CreateCubeTexture(dwW, dwNumNewMips, 0, fmt, D3DPOOL_MANAGED, &pcubetexNew, NULL)))
			{	assert(0);return(0); }

		hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &psurfSrc);
		hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &psurfDest);
		hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
			indwFilter, 0);
		ReleasePpo(&psurfSrc);
		ReleasePpo(&psurfDest);
		hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_X, 0, &psurfSrc);
		hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_X, 0, &psurfDest);
		hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
			indwFilter, 0);
		ReleasePpo(&psurfSrc);
		ReleasePpo(&psurfDest);
		hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Y, 0, &psurfSrc);
		hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Y, 0, &psurfDest);
		hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
			indwFilter, 0);
		ReleasePpo(&psurfSrc);
		ReleasePpo(&psurfDest);
		hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Y, 0, &psurfSrc);
		hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Y, 0, &psurfDest);
		hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
			indwFilter, 0);
		ReleasePpo(&psurfSrc);
		ReleasePpo(&psurfDest);
		hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Z, 0, &psurfSrc);
		hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Z, 0, &psurfDest);
		hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
			indwFilter, 0);
		ReleasePpo(&psurfSrc);
		ReleasePpo(&psurfDest);
		hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Z, 0, &psurfSrc);
		hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Z, 0, &psurfDest);
		hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
			indwFilter, 0);
		ReleasePpo(&psurfSrc);
		ReleasePpo(&psurfDest);
		hr = D3DXFilterCubeTexture(pcubetexNew, NULL, 0, indwFilter);
		assert(pcubetexNew);
		return((LPDIRECT3DBASETEXTURE9)pcubetexNew);
	}
}

CString CImageCompiler::GetSourceFilename( void )
{
	assert(m_pCC);	

	return(CString(m_pCC->sourceFile));
}

DWORD CImageCompiler::_CalcMipCount( const DWORD indwWidth, const DWORD indwHeight )
{
	LONG lwTempH,lwTempW,lwPowsW,lwPowsH;

	lwTempW = indwWidth;
	lwTempH = indwHeight;
	lwPowsW = 0;
	lwPowsH = 0;
	while (lwTempW > 0)
	{
		lwPowsW++;
		lwTempW = lwTempW / 2;
	}
	while (lwTempH > 0)
	{
		lwPowsH++;
		lwTempH = lwTempH / 2;
	}
	return(lwPowsW > lwPowsH ? lwPowsW : lwPowsH);
}



bool CImageCompiler::Compress( LPDIRECT3DBASETEXTURE9 inSrc, D3DFORMAT fmtTo, const DWORD indwFilter )
{
	assert(inSrc);
	if(m_pNewImage) delete m_pNewImage;
	m_pNewImage = NULL;
	return ChangeFormat(inSrc,fmtTo,m_pNewImage,indwFilter,0)==S_OK;
}



HRESULT CImageCompiler::ChangeFormat( LPDIRECT3DBASETEXTURE9 ptexCur, D3DFORMAT fmtTo, ImageObject *&pNewImage,
	const DWORD indwFilter, const DWORD indwReduceResolution )
{
	assert(ptexCur);

	HRESULT hr;
	LPDIRECT3DTEXTURE9 pmiptex;
	LPDIRECT3DCUBETEXTURE9 pcubetex;
	LPDIRECT3DVOLUMETEXTURE9 pvoltex;
	D3DFORMAT fmtFrom;
	LPDIRECT3DTEXTURE9 pmiptexNew;
	LPDIRECT3DCUBETEXTURE9 pcubetexNew;
	LPDIRECT3DVOLUMETEXTURE9 pvoltexNew;

	DWORD dwWidth,dwHeight,dwMips=ptexCur->GetLevelCount();

	if (IsVolumeMap())
	{
		pvoltex = (LPDIRECT3DVOLUMETEXTURE9)ptexCur;
		D3DVOLUME_DESC vd;
		pvoltex->GetLevelDesc(0, &vd);
		fmtFrom = vd.Format;
		dwWidth=vd.Width;dwHeight=vd.Height;
	}
	else if (IsCubeMap())
	{
		pcubetex = (LPDIRECT3DCUBETEXTURE9)ptexCur;
		D3DSURFACE_DESC sd;
		pcubetex->GetLevelDesc(0, &sd);
		fmtFrom = sd.Format;
		dwWidth=sd.Width;dwHeight=sd.Height;
	}
	else
	{
		pmiptex = (LPDIRECT3DTEXTURE9)ptexCur;
		D3DSURFACE_DESC sd;
		pmiptex->GetLevelDesc(0, &sd);
		fmtFrom = sd.Format;
		dwWidth=sd.Width;dwHeight=sd.Height;
	}

	if (fmtFrom == D3DFMT_DXT2 || fmtFrom == D3DFMT_DXT4)
	{
		if (fmtTo == D3DFMT_DXT1)
		{
			CCLOG->LogError("ERROR_PREMULTTODXT1");
		}
		else if (fmtTo != D3DFMT_DXT2 && fmtTo != D3DFMT_DXT4)
		{
			CCLOG->LogError("ERROR_PREMULTALPHA");
			return E_FAIL;
		}
	}

	if (IsVolumeMap())
	{
		hr = m_pd3ddev->CreateVolumeTexture(dwWidth,dwHeight, m_dwDepth, dwMips,	0, fmtTo, D3DPOOL_SYSTEMMEM, &pvoltexNew, NULL);
		if (FAILED(hr))
			return hr;
		pNewImage = new DXImageVol(pvoltexNew);
		if (FAILED(BltAllLevels(D3DCUBEMAP_FACE_FORCE_DWORD, ptexCur, pNewImage,indwFilter,indwReduceResolution, fmtTo)))
			return hr;
	}
	else if (IsCubeMap())
	{
		hr = m_pd3ddev->CreateCubeTexture(dwWidth, dwMips, 0, fmtTo, D3DPOOL_MANAGED, &pcubetexNew, NULL);
		if (FAILED(hr))
			return hr;
		pNewImage = new DXImage(pcubetexNew);
		if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_X, ptexCur, pNewImage,indwFilter,indwReduceResolution, fmtTo)))
			return hr;
		if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_X, ptexCur, pNewImage,indwFilter,indwReduceResolution, fmtTo)))
			return hr;
		if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_Y, ptexCur, pNewImage,indwFilter,indwReduceResolution, fmtTo)))
			return hr;
		if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_Y, ptexCur, pNewImage,indwFilter,indwReduceResolution, fmtTo)))
			return hr;
		if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_Z, ptexCur, pNewImage,indwFilter,indwReduceResolution, fmtTo)))
			return hr;
		if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_Z, ptexCur, pNewImage,indwFilter,indwReduceResolution, fmtTo)))
			return hr;
	}
	else
	{
		if(fmtTo==D3DFMT_P8)
		{
			pNewImage = new P8Image(dwWidth, dwHeight, dwMips);
		}
		else
		{
			if ((fmtTo == D3DFMT_DXT1 || fmtTo == D3DFMT_DXT2 ||
				fmtTo == D3DFMT_DXT3 || fmtTo == D3DFMT_DXT4 ||
				fmtTo == D3DFMT_DXT5) && (m_dwOrigWidth % 4 != 0 || m_dwOrigHeight % 4 != 0))
			{
				CCLOG->LogError("ERROR_NEEDMULTOF4 = for DXT compression we need width and height to be multiple of 4");
				return E_FAIL;
			}

			hr = m_pd3ddev->CreateTexture(dwWidth,dwHeight, dwMips, 0, fmtTo, D3DPOOL_MANAGED, &pmiptexNew, NULL);
			if (FAILED(hr))
			{
				CCLOG->LogError("CreateTexture failed (texture format not supported by driver)");
				return hr;
			}
			pNewImage = new DXImage(pmiptexNew);
		};
		if (FAILED(BltAllLevels(D3DCUBEMAP_FACE_FORCE_DWORD, ptexCur, pNewImage,indwFilter,indwReduceResolution, fmtTo)))
			return hr;
	}
	return S_OK;
}

HRESULT CImageCompiler::BltAllLevels( D3DCUBEMAP_FACES FaceType, LPDIRECT3DBASETEXTURE9 ptexSrc,
	ImageObject *pNewImage, const DWORD indwFilter, const DWORD indwReduceResolution, D3DFORMAT fmtTo )
{
	DWORD dwReduceRes=indwReduceResolution;
//	DWORD dwMips=_CalcMipCount(m_dwOrigWidth,m_dwOrigHeight)-dwReduceRes;
	DWORD dwMips=ptexSrc->GetLevelCount();
	
	for (DWORD iLevel = 0; iLevel < dwMips; iLevel++)
	{
		if (IsVolumeMap())
		{
			LPDIRECT3DVOLUMETEXTURE9 pvoltexSrc = (LPDIRECT3DVOLUMETEXTURE9)ptexSrc;
			LPDIRECT3DVOLUME9 pvolSrc = NULL;
			DXERRORCHECK("GetVolumeLevel",pvoltexSrc->GetVolumeLevel(iLevel+indwReduceResolution, &pvolSrc));
			DXERRORCHECK("Convert1",pNewImage->Convert((LPDIRECT3DSURFACE9)pvolSrc, iLevel, indwFilter, FaceType, m_pd3ddev));
			ReleasePpo(&pvolSrc);
		}
		else if (IsCubeMap())
		{
			LPDIRECT3DCUBETEXTURE9 pcubetexSrc = (LPDIRECT3DCUBETEXTURE9)ptexSrc;
			LPDIRECT3DSURFACE9 psurfSrc = NULL;
			DXERRORCHECK("GetCubeMapSurface",pcubetexSrc->GetCubeMapSurface(FaceType, iLevel+indwReduceResolution, &psurfSrc));
			DXERRORCHECK("Convert2",pNewImage->Convert(psurfSrc, iLevel, indwFilter, FaceType, m_pd3ddev));
			ReleasePpo(&psurfSrc);
		}
		else
		{
			LPDIRECT3DTEXTURE9 pmiptexSrc = (LPDIRECT3DTEXTURE9)ptexSrc;
			LPDIRECT3DSURFACE9 psurfSrc = NULL;
			DXERRORCHECK("GetSurfaceLevel",pmiptexSrc->GetSurfaceLevel(iLevel+indwReduceResolution, &psurfSrc));

			{ 
				HRESULT _hr = pNewImage->Convert(psurfSrc, iLevel, indwFilter, FaceType, m_pd3ddev); 
				if(FAILED(_hr))
					CCLOG->LogError("'%s' DX ERROR: %s", "Convert3",DXGetErrorString9A(_hr));
			}

			ReleasePpo(&psurfSrc);
		}
	};
	
	return S_OK;
}

void CImageCompiler::Release( void )
{
	delete this;
}


int CImageCompiler::GetIntParam( CString insName, const int iniDefault ) const
{
	int iRet=iniDefault;		
	CString sValue;

	if(m_pCC->config->Get(insName,sValue))
		sscanf(sValue.GetBuffer(),"%d",&iRet);

	CCLOG->Log("CImageCompiler::%s=%d",insName.GetBuffer(),iRet);

	return(iRet);
}

bool CImageCompiler::GetBoolParam( CString insName, const bool inbDefault ) const
{
	return( GetIntParam(insName,inbDefault?1:0)!=0 );
}


// Process file. Return error code or 0 if successful
bool CImageCompiler::Process( ConvertContext &cc )
{
	m_pCC=&cc;

	// this would fit much better in the Init() method - but unfortunatly we don't have access to CCLOG there
	static bool bFirstTime=true;
	if(bFirstTime)											// print the supported formats
	{
		CCLOG->Log("");
		CCLOG->Log("ResourceCompilerImage supported output pixel formats:");

		int iCount=GetPixelFormatCount();

		for(int i=0;i<iCount;i++)
		{
			CCLOG->Log(" * %s",g_pixelformats[i].szName);
			CCLOG->Log("   %s",g_pixelformats[i].szDescription);
		}
		CCLOG->Log("");

		bFirstTime=false;
	}


	// highest to lowest priority:
	//
	// ranger_statue._rc  rc.ini  commandline
	CString sourceFile = cc.getSourcePath();

	if(Load(sourceFile))
	{
		if(!LoadConfigFile())
			return false;			// error
			
		SetPresetSettings();

		if(m_Props.m_bUserDialog)
		{
			CUserDialog dialog;

			// user dialog should show only the first time - if not specified differently
			{
				int sValue;

				if(!m_pCC->config->Get("userdialog",sValue))
					m_Props.m_bUserDialog=false;
			}
			
			dialog.DoModal(this);
		}
		else RunWithProperties(true);			// run and save

	}
	else CCLOG->LogError("CImageCompiler::Process load '%s' failed",(const char*)sourceFile );

	m_pCC=0;

	return true;		// success
}


bool CImageCompiler::RunWithProperties( const bool inbSave )
{
	if(m_pNewImage) delete m_pNewImage;
	m_pNewImage = NULL;

	DWORD dwFilter=D3DX_FILTER_TRIANGLE;

	if(m_Props.m_bMipMirror) dwFilter|=D3DX_FILTER_MIRROR;

	if(m_Props.m_bMipmaps || m_Props.m_dwReduceResolution)					// generate mipmaps
	{
		// with mipmaps
		LPDIRECT3DBASETEXTURE9 pSrc=CreateUncompressedMipMaps(dwFilter,m_Props.m_dwReduceResolution,!m_Props.m_bMipmaps);

		assert(pSrc);

		if(pSrc)
		{
			if(!Compress(pSrc,g_pixelformats[m_Props.m_iDestPixelFormat].DxtNo,dwFilter))
				{	ReleasePpo(&pSrc);return(false); }
		}

		ReleasePpo(&pSrc);
	}
	else
	{
		// without downsampling
		if(!Compress(m_ptexOrig,g_pixelformats[m_Props.m_iDestPixelFormat].DxtNo,dwFilter))
			return(false);
	}


	if(inbSave)
	{
		CString outputFile = m_pCC->getOutputPath();
		if(Save(outputFile))
		{
			CCLOG->Log("CImageCompiler::Process save '%s'",(const char*)outputFile );
		}
		else
		{
			CCLOG->LogError("CImageCompiler::Process load '%s' failed",(const char*)outputFile );
			return(false);
		}
	}

	return(true);
}



int CImageCompiler::GetNoFromName( const char *inszName )
{
	int iCount=GetPixelFormatCount();

	for(int i=0;i<iCount;i++)
		if(stricmp(g_pixelformats[i].szName,inszName)==0)
			return(i);

	return(-1);
}



int CImageCompiler::GetNoFromD3DFormat( D3DFORMAT inFormat )
{
	int iCount=GetPixelFormatCount();

	for(int i=0;i<iCount;i++)
		if(g_pixelformats[i].DxtNo==inFormat)
			return(i);

	return(-1);
}


char *CImageCompiler::GetPixelFormatName( const int iniNo )
{
	assert(iniNo>=0);
	assert(iniNo<GetPixelFormatCount());

	return(g_pixelformats[iniNo].szName);
}


int CImageCompiler::GetPixelFormatUncompressed( const int iniNo )
{
	assert(iniNo>=0);
	assert(iniNo<GetPixelFormatCount());

	int iRet=GetNoFromName(g_pixelformats[iniNo].szUncompressedAltName);

	assert(iRet!=-1);			// szUncompressedAltName must be in szName

	return(iRet);
}


int CImageCompiler::GetPixelFormatCount( void )
{
	return(sizeof(g_pixelformats)/sizeof(SPixelFormats));
}


char *CImageCompiler::GetPixelFormatDesc( const int iniNo )
{
	assert(iniNo>=0);
	assert(iniNo<GetPixelFormatCount());

	return(g_pixelformats[iniNo].szDescription);
}


CString CImageCompiler::GetInfoString( const bool inbOrig )
{
	int iNo=inbOrig?m_iOrigPixelFormatNo:m_Props.m_iDestPixelFormat;

	char str[256];

	int iMem=CalcTextureMemory(inbOrig);

	if(inbOrig)
		sprintf(str,"W:%d  H:%d  Alpha:%s\nMem:%.1fkB",m_dwOrigWidth,m_dwOrigHeight,g_pixelformats[iNo].szAlpha,iMem/1024.0f);
	else 
	{
		DWORD dwW=max(m_dwOrigWidth>>m_Props.m_dwReduceResolution,1);
		DWORD dwH=max(m_dwOrigHeight>>m_Props.m_dwReduceResolution,1);
		DWORD dwNumMips=max((int)_CalcMipCount(m_dwOrigWidth,m_dwOrigHeight)-(int)m_Props.m_dwReduceResolution,1);
		if(!m_Props.m_bMipmaps)dwNumMips=1;

		sprintf(str,"W:%d  H:%d  Alpha:%s  Mips:%d\nMem:%.1fkB",dwW,dwH,g_pixelformats[iNo].szAlpha,dwNumMips,iMem/1024.0f);
	}

	return(str);
}


DWORD CImageCompiler::CalcTextureMemory( const bool inbOrig ) const
{
	int iSum=0;
	DWORD iW=m_dwOrigWidth;
	DWORD iH=m_dwOrigHeight;
	int iNo=inbOrig?m_iOrigPixelFormatNo:m_Props.m_iDestPixelFormat;
	int iBpp=g_pixelformats[iNo].iBitsPerPixel;
	int iMipmaps=1;
	
	if(!inbOrig && m_Props.m_bMipmaps)iMipmaps=_CalcMipCount(m_dwOrigWidth,m_dwOrigHeight);

	int iIgnoreTopMips=0;
	
	if(!inbOrig)iIgnoreTopMips=(int)m_Props.m_dwReduceResolution;

	for(int i=0;i<iMipmaps;i++)
	{
		if(iIgnoreTopMips)iIgnoreTopMips--;
		else
		{
			if(g_pixelformats[iNo].bCompressed)
			{
				iSum+=max(1,iW/4) * max(1,iH/4) * iBpp;			// from DX SDK:  max(1,width ÷ 4)x max(1,height ÷ 4)x 8 (DXT1) or 16 (DXT2-5)
			}
			else
			{
				iSum+=(iW*iH*iBpp)/8;
			}
		}

		iW=(iW+1)/2; iH=(iH+1)/2;
	}

	return(iSum);
}






bool CImageCompiler::GetOutputFile( ConvertContext& cc )
{
	//specify output path
	cc.outputFile = Path::ReplaceExtension( cc.sourceFile,"dds" );
	return true;
}


int CImageCompiler::GetNumPlatforms() const
{
	return(4);
}


Platform CImageCompiler::GetPlatform( int index ) const
{
	switch (index)
	{
		case 0:	return PLATFORM_PC;
		case 1:	return PLATFORM_XBOX;
			//case 2:	return PLATFORM_PS2;
			//case 3:	return PLATFORM_GAMECUBE;
	};
	//assert(0);
	return PLATFORM_UNKNOWN;
}


int CImageCompiler::GetNumExt() const
{
	return(6);
}


const char* CImageCompiler::GetExt( int index ) const
{
	switch (index)
	{
		// DirectX supports bmp dds dib jpg png tga
		case 0:	return("bmp");
		case 1:	return("dds");
		case 2:	return("dib");
		case 3:	return("jpg");
		case 4:	return("png");
		case 5:	return("tga");
	};

	//assert(0);
	return(0);
}


// this should retrieve the timestamp of the convertor executable:
// when it was created by the linker, normally. This date/time is used to
// compare with the compiled file date/time and even if the compiled file
// is not older than the source file, it will be recompiled if it's older than the
// convertor
DWORD CImageCompiler::GetTimestamp() const
{
	return GetTimestampForLoadedLibrary(g_hInst);
}



struct my_vertex
{
    FLOAT x, y, z,rhw;
    FLOAT u1, v1;
};

// Define corresponding FVF macro.
#define D3D8T_CUSTOMVERTEX ( D3DFVF_XYZRHW|D3DFVF_TEX1|D3DFVF_TEXCOORDSIZE2(0))


static void PrintInPreview( HWND inHWND, RECT &inRect, const char *inszTxt1, const char *inszTxt2=0 )
{
	HDC hdc=GetDC(inHWND);
	FillRect(hdc,&inRect,GetSysColorBrush(COLOR_3DFACE));
	SetBkMode(hdc,TRANSPARENT);
	SetTextAlign(hdc,TA_CENTER);
	ExtTextOut(hdc,(inRect.left+inRect.right)/2,(inRect.top+inRect.bottom)/2-8,ETO_CLIPPED,&inRect,inszTxt1,(int)strlen(inszTxt1),0);
	if(inszTxt2)ExtTextOut(hdc,(inRect.left+inRect.right)/2,(inRect.top+inRect.bottom)/2+8,ETO_CLIPPED,&inRect,inszTxt2,(int)strlen(inszTxt2),0);
	ReleaseDC(inHWND,hdc);
}



bool CImageCompiler::BlitTo( HWND inHWND, RECT &inRect, const float infOffsetX, const float infOffsetY, const int iniScale16, const bool inbOrig )
{
	HRESULT hr;
	IDirect3DTexture9 *pTexture=0;

	if(!IsPowerOfTwo(m_dwOrigWidth) || !IsPowerOfTwo(m_dwOrigHeight))
	{
		char str[256];

		sprintf(str,"(%dx%d)",m_dwOrigWidth,m_dwOrigHeight);
		PrintInPreview(inHWND,inRect,"Image size is not power of two",str);
		return(true);
	}

	// check if P8 format which DX can't render, and convert to XRGB
	if(g_pixelformats[m_Props.m_iDestPixelFormat].DxtNo==D3DFMT_P8 && !inbOrig)
	{	
		assert(m_pNewImage);

		if(!m_pNewImage)
		{
			PrintInPreview(inHWND,inRect,"Conversion failed","(format not supported by driver?)");
			return(true);
		}

		pTexture = m_pNewImage->CopyToXRGB(m_pd3ddev);	
	}
	else
	{
		// error message is neccessary
		if(inbOrig)
		{
			if(!m_ptexOrig)
			{
				PrintInPreview(inHWND,inRect,"Load failed","(format not supported by driver?)");
				return(true);
			}
		}
		else
		{
			if(m_pNewImage==0 || m_pNewImage->GetDXTex()==0)
			{
				PrintInPreview(inHWND,inRect,"Conversion failed","(format not supported by driver?)");
				return(true);
			}
		}
		// convert to blitable format
		IDirect3DBaseTexture9 *pBaseTexture = inbOrig ? m_ptexOrig : m_pNewImage->GetDXTex();
		
		assert(pBaseTexture);			// this was checked earlier

		ImageObject *pimgNew = NULL;

		if(m_Props.m_bPreviewAlpha)		// preview alpha
		{
			// convert to format with alpha
			if(FAILED(hr = ChangeFormat(pBaseTexture,D3DFMT_A8R8G8B8,pimgNew,D3DX_FILTER_NONE,0)))
				return(false);

			pimgNew->GetDXTexI(pTexture);

			assert(pTexture);

			// for all mipmaps
			for(unsigned int mip = 0; mip<pTexture->GetLevelCount(); mip++)
			{
				IDirect3DSurface9 *pSurfaceLevel=0;

				// convert alpha to gray
				if(pTexture->GetSurfaceLevel(mip,&pSurfaceLevel)==D3D_OK)
				{	
					CopyAlphaToRGB(pSurfaceLevel);

					pSurfaceLevel->Release();pSurfaceLevel=0;
				}
			};

			ReleasePpo(&pTexture);

			// convert to blitable format
			if(FAILED(hr = ChangeFormat(pimgNew->GetDXTex(),D3DFMT_X8R8G8B8,pimgNew,D3DX_FILTER_NONE,0)))
				return(false);

			pimgNew->GetDXTexI(pTexture);
		}
		else
		{
			if(FAILED(hr = ChangeFormat(pBaseTexture,D3DFMT_X8R8G8B8,pimgNew,D3DX_FILTER_NONE,0)))
				return(false);

			if(pimgNew) pimgNew->GetDXTexI(pTexture);
		}

		if(pimgNew) delete pimgNew;
	}

	if(!pTexture)
		return(false);

	int iWidth=inRect.right-inRect.left,iHeight=inRect.bottom-inRect.top;

	int iW=((iWidth)*16)/iniScale16;	
	int iH=((iHeight)*16)/iniScale16;

	int iX=(int)(infOffsetX*GetWidth()*1.0f);
	int iY=(int)(infOffsetY*GetHeight()*1.0f);

	m_pd3ddev->BeginScene();

//	m_pd3ddev->Clear(0,0,D3DCLEAR_TARGET,0xff0000,0.0f,0);

	hr=m_pd3ddev->SetTexture(0,pTexture);

	if (FAILED(hr))
	{
		CCLOG->LogError("SetTexture failed");
		return false;
	}


	if(m_Props.m_bPreviewFiltered)
	{
		m_pd3ddev->SetSamplerState(0,D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
		m_pd3ddev->SetSamplerState(0,D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
	}
	else
	{
		m_pd3ddev->SetSamplerState(0,D3DSAMP_MAGFILTER,D3DTEXF_POINT);
		m_pd3ddev->SetSamplerState(0,D3DSAMP_MINFILTER,D3DTEXF_POINT);
	}



	m_pd3ddev->SetSamplerState(0,D3DSAMP_MIPFILTER,D3DTEXF_POINT);

	m_pd3ddev->SetSamplerState(0,D3DSAMP_MIPFILTER,D3DTADDRESS_BORDER);

	if(m_Props.m_bPreviewTiled)
	{
		m_pd3ddev->SetSamplerState(0, D3DSAMP_ADDRESSU,	D3DTADDRESS_WRAP);
		m_pd3ddev->SetSamplerState(0, D3DSAMP_ADDRESSV,	D3DTADDRESS_WRAP);
	}
	else
	{
		m_pd3ddev->SetSamplerState(0, D3DSAMP_ADDRESSU,	D3DTADDRESS_BORDER);
		m_pd3ddev->SetSamplerState(0, D3DSAMP_ADDRESSV,	D3DTADDRESS_BORDER);
	}



	// Rendering of scene objects happens here.

	m_pd3ddev->SetVertexShader(NULL);
	m_pd3ddev->SetFVF( D3D8T_CUSTOMVERTEX );

	
	int iScaleX=(int)(iWidth*16.0f/iniScale16*0.5f);
	int iScaleY=(int)(iHeight*16.0f/iniScale16*0.5f);

	// Create vertex data with position and texture coordinates.
	my_vertex g_triangle_vertices[]=
	{
			//  x      y       z     rhw  u1  v1
			{ -0.5f,   -0.5f,   0.5f,  1,   (float)(-iScaleX+iX)/GetWidth(),  (float)(-iScaleY+iY)/GetHeight(), }, 
			{ 255.5f, -0.5f,   0.5f,  1,   (float)(iScaleX+iX)/GetWidth(),   (float)(-iScaleY+iY)/GetHeight(), }, 
			{ 255.5f, 255.5f, 0.5f,  1,   (float)(iScaleX+iX)/GetWidth(),   (float)(iScaleY+iY)/GetHeight(), }, 
			{ -0.5f,   255.5f, 0.5f,  1,   (float)(-iScaleX+iX)/GetWidth(),  (float)(iScaleY+iY)/GetHeight(), }, 
	};



	m_pd3ddev->DrawPrimitiveUP( D3DPT_TRIANGLEFAN, 2, g_triangle_vertices, sizeof(my_vertex));
	m_pd3ddev->SetTexture(0,0);

// End the scene.
	m_pd3ddev->EndScene();

	hr = m_pd3ddev->Present( NULL, &inRect, inHWND, 0 );

	if (FAILED(hr))
	{
		//check if device was lost
		if (hr == D3DERR_DEVICELOST)
		{
			CCLOG->LogError("Device Lost");

			m_pd3ddev->Reset(&m_presentParams);
		}
	}


/*
		for(int y=0;y<iHeight;y++)
		for(int x=0;x<iWidth;x++)
		{
			SetPixel(inHdc,inRect.left+x,inRect.top+y,  GetPixel(dc,x*(iW)/iWidth+iX-iW/2,y*(iH)/iHeight+iY-iH/2)  );
		}
*/
//		BOOL ok=StretchBlt(inHdc,	inRect.left,inRect.top,iWidth,iHeight,
//											 dc,		iX-iW,iY-iH,						 iW*2,iH*2,  SRCCOPY);
//		assert(ok);

//		pSurfaceLevel->ReleaseDC(dc);

//	}

	ReleasePpo(&pTexture);
	return(true);
}


bool CImageCompiler::ClampBlitOffset( const int iniWidth, const int iniHeight, float &inoutfX, float &inoutfY, const int iniScale16 ) const
{
	bool bRet=true;

	if( iniWidth >= (int)(m_dwOrigWidth*iniScale16)/16 ) inoutfX=0.5f;
	else
	{
		float fXMin=(float)((iniWidth*16)/iniScale16)/(float)m_dwOrigWidth*0.5f;
		float fXMax=1.0f-fXMin;

		if(inoutfX<fXMin)inoutfX=fXMin;
		if(inoutfX>fXMax)inoutfX=fXMax;

		bRet=false;
	}

	if( iniHeight >= (int)(m_dwOrigHeight*iniScale16)/16 ) inoutfY=0.5f;
	else
	{
		float fYMin=(float)((iniHeight*16)/iniScale16)/(float)m_dwOrigHeight*0.5f;
		float fYMax=1.0f-fYMin;

		if(inoutfY<fYMin)inoutfY=fYMin;
		if(inoutfY>fYMax)inoutfY=fYMax;

		bRet=false;
	}

	return(bRet);
}




DWORD CImageCompiler::GetWidth( void ) const
{
	return(m_dwOrigWidth);
}


DWORD CImageCompiler::GetHeight( void ) const
{
	return(m_dwOrigHeight);
}







bool CImageCompiler::CopyAlphaToRGB( LPDIRECT3DSURFACE9 psurf ) const
{
  HRESULT hr;
  D3DSURFACE_DESC sd;
  LPDIRECT3DSURFACE9 psurfTarget;

  hr=psurf->GetDesc(&sd);
	assert(hr==D3D_OK);

  // Copy the target surface into an A8R8G8B8 surface
  hr = m_pd3ddev->CreateOffscreenPlainSurface(sd.Width, sd.Height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &psurfTarget, NULL);
	assert(hr==D3D_OK);
  hr = D3DXLoadSurfaceFromSurface(psurfTarget, NULL, NULL, psurf, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
	assert(hr==D3D_OK);

  D3DLOCKED_RECT lrDest;

  hr = psurfTarget->LockRect(&lrDest, NULL, 0);
	assert(hr==D3D_OK);

  DWORD xp;
  DWORD yp;
	DWORD* pdwRow = (DWORD*)lrDest.pBits;
  DWORD* pdwPtr;
  LONG dataBytesPerRow = 4 * sd.Width;

  for (yp = 0; yp < sd.Height; yp++)
  {
      pdwPtr = pdwRow;
      for (xp = 0; xp < sd.Width; xp++)
      {
				  DWORD dwAlpha= (*pdwPtr) >> 24;
			
					*pdwPtr = dwAlpha | (dwAlpha<<8) | (dwAlpha<<16);

          pdwPtr++;
      }
      pdwRow += lrDest.Pitch / 4;
  }

  psurfTarget->UnlockRect();

  // Copy psurfTarget back into real surface
  hr = D3DXLoadSurfaceFromSurface(psurf, NULL, NULL, psurfTarget, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  assert(hr==D3D_OK);

  // Release allocated interfaces
  ReleasePpo(&psurfTarget);

  return S_OK;
}

bool CImageCompiler::IsPowerOfTwo( const DWORD indwValue )
{
	return((indwValue&(indwValue-1)) == 0);
}

// set the stored properties to the current file and save it
bool CImageCompiler::LoadConfigFile( void )
{
	assert(m_pCC);

	CString sPixelformat="UNKNOWN";						

	// pixelformat
	if(m_pCC->config->Get("pixelformat",sPixelformat))
	{
		int iNo=GetNoFromName(sPixelformat.GetBuffer());	

		if(iNo==-1)
		{ 
			CCLOG->LogError("CImageCompiler::Process pixelformat '%s' not recognized",sPixelformat.GetBuffer());
			return(false); 
		}

		m_Props.m_iDestPixelFormat=iNo;

		CCLOG->Log("CImageCompiler::pixelformat='%s'",sPixelformat.GetBuffer());
	}

	// ---------------------------

	m_Props.m_bMipmaps=GetBoolParam("mipmaps",true);
	m_Props.m_bMipMirror=GetBoolParam("mipmirror",true);
	m_Props.m_bUserDialog=GetBoolParam("userdialog",true);
	m_Props.m_dwReduceResolution=max(GetIntParam("reduce",0),0);
	m_Props.m_dwDitherMode=max(GetIntParam("dither",0),0);
	
	if(!m_pCC->config->Get("preset",m_Props.m_sPreset)) m_Props.m_sPreset = "";

	return(true);
} 


void CImageCompiler::SetPresetSettings()
{
	if(m_Props.m_sPreset=="") return;
	m_pCC->config->Set("preset", m_Props.m_sPreset);
	m_pCC->presets->SetConfig(m_Props.m_sPreset, m_pCC->config);
	LoadConfigFile();
};


// set the stored properties to the current file and save it
bool CImageCompiler::UpdateAndSaveConfigFile( void )
{
	m_pCC->pFileSpecificConfig->UpdateOrCreateEntry("","preset",m_Props.m_sPreset);
	// bools

	m_pCC->pFileSpecificConfig->UpdateOrCreateEntry("","pixelformat",g_pixelformats[m_Props.m_iDestPixelFormat].szName);
	m_pCC->pFileSpecificConfig->UpdateOrCreateEntry("","mipmaps",m_Props.m_bMipmaps?"1":"0");
	m_pCC->pFileSpecificConfig->UpdateOrCreateEntry("","mipmirror",m_Props.m_bMipMirror?"1":"0");
	m_pCC->pFileSpecificConfig->UpdateOrCreateEntry("","userdialog",m_Props.m_bUserDialog?"1":"0");

	// DWORDs
	char str[256];

	sprintf(str,"%d",m_Props.m_dwReduceResolution);
	m_pCC->pFileSpecificConfig->UpdateOrCreateEntry("","reduce",str);

	sprintf(str,"%d",m_Props.m_dwDitherMode);
	m_pCC->pFileSpecificConfig->UpdateOrCreateEntry("","dither",str);

	return(m_pCC->pFileSpecificConfig->Save());
}