Graphics

#if defined(UNICODE) && !defined(_UNICODE)
    #define _UNICODE
#elif defined(_UNICODE) && !defined(UNICODE)
    #define UNICODE
#endif

#include <tchar.h>
#include <windows.h>
#include <windowsx.h>
#include <d3d9.h>
#include <d3dx9.h>
#include "Resource.h"

#pragma comment (lib, "d3d9.lib")

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
BOOL CALLBACK Raumaktionproc (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
TCHAR szClassName[ ] = _T("CodeBlocksWindowsApp");

LPDIRECT3D9 d3d;
LPDIRECT3DDEVICE9 d3ddev;
LPDIRECT3DVERTEXBUFFER9 g_pVertexBuffer = NULL;
LPDIRECT3DTEXTURE9      g_pTexture      = NULL;

#define D3DFVF_CUSTOMVERTEX ( D3DFVF_XYZ | D3DFVF_TEX1 )

struct Vertex
{
    float x, y, z;
    float tu, tv;
};

Vertex g_quadVertices[] =
{
	{-1.0f, 1.0f, 0.0f,  0.0f,0.0f },
	{ 1.0f, 1.0f, 0.0f,  1.0f,0.0f },
	{-1.0f,-1.0f, 0.0f,  0.0f,1.0f },
	{ 1.0f,-1.0f, 0.0f,  1.0f,1.0f }
};
static HWND hwndRaumkarte;

void initD3D(HWND hwndRaumkarte);
void render_frame(void);
void cleanD3D(void);
void loadTexture(void);

#define ID_StartDialog 1


int WINAPI WinMain (HINSTANCE hThisInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR lpszArgument,
                     int nCmdShow)
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    memset(&messages,0,sizeof(messages));

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           _T("Code::Blocks Template Windows App"),       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           800,                 /* The programs width */
           600,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nCmdShow);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static HINSTANCE hInstance;

    switch (message)                  /* handle the messages */
    {
    case WM_CREATE:
        {


        CreateWindow(TEXT("button"),"Karte anzeigen",WS_CHILD|WS_VISIBLE,
                    20, 20, 200, 40, hwnd, (HMENU) ID_StartDialog, NULL,NULL);

        }
        break;
    case WM_COMMAND:
            //hMenu=GetMenu(hwnd);
            switch (LOWORD(wParam))
            {
            case ID_StartDialog:
        {


        DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1),hwnd, Raumaktionproc);
                    InvalidateRect(hwnd,NULL, TRUE);
        }
            }
        break;
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}


BOOL CALLBACK Raumaktionproc(HWND hDlg1, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    RECT rect;
    hdc=GetDC(hDlg1);
    hwndRaumkarte=GetDlgItem(hDlg1, ID_RAUMKARTE);

    switch (message)
    {


    case WM_INITDIALOG:
       {
        ShowWindow(GetDlgItem(hDlg1, IDD_DIALOG1), TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_OK),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_RAUMKARTE),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_VERTSCROLL),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_HORSCROLL),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_BASIS),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_FEUER),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_GEGNERAUSWAHL),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_KOM),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_FEUERBEENDEN),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_FEUERFLUCHT),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_LABWERFEN),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_LTAUSCHEN),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_MOBILINFO),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_NMOBIL),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_PLANET),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_SCAN),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_VMOBIL),TRUE);
        ShowWindow(GetDlgItem(hDlg1, ID_ZIELAUSWAHLLISTE),TRUE);

        EnableWindow(GetDlgItem(hDlg1, ID_GEGNERAUSWAHL),FALSE);
        EnableWindow(GetDlgItem(hDlg1, ID_FEUERBEENDEN),FALSE);
        EnableWindow(GetDlgItem(hDlg1, ID_FEUERFLUCHT),FALSE);
        initD3D(hwndRaumkarte);
        InvalidateRect(hDlg1, NULL, TRUE);
        return FALSE;
       };
    case WM_PAINT:
        {
            render_frame();

            //render_frame_Mobil(Mobilx, Mobily);


        }
        break;


    case WM_COMMAND:
        switch (LOWORD (wParam))
       {
           case ID_OK:
        {
                        MessageBox(hDlg1, TEXT ("Runde im All beendet"), "EXO 1.2", MB_ICONEXCLAMATION|MB_OK);
                        cleanD3D();
                        EndDialog(hDlg1,0);
                        return TRUE;
        }
       break;
        }
        break;

    }
    return FALSE;
    }

void loadTexture()
{
    D3DXCreateTextureFromFile( d3ddev, "Raumkarte.bmp", &g_pTexture );

	d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
}


void initD3D(HWND hwndRaumkarte)
{
    d3d=Direct3DCreate9(D3D_SDK_VERSION);


    D3DDISPLAYMODE d3ddm;

    d3d->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm );

    D3DPRESENT_PARAMETERS d3dpp;

    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed=TRUE;
    d3dpp.SwapEffect=D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow=hwndRaumkarte;
    d3dpp.BackBufferFormat       = d3ddm.Format;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
    d3dpp.PresentationInterval   = D3DPRESENT_INTERVAL_IMMEDIATE;

    d3d->CreateDevice(D3DADAPTER_DEFAULT,
                      D3DDEVTYPE_HAL,
                      hwndRaumkarte,
                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                      &d3dpp,
                      &d3ddev);

    loadTexture();

    d3ddev->CreateVertexBuffer( 4*sizeof(Vertex), D3DUSAGE_WRITEONLY,
                                      D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT,
                                      &g_pVertexBuffer, NULL );

    void *pVertices = NULL;

    g_pVertexBuffer->Lock( 0, sizeof(g_quadVertices), (void**)&pVertices, 0 );
    memcpy( pVertices, g_quadVertices, sizeof(g_quadVertices) );
    g_pVertexBuffer->Unlock();

    D3DXMATRIX matProj;
    D3DXMatrixPerspectiveFovLH( &matProj, D3DXToRadian( 45.0f ),
                                1920.0f / 1080.0f, 0.1f, 100.0f );
    d3ddev->SetTransform( D3DTS_PROJECTION, &matProj );

	d3ddev->SetRenderState(D3DRS_LIGHTING, FALSE);
}

void render_frame(void)
{
    d3ddev->Clear(0,NULL,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_COLORVALUE(0.0f,0.0f,0.0f,1.0f), 1.0f, 0);

    D3DXMATRIX matWorld;
    D3DXMatrixTranslation( &matWorld, 0.5f, 0.5f, 1.0f );
    d3ddev->SetTransform( D3DTS_WORLD, &matWorld );

    d3ddev->BeginScene();
    d3ddev->SetTexture( 0, g_pTexture );
    d3ddev->SetStreamSource( 0, g_pVertexBuffer, 0, sizeof(Vertex) );
	d3ddev->SetFVF( D3DFVF_CUSTOMVERTEX );
	d3ddev->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );


    d3ddev->EndScene();

    d3ddev->Present(NULL,NULL,NULL,NULL);

}

void cleanD3D(void)
{
    if( g_pTexture != NULL )
        g_pTexture->Release();

    if( g_pVertexBuffer != NULL )
        g_pVertexBuffer->Release();

    d3ddev->Release();
    d3d->Release();
}

I would like to model the 3d object, consisted of two parts (A1 and A2). The angle between A1 and A2 is 150°. A1 and A2 are cylinders. The 3D object (A1 and A2) is lying on the XY plane.
I would like to rotate the 3d object around the A1 axis. The render plane has to be XZ. I don’t know how to rotate the 3d object around A1 axis. I use different combinations of the following functions:

D3DXMatrixRotationY(&R11, D3DX_PI * D3DXToRadian(0));
D3DXMatrixRotationAxis(&A1,  &D3DXVECTOR3 (0.0f, 1.0f, 0.0f), D3DXToRadian(30));
D3DXMatrixRotationZ(&R12, D3DXToRadian(20));
D3DXMatrixTranslation(&T11, 20.0f, 5.0f, 0.0f);
D3DXMatrixRotationX(&R13, D3DXToRadian(40));
HR(gd3dDevice->SetTransform(D3DTS_WORLD, &(R11 * A1 * R13/* * T11 * R13*/)));

Unfortunately I don’t understand how to create a child object (A2). When I rotate the object A1, the child object A2 has to be rotated automatically around the A1 axis.

Could you help to resolve the problem?

Regards

#include <windows.h>
#include "CubeDemo.h"
#include "d3dApp.h"
#include "GfxStats.h"
#include "Vertex.h"
#include "DirectInput.h"
#include <crtdbg.h>
#include <list>
#include "d3dUtil.h"
CubeDemo::CubeDemo(HINSTANCE hInstance, std::string winCaption, 
		D3DDEVTYPE devType, DWORD requestedVP)
		: D3DApp(hInstance, winCaption,	devType, requestedVP), MAX_SPEED(1500.0f), ACCELE(1000.0f)
{
	mGfxStats = new GfxStats();
	// 10 units from origin.
	mCameraRadius = 10.0f;
	// Somewhere in the 3rd quadrant of xz-plane.
	mCameraRotationY = 1.2 * D3DX_PI;
	xPos = 0.0f;
	yPos = 0.0f;
	// 5 units off the ground.
	mCameraHeight = 1.0f;
	HR(D3DXCreateCylinder(gd3dDevice, 4.0f, 5.0f, 6.0f, 10, 4, &mCylinder, 0));
	// If you look at the drawCylinders and drawSpheres functions, you see
	// that we draw 14 cylinders and 14 spheres.
	int numCylVerts    = mCylinder->GetNumVertices() * 14;
	int numCylTris     = mCylinder->GetNumFaces()    * 14;
 
	mGfxStats->addVertices(mNumGridVertices);
	mGfxStats->addVertices(numCylVerts);
	mGfxStats->addTriangles(mNumGridTriangles);
	mGfxStats->addTriangles(numCylTris);
 
	buildGeoBuffers();
	buildFX();
	buildVertexBuffer();
	buildIndexBuffer();
	onResetDevice();
	InitAllVertexDeclarations();
	checkDeviceCaps();
}
void CubeDemo::buildFX()
{
	// Create the FX from a .fx file.
	ID3DXBuffer* errors = 0;
	HR(D3DXCreateEffectFromFile(gd3dDevice, "transform.fx", 
		0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
	if( errors )
		MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
	// Obtain handles.
	mhTech = mFX->GetTechniqueByName("TransformTech");
	mhWVP  = mFX->GetParameterByName(0, "gWVP");
}
bool CubeDemo::checkDeviceCaps()
{
	D3DCAPS9 caps;
	HR(gd3dDevice->GetDeviceCaps(&caps));
	if (caps.VertexShaderVersion < D3DVS_VERSION(3, 0))
		return false;
	if (caps.VertexShaderVersion < D3DPS_VERSION(3, 0))
		return true;
}
void CubeDemo::drawCylinders()
{
	D3DXMATRIX T, R;
	D3DXMatrixRotationX(&R, D3DX_PI * 0.5f);
	int z = 30;
 
	D3DXVECTOR3 pos(100, 0, 0);
	D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
	D3DXMatrixLookAtLH(&mView, &pos, &target, &up);
		D3DXMatrixTranslation(&T, -100.0f, 3.0f, (float)z);
		HR(mFX->SetMatrix(mhWVP, &(R * T * mView * mProj)));
		HR(mFX->CommitChanges());
		HR(mCylinder->DrawSubset(0));
}
void CubeDemo::buildVertexBuffer()
{
	// Obtain a pointer to a new vertex buffer.
	HR(gd3dDevice->CreateVertexBuffer(8 * sizeof (VertexPos), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mVB, 0));
	// Now lock it to obtain a pointer to its internal data,
	// and write the cube's vertex data.
	VertexPos* v = 0;
	HR(mVB->Lock(0, 0, (void**)&v, 0));
	v[0] = VertexPos(-1.0f, -1.0f, -1.0f);
	v[1] = VertexPos(-1.0f, 1.0f, -1.0f);
	v[2] = VertexPos( 1.0f, 1.0f, -1.0f);
	v[3] = VertexPos( 1.0f, -1.0f, -1.0f);
	v[4] = VertexPos(-1.0f, -1.0f, 1.0f);
	v[5] = VertexPos(-1.0f, 1.0f, 1.0f);
	v[6] = VertexPos( 1.0f, 1.0f, 1.0f);
	v[7] = VertexPos( 1.0f, -1.0f, 1.0f);
	HR(mVB->Unlock());
}
 
void CubeDemo::buildIndexBuffer()
{
	// Obtain a pointer to a new index buffer.
	HR(gd3dDevice->CreateIndexBuffer(36 * sizeof(WORD),	D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));
	// Now lock it to obtain a pointer to its internal data,
	// and write the cube's index data.
	WORD* k = 0;
	HR(mIB->Lock(0, 0, (void**)&k, 0));
 
	// Front face.
	k[0] = 0; k[1] = 1; k[2] = 2;
	k[3] = 0; k[4] = 2; k[5] = 3;
	
	// Back face.
	k[6] = 4; k[7] = 6; k[8] = 5;
	k[9] = 4; k[10] = 7; k[11] = 6;
	
	// Left face.
	k[12] = 4; k[13] = 5; k[14] = 1;
	k[15] = 4; k[16] = 1; k[17] = 0;
	
	// Right face.
	k[18] = 3; k[19] = 2; k[20] = 6;
	k[21] = 3; k[22] = 6; k[23] = 7;
	
	// Top face.
	k[24] = 1; k[25] = 5; k[26] = 6;
	k[27] = 1; k[28] = 6; k[29] = 2;
	
	// Bottom face.
	k[30] = 4; k[31] = 0; k[32] = 3;
	k[33] = 4; k[34] = 3; k[35] = 7;
	
	HR(mIB->Unlock());
}
 
CubeDemo::~CubeDemo()
{
	delete mGfxStats;
	ReleaseCOM(mVB);
	ReleaseCOM(mIB);
	ReleaseCOM(mCylinder);
	DestroyAllVertexDeclarations();
}
 
void CubeDemo::onLostDevice()
{
	mGfxStats->onLostDevice();
}
 
void CubeDemo::onResetDevice()
{
	mGfxStats->onResetDevice();
	buildProjMtx();
}
 
void CubeDemo::buildProjMtx()
{
	float w = (float)md3dPP.BackBufferWidth;
	float h = (float)md3dPP.BackBufferHeight;
	D3DXMatrixPerspectiveFovLH(&mProj, D3DX_PI * 0.25f, w/h,
		1.0f, 5000.0f);
}
 
void CubeDemo::updateScene(float dt)
{
	// One cube has 8 vertices and 12 triangles.
	mGfxStats->setVertexCount(8);
	mGfxStats->setTriCount(12);
	mGfxStats->update(dt);
	// Get snapshot of input devices.
	gDInput->poll();
	// Check input.
	if( gDInput->keyDown(DIK_W) )
		xPos = xPos + 0.001f;
	if( gDInput->keyDown(DIK_S) )
		xPos = xPos - 0.001f;
	if( gDInput->keyDown(DIK_A) )
		yPos = yPos - 0.001f;
	if( gDInput->keyDown(DIK_D) )
		yPos = yPos + 0.001f;
	// Divide by 50 to make mouse less sensitive.
	mCameraRotationY += gDInput->mouseDX() / 50.0f;
	mCameraRadius += gDInput->mouseDY() / 50.0f;
	// If we rotate over 360 degrees, just roll back to 0
	if( fabsf(mCameraRotationY) >= 2.0f * D3DX_PI )
		mCameraRotationY = 0.0f;
	// Don't let radius get too small.
	if( mCameraRadius < 5.0f )
		mCameraRadius = 5.0f;
	buildViewMtx();
}
 

	
void CubeDemo::buildViewMtx()
{
	D3DXVECTOR3 pos(0, 0, 100);
	D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 up(1.0f, 0.0f, 0.0f);
	D3DXMatrixLookAtLH(&mView, &pos, &target, &up);
}
 
void CubeDemo::drawScene()
{
	// Clear the back buffer and depth buffer.
	HR(gd3dDevice->Clear(0, 0,
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0));
	HR(gd3dDevice->BeginScene());
	// Let Direct3D know the vertex buffer, index buffer, and vertex
	// declaration we are using.
	
	HR(gd3dDevice->SetStreamSource(0, mVB, 0, sizeof(VertexPos)));
	HR(gd3dDevice->SetIndices(mIB));
	HR(gd3dDevice->SetVertexDeclaration(VertexPos::Decl));
	
	// Setup the rendering FX
	HR(mFX->SetTechnique(mhTech));
	// World matrix is identity.
	D3DXMATRIX W;
	D3DXMatrixIdentity(&W);
	HR(gd3dDevice->SetTransform(D3DTS_WORLD, &W));
	HR(gd3dDevice->SetTransform(D3DTS_VIEW, &mView));
	HR(gd3dDevice->SetTransform(D3DTS_PROJECTION, &mProj));
 
	D3DXMATRIX matTranslate;    // a matrix to store the translation information

// build a matrix to move the model 12 units along the x-axis and 4 units along the y-axis// store it to matTranslate
	D3DXMatrixTranslation(&matTranslate, xPos, yPos, 0.0f);
// tell Direct3D about our matrix
HR(gd3dDevice->SetTransform(D3DTS_WORLD, &matTranslate));
	HR(gd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME));
	HR(gd3dDevice->DrawIndexedPrimitive(
		D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12));
	drawCylinders();
	HR(gd3dDevice->EndScene());
	// Present the back buffer.
	HR(gd3dDevice->Present(0, 0, 0, 0));
}
 
void CubeDemo::buildGeoBuffers()
{
	std::vector<D3DXVECTOR3> verts;
	std::vector<DWORD> indices;
	GenTriGrid(100, 100, 1.0f, 1.0f, D3DXVECTOR3(0.0f, 0.0f, 0.0f), verts, indices);
	// Save vertex count and triangle count for DrawIndexedPrimitive arguments.
	mNumGridVertices  = 100*100;
	mNumGridTriangles = 99*99*2;
	// Obtain a pointer to a new vertex buffer.
	HR(gd3dDevice->CreateVertexBuffer(mNumGridVertices * sizeof(VertexPos), 
		D3DUSAGE_WRITEONLY,	0, D3DPOOL_MANAGED, &mVB, 0));
 
	// Now lock it to obtain a pointer to its internal data, and write the
	// grid's vertex data.
	VertexPos* v = 0;
	HR(mVB->Lock(0, 0, (void**)&v, 0));
 
	for(DWORD i = 0; i < mNumGridVertices; ++i)
		v[i] = verts[i];
	HR(mVB->Unlock());
	// Obtain a pointer to a new index buffer.
	HR(gd3dDevice->CreateIndexBuffer(mNumGridTriangles*3*sizeof(WORD), D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));
	// Now lock it to obtain a pointer to its internal data, and write the
	// grid's index data.
	WORD* k = 0;
	HR(mIB->Lock(0, 0, (void**)&k, 0));
 
	for(DWORD i = 0; i < mNumGridTriangles*3; ++i)
		k[i] = (WORD)indices[i];
 
	HR(mIB->Unlock());
}

#include<d2d1_2.h>
#include<gdiplus.h>
#include<iostream>
#include<wincodec.h>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "GdiPlus.lib")
#pragma comment(lib, "Windowscodecs.lib")

using namespace std;

void main()
{
	HRESULT hr;
	ID2D1Factory* factory;
	ID2D1DCRenderTarget* target;
	ID2D1SolidColorBrush* brush;

	D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &factory);

	// initialize GDI+
	ULONG_PTR token;
	Gdiplus::GdiplusStartup(&token, new Gdiplus::GdiplusStartupInput(), nullptr);


	auto image = new Gdiplus::Image(L"C:\\temp\\test.jpg");

	auto g = Gdiplus::Graphics::FromImage(image);

	auto prop = D2D1_RENDER_TARGET_PROPERTIES{
		D2D1_RENDER_TARGET_TYPE_HARDWARE ,
		D2D1_PIXEL_FORMAT{ DXGI_FORMAT_B8G8R8A8_UNORM , D2D1_ALPHA_MODE_PREMULTIPLIED },
		144.0f,
		144.0f,
		D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE,
		D2D1_FEATURE_LEVEL_DEFAULT
	};


	hr = factory->CreateDCRenderTarget(&prop, &target);

	auto rect = RECT{ 0L,0L,800L, 600L };

	cout << boolalpha << (image == nullptr) << boolalpha << (g == nullptr) << endl;

	HDC deviceContext = g->GetHDC();

	// binds D2D device context to GDI+ device context.
	target->BindDC(deviceContext, &rect);

	// DrawRectangle using D2d
	target->BeginDraw();

	target->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Red, 1.0f), &brush);
	target->DrawRectangle(D2D1_RECT_F{ 5.0f,5.0f,10.0f,10.0f }, brush);
	target->DrawRectangle(D2D1_RECT_F{ 10.0f,10.0f,30.0f,30.0f }, brush);

	hr = target->EndDraw();

	cout << boolalpha << SUCCEEDED(hr) << endl;

	CLSID pngEncoderClsId = { 0x557cf406, 0x1a04, 0x11d3,{ 0x9a,0x73,0x00,0x00,0xf8,0x1e,0xf3,0x2e } };

	// Transcode and save as PNG image file
	image->Save(L"C:\\temp\\output.png", &pngEncoderClsId);

	Gdiplus::GdiplusShutdown(token);
}