Direct x 9 Textur rund rendern

BOOL C2DRender::RenderTextureAlphaMask( CPoint pt, CTexture* pTexture, CTexture* pTexture2, DWORD dwBlendFactorAlhpa, FLOAT fScaleX , FLOAT fScaleY )
{
	if( !pTexture )			//gmpbigsun
		return FALSE;
	if( !pTexture2 )
		return FALSE;

	pt += m_ptOrigin;
	CPoint ptCenter = pTexture->m_ptCenter;
	ptCenter.x	= (LONG)( ptCenter.x * fScaleX );
	ptCenter.y	= (LONG)( ptCenter.y * fScaleY );
	pt -= ptCenter;

	FLOAT left   = (FLOAT)( pt.x );
	FLOAT top    = (FLOAT)( pt.y );
	FLOAT right  = pt.x + ( fScaleX * pTexture->m_size.cx );
	FLOAT bottom = pt.y + ( fScaleY * pTexture->m_size.cy );
	

TEXTUREVERTEX vertex[ 4 ];
	TEXTUREVERTEX* pVertices = vertex; 
	
	SetTextureVertex( pVertices, left, top, pTexture->m_fuLT, pTexture->m_fvLT );
	pVertices++;
	SetTextureVertex( pVertices, right, top, pTexture->m_fuRT, pTexture->m_fvRT);
	pVertices++;
	SetTextureVertex( pVertices, left, bottom, pTexture->m_fuLB, pTexture->m_fvLB);
	pVertices++;
	SetTextureVertex( pVertices, right, bottom, pTexture->m_fuRB, pTexture->m_fvRB);
	pVertices++;



	m_pd3dDevice->SetTexture( 0, pTexture->m_pTexture );
	m_pd3dDevice->SetTexture( 1, pTexture2->m_pTexture );

m_pd3dDevice->SetRenderState(D3DRS_STENCILENABLE,TRUE);
m_pd3dDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
m_pd3dDevice->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
m_pd3dDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
m_pd3dDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
m_pd3dDevice->SetRenderState(D3DRS_STENCILREF, 0x1);
m_pd3dDevice->SetRenderState(D3DRS_STENCILMASK, 0xff000000);
m_pd3dDevice->SetRenderState(D3DRS_STENCILWRITEMASK, 0xff000000);

 

	m_pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, vertex, sizeof( TEXTUREVERTEX ) );
	m_pd3dDevice->SetTexture( 0, NULL );
	m_pd3dDevice->SetTexture( 1, NULL );
	return TRUE;
	/////


};

// Kapitel 2
// Beispielprogramm 13
// ===================
// Hier wird der Stencil-Buffer verwendet, um den Overdraw jedes Pixels darzustellen.

#include <Windows.h>
#include <TriBase.h>
#include "..\\..\\Allgemeines\\InitWindow.h"
#include "..\\..\\Allgemeines\\Direct3DEnum.h"
#include "..\\..\\Allgemeines\\InitDirect3D.h"
#include "Resource.h"

// ******************************************************************
// Struktur für einen Vertex: Position und Farbe
struct SVertex
{
	tbVector3			vPosition;	// Position des Vertex
	DWORD				dwColor;	// Farbe des Vertex
	static const DWORD	dwFVF;		// Vertexformat
};

const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;

// ******************************************************************
// Globale Variablen
float				g_fTime = 0.0f;			// Zeitzähler
SDirect3DParameters	g_Direct3DParameters;	// Direct3D-Parameter
LPD3DXMESH			g_pThing = NULL;		// Das Modell

// ******************************************************************
// Render-Funktion
tbResult Render(float fNumSecsPassed)
{
	HRESULT		hResult;
	tbMatrix	mWorld;
	SVertex		aVertex[4];


	// Nur den Stencil-Buffer leeren.
	// Der Z-Buffer wird nicht gebraucht und der Bildpuffer wird
	// sowieso von den Rechtecken gefüllt.
	if(FAILED(hResult = g_pD3DDevice->Clear(0,
							                NULL,
									        D3DCLEAR_STENCIL,
									        D3DCOLOR_XRGB(0, 0, 0),
									        1.0f,
									        0)))
	{
		// Fehler beim Leeren!
		TB_ERROR_DIRECTX("g_pD3DDevice->Clear", hResult, TB_STOP);
	}

	// Szene beginnen
	g_pD3DDevice->BeginScene();

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

	// Als erstes zeichnen wir die drei sich drehenden Objekte.
	// Dabei soll jeder Pixel den Stencil-Wert an dieser Stelle um eins erhöhen,
	// außerdem soll nichts davon auf den Bildschirm gelangen.
	// Damit auch wirklich alle Dreiecke gezeichnet werden, schalten wir Culling ab.
	// Der Z-Buffer wird so eingestellt, dass kein Pixel den Test besteht.
	// D3DRS_STENCILZFAIL ist dafür der richtige Fall. Dieses Render-State setzen
	// wir auf den Wert D3DSTENCILOP_INCRSAT, damit die Pixel, die den Z-Test
	// nicht bestanden haben (also alle) den Stencil-Wert um eins erhöhen.
	// Den Stencil-Test stellen wir so ein, dass ihn alle Pixel bestehen.
	g_pD3DDevice->SetRenderState(D3DRS_STENCILENABLE,	TRUE);
	g_pD3DDevice->SetRenderState(D3DRS_STENCILFUNC,		D3DCMP_ALWAYS);
	g_pD3DDevice->SetRenderState(D3DRS_STENCILZFAIL,	D3DSTENCILOP_INCRSAT);
	g_pD3DDevice->SetRenderState(D3DRS_CULLMODE,		D3DCULL_NONE);
	g_pD3DDevice->SetRenderState(D3DRS_ZFUNC,			D3DCMP_NEVER);

	// Nun die drei Objekte zeichnen. Nichts davon wird sichtbar - sie hinterlassen
	// ihre Spuren nur im Stencil-Buffer und die machen wir später dann erkennbar.
	mWorld = tbMatrixRotation(g_fTime, g_fTime * 0.5f, g_fTime * 0.25f) *
		     tbMatrixTranslation(tbVector3(0.0f, 0.0f, 3.0f));
	g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));
	g_pThing->DrawSubset(0);

	mWorld = tbMatrixRotation(g_fTime * 0.9f, g_fTime * 0.6f, g_fTime * 0.3f) *
		     tbMatrixTranslation(tbVector3(-3.0f, 0.0f, 5.0f));
	g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));
	g_pThing->DrawSubset(0);

	mWorld = tbMatrixRotation(g_fTime * 1.1f, g_fTime * 0.4f, g_fTime * 0.35f) *
		     tbMatrixTranslation(tbVector3(3.0f, 0.0f, 5.0f));
	g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));
	g_pThing->DrawSubset(0);

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

	// Nun zeichnen wir eine Reihe von Rechtecken, die sich über das gesamte
	// Bild erstrecken. Das erste Rechteck wird nur dort gezeichnet, wo der
	// Stencil-Wert eins ist, das zweite nur da, wo er zwei ist und so weiter.
	// Jedes Rechteck bekommt eine andere Farbe. Dort, wo mehr Overdraw ist,
	// wird die Farbe stärker rötlich.

	// Vertexformat setzen und den Z-Buffer so einstellen, dass das Rechteck
	// auch sichtbar wird
	g_pD3DDevice->SetFVF(SVertex::dwFVF);
	g_pD3DDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);

	// Die Weltmatrix zurücksetzen
	g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&tbMatrixIdentity()));

	// Rechteckkoordinaten generieren
	aVertex[0].vPosition = tbVector3(-100.0f, -100.0f, 1.0f);
	aVertex[1].vPosition = tbVector3(-100.0f,  100.0f, 1.0f);
	aVertex[2].vPosition = tbVector3( 100.0f, -100.0f, 1.0f);
	aVertex[3].vPosition = tbVector3( 100.0f,  100.0f, 1.0f);

	// Für jedes Rechteck...
	for(int iRect = 0; iRect < 10; iRect++)
	{
		// Stencil-Buffer-Einstellungen vornehmen.
		// Das letzte Rechteck soll auch bei denjenigen Pixeln gezeichnet werden,
		// bei denen der Overdraw größer als die 15 ist.
		if(iRect != 9) g_pD3DDevice->SetRenderState(D3DRS_STENCILFUNC,	D3DCMP_EQUAL);
		else g_pD3DDevice->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_LESSEQUAL);

		// Der Referenzwert entspricht der Nummer des Rechtecks.
		g_pD3DDevice->SetRenderState(D3DRS_STENCILREF, iRect);

		// Die Vertexfarben einstellen. Je höher iRect, desto roter.
		aVertex[0].dwColor = aVertex[1].dwColor = aVertex[2].dwColor = aVertex[3].dwColor
			= tbColor((float)(iRect) / 9.0f, 1.0f - (float)(iRect) / 9.0f, 0.0f);

		// Das Rechteck zeichnen
		g_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, aVertex, sizeof(SVertex));
	}

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

	// Szene beenden
	g_pD3DDevice->EndScene();

	// Der große Moment: den Bildpuffer sichtbar machen
	g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

	return TB_OK;
}

// ******************************************************************
// Move-Funktion
tbResult Move(float fNumSecsPassed)
{
	// Zeitzähler erhöhen
	g_fTime += fNumSecsPassed;

	return TB_OK;
}

// ******************************************************************
// Herunterfahren der Szene
tbResult ExitScene()
{
	// Das Modell löschen
	TB_SAFE_RELEASE(g_pThing);

	return TB_OK;
}

// ******************************************************************
// Herunterfahren der Anwendung
tbResult ExitApplication()
{
	// Szene herunterfahren
	ExitScene();

	// Direct3D und Fenster herunterfahren
	ExitDirect3D();
	ExitWindow();

	// Engine herunterfahren
	tbExit();

	return TB_OK;
}

// ******************************************************************
// Initialisieren der Szene
tbResult InitScene()
{
	HRESULT		hResult;
	tbMatrix	mProjection;
	float		fAspect;


	// Dithering aktivieren, Beleuchtung ausschalten
	g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);
	g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

	// Das Bildseitenverhältnis berechnen
	fAspect =   (float)(g_Direct3DParameters.VideoMode.Width)
	          / (float)(g_Direct3DParameters.VideoMode.Height);

	// Die Projektionsmatrix erzeugen
	mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f),	// Sichtfeld: 90°
					                 fAspect,				// Bildseitenverhältnis
					                 0.1f,					// Nahe Clipping-Ebene
					                 100.0f);				// Ferne Clipping-Ebene

	// Projektionsmatrix einsetzen
	g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));

	// Das Modell laden
	if(FAILED(hResult = D3DXLoadMeshFromX("Thing.x",
		                                  D3DXMESH_MANAGED,
										  g_pD3DDevice,
										  NULL,
										  NULL,
										  NULL,
										  NULL,
										  &g_pThing)))
	{
		// Fehler!
		TB_ERROR_DIRECTX("D3DXLoadMeshFromX", hResult, TB_ERROR);
	}

	return TB_OK;
}

// ******************************************************************
// Initialisierungsfunktion
tbResult InitApplication()
{
	tbResult Result;

	// TriBase-Engine initialisieren
	tbInit();

	// Direct3D-Optionen abfragen (vom Benutzer gewählt)
	Result = GetDirect3DParameters(&g_Direct3DParameters);
	if(Result == TB_ERROR)
	{
		// Es trat ein Fehler auf!
		MessageBox(NULL, "Fehler beim Abzählen!", "Fehler",
			       MB_OK | MB_ICONEXCLAMATION);
		return TB_ERROR;
	}
	else if(Result == TB_CANCELED)
	{
		// Der Dialog wurde abgebrochen!
		return TB_CANCELED;
	}

	// Dieses Programm benötigt einen Stencil-Buffer. Wenn das vom Benutzer
	// gewählte Format keinen Platz dafür bietet, bricht das Programm ab.
	if(g_Direct3DParameters.ZStencilBufferFormat != D3DFMT_D24S8 &&
	   g_Direct3DParameters.ZStencilBufferFormat != D3DFMT_D24X4S4)
	{
		MessageBox(NULL, "Das von Ihnen gewählte Z-Stencil-Buffer-Format bietet keinen oder nicht genug Platz für die Stencil-Werte!",
			       "Fehler", MB_OK | MB_ICONINFORMATION);
		return TB_CANCELED;
	}

	// Fenster initialisieren. Die Größe hängt vom gewählten
	// Videomodus ab, der in der Parameterstruktur gespeichert ist.
	if(InitWindow(g_Direct3DParameters.VideoMode.Width,
		          g_Direct3DParameters.VideoMode.Height,
				  "Beispielprogramm Nr. 13: Der Stencil-Buffer",
				  LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1))))
	{
		// Fehler beim Erstellen des Fensters!
		MessageBox(NULL, "Fehler beim Erstellen des Fensters!",
			       "Fehler", MB_OK | MB_ICONEXCLAMATION);
		return TB_ERROR;
	}

	// Direct3D mit den abgefragten Einstellungen initialisieren
	if(InitDirect3D(&g_Direct3DParameters,
		            g_hWindow))
	{
		// Fehler!
		MessageBox(g_hWindow, "Fehler beim Initialisieren von Direct3D!",
			       "Fehler", MB_OK | MB_ICONEXCLAMATION);
		ExitApplication();
		return TB_ERROR;
	}

	// Szene initialisieren
	if(InitScene())
	{
		// Fehler!
		MessageBox(g_hWindow, "Fehler beim Initialisieren der Szene!",
			       "Fehler", MB_OK | MB_ICONINFORMATION);
		ExitApplication();
		return TB_ERROR;
	}

	// Alles OK!
	return TB_OK;
}

// ******************************************************************
// Windows-Hauptfunktion
int WINAPI WinMain(HINSTANCE hInstance,
				   HINSTANCE hPrevInstance,
				   char* pcCmdLine,
				   int iShowCmd)
{
	tbResult Result;

	// Initialisierung
	Result = InitApplication();
	if(Result == TB_CANCELED) return 0;
	else if(Result)
	{
		MessageBox(NULL, "Fehler beim Initialisieren der Anwendung!",
			       "Fehler", MB_OK | MB_ICONEXCLAMATION);
		return 1;
	}

	// Nachrichtenschleife
	tbDoMessageLoop(Render, Move);

	// Herunterfahren
	ExitApplication();

	return 0;
}

// ******************************************************************

		u = x / (sqrt((double) ((int)x^(int)2 + (int)y^(int)2 )));
		v = y / (sqrt((double) ((int)x^(int)2 + (int)y^(int)2 )));