sprite

#include <windows.h>
#include <windowsx.h>
#include <d3d10.h>
#include <d3dx10.h>
#include <DXGI.h>

#pragma comment (lib, "d3d10.lib")
#pragma comment (lib, "d3dx10.lib")
#pragma comment (lib, "DXGI.lib")


ID3D10Device* d3ddev = NULL;
IDXGISwapChain* swChain;
ID3D10RenderTargetView* renderTargetView;

 HWND hWnd;
D3D10_VIEWPORT viewPort;
ID3D10Texture2D *texture;
D3DX10_SPRITE testSprite;
D3D10_TEXTURE2D_DESC desc;
D3D10_SHADER_RESOURCE_VIEW_DESC SRVdesc;
ID3D10ShaderResourceView *spriteRV;
ID3DX10Sprite *ObjSprite;
D3DXMATRIX matProjection, matTranslation, matScalation;


void loadresource(void);	
void initD3D(HWND hWnd);    
void render_frame(void);    
void cleanD3D(void);     


LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);



int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
    
    WNDCLASSEX wc;

    ZeroMemory(&wc, sizeof(WNDCLASSEX));

    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszClassName = "WindowClass";

    RegisterClassEx(&wc);

	RECT r={0,0,800,600};
	AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
    hWnd = CreateWindowEx(NULL,
                          "WindowClass",
				          "Direct3D 10",
                          WS_OVERLAPPEDWINDOW,
                          150, 150,
                          800, 600,
                          NULL,
                          NULL,
                          hInstance,
                          NULL);

    ShowWindow(hWnd, nCmdShow);


    initD3D(hWnd);



    MSG msg;

    while(TRUE)
    {
        while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        if(msg.message == WM_QUIT)
            break;

        render_frame();
    }

   
    cleanD3D();

    return msg.wParam;
}


LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_DESTROY:
            {
                PostQuitMessage(0);
                return 0;
            } break;
    }

    return DefWindowProc (hWnd, message, wParam, lParam);
}


void initD3D(HWND hWnd)
{
	DXGI_SWAP_CHAIN_DESC swChainDesc;
	
	
	ZeroMemory(&swChainDesc, sizeof(swChainDesc));
	swChainDesc.BufferDesc.Height = 600;
	swChainDesc.BufferDesc.Width = 800;
	swChainDesc.BufferDesc.RefreshRate.Numerator = 60;
	swChainDesc.BufferDesc.RefreshRate.Denominator = 1;
	swChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
	swChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
	swChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
	swChainDesc.SampleDesc.Count = 1;
	swChainDesc.SampleDesc.Quality = 0;
	swChainDesc.OutputWindow = hWnd;
	swChainDesc.BufferCount = 1;
	swChainDesc.Windowed = TRUE;
	swChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
	swChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
	swChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_NONPREROTATED;
	swChainDesc.Flags = 0;

	D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &swChainDesc, &swChain, &d3ddev);

	ID3D10Texture2D *backBuffer;
	swChain->GetBuffer( 0, __uuidof( ID3D10Texture2D ), (LPVOID*)&backBuffer ); 
    HRESULT hr = d3ddev->CreateRenderTargetView( backBuffer, NULL, &renderTargetView );
	backBuffer->Release();

	d3ddev->OMSetRenderTargets(1, &renderTargetView,NULL);

	ZeroMemory(&viewPort,sizeof(viewPort));
	viewPort.Width = 800;
	viewPort.Height = 600;
	viewPort.MaxDepth = 1;
	viewPort.MinDepth = 0;
	viewPort.TopLeftX = 0;
	viewPort.TopLeftY = 0;
	d3ddev->RSSetViewports(1, &viewPort);


	loadresource();
}


void render_frame(void)
{
	D3DXMatrixOrthoOffCenterLH(&matProjection, (float)viewPort.TopLeftX,(float)viewPort.Width, (float)viewPort.TopLeftY, (float)viewPort.Height, 0.1f, 10);
	ObjSprite->SetProjectionTransform(&matProjection);
	D3DXMatrixTranslation(&matTranslation, 200.f,viewPort.Height - 200.f, 0.1f);
	D3DXMatrixScaling(&matScalation, 60,60,1.0f);
	testSprite.matWorld = (matTranslation*matScalation);

	d3ddev->ClearRenderTargetView(renderTargetView, D3DXCOLOR(0.0f,0.125f,0.6f,0.0f));
	
	ObjSprite->Begin(D3DX10_SPRITE_SORT_TEXTURE);
	//ObjSprite->DrawSpritesImmediate(&testSprite,1,0,0);
	ObjSprite->DrawSpritesBuffered(&testSprite,1);
	ObjSprite->Flush();
	ObjSprite->End();
	swChain->Present(0,0);
}


void cleanD3D(void)
{
	renderTargetView->Release();
	swChain->Release();
	ObjSprite->Release();
	d3ddev->Release();
}//*

void loadresource()
{
	ID3D10Resource* pRes;		
	HRESULT hr = D3DX10CreateTextureFromFile(d3ddev,"sprite.bmp", NULL, NULL, &pRes, NULL); 

	if(FAILED(hr))
	{
		MessageBox(hWnd, "Texture Load Failed","Message",MB_OK);
	}
	pRes->QueryInterface(__uuidof(ID3D10Texture2D), (LPVOID*)&texture);
	pRes->Release();

	texture->GetDesc(&desc); 
	ZeroMemory(&SRVdesc, sizeof(SRVdesc));
	
	SRVdesc.Format = desc.Format;
	SRVdesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
	SRVdesc.Texture2D.MipLevels = desc.MipLevels;

	d3ddev->CreateShaderResourceView(texture, &SRVdesc, &spriteRV);

	testSprite.pTexture = spriteRV;
	testSprite.TexCoord.x = 0;
	testSprite.TexCoord.y = 0;
	testSprite.TexSize.x = 1.0f;
	testSprite.TexSize.y = 1.0f;
	testSprite.TextureIndex=0;
	testSprite.ColorModulate=D3DXCOLOR(1.0f,1.0f,1.0f,1.0f);

	hr = D3DX10CreateSprite(d3ddev,0,&ObjSprite);
	if(FAILED(hr))
	{
		MessageBox(hWnd, "Create Sprite Failed","Message",MB_OK);
	}
}