void MyDirectXWindow::init()
{
	mCamera.initializeOnDevice(mDevice);
	createDepthStencilState();
	createRasterizerStates();
	createBlendingStates();
	createObjects();
}
/* virtual */	
MStatus	
DX11ViewportRenderer::initialize()
{
	MStatus status = MStatus::kFailure;

#if defined(DX11_SUPPORTED)

	// Do we want floating point targets
	//
	MString wantFloatingPoint("D3D_RENDERER_FLOAT_TARGETS");
	int value;
	if (!MGlobal::getOptionVarValue(wantFloatingPoint, value))
	{
		m_wantFloatingPointTargets = true;
	}
	else
	{
		m_wantFloatingPointTargets = (value != 0);
	}
	m_wantFloatingPointTargets = false;

	// Create the window to contain our off-screen target.
	//
	if (!m_hWnd)
	{
		// Register the window class
		WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, (WNDPROC) D3DWindowProc, 0L, 0L, 
                      GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
					  "DX11 Viewport Renderer", NULL };
		if (RegisterClassEx( &wc ))
		{
			m_hWnd = CreateWindow( "DX11 Viewport Renderer", "DX11 Viewport Renderer", 
									WS_OVERLAPPEDWINDOW, 0, 0, m_renderWidth, m_renderHeight,
									NULL, NULL, wc.hInstance, NULL );
		}
	}

	HRESULT hr;

	// Test for floating point buffer usage for render targets
	if (m_wantFloatingPointTargets)
	{
		m_intermediateTargetFormat = DXGI_FORMAT_R16G16B16A16_FLOAT;
	}
	else
	{
		m_intermediateTargetFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
	}
	// The output target is always fixed8 for now.
	m_outputTargetFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
	if (m_requireDepthStencilReadback)
	{
		m_depthStencilFormat = DXGI_FORMAT_D32_FLOAT; // Let's try for 32-bit depth, not stencil
	}
	else
		m_depthStencilFormat = DXGI_FORMAT_D24_UNORM_S8_UINT; 

	// Create an appropriate device
	if (m_hWnd)
	{
		if (!m_pD3DDevice)
		{
			// Try hardware vertex processing first.
			//
			hr = D3D11CreateDevice( NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, NULL, 
												0, D3D11_SDK_VERSION, 
												&m_pD3DDevice, NULL, NULL );
			// Try software if we can't find hardware.
			if (FAILED(hr))
			{
				// TODO
			}
			if ( FAILED(hr) )
			{
				m_pD3DDevice = 0;
			}
		}
	}

	// Get the device context.
	if (m_pD3DDevice)
	{
		m_pD3DDevice->GetImmediateContext( &m_pD3DDeviceCtx );
	}

	// Create targets, buffers, states and load shaders.
	if (m_pD3DDevice)
	{
		bool success = buildRenderTargets(640, 480);
		if ( success )
			success = createBoundsBuffers();
		if ( success )
			success = createRasterizerStates();
		if ( success )
		{
			MString shaderLocation(MString(getenv("MAYA_LOCATION")) + MString("\\devkit\\plug-ins"));

			bool loaded;

			{
				D3D11_INPUT_ELEMENT_DESC layout[] =
				{
					{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
					{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
					{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
				};
				const int numLayoutElements = sizeof layout/sizeof layout[0];
				loaded = m_resourceManager.initializeDefaultSurfaceEffect( shaderLocation, m_pD3DDevice, "Maya_fixedFunction", 
																			"mainVS", "mainPS", layout, numLayoutElements );
			}

			{
				D3D11_INPUT_ELEMENT_DESC layout[] =
				{
					{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
				};
				const int numLayoutElements = sizeof layout/sizeof layout[0];
				loaded = m_resourceManager.initializeDefaultSurfaceEffect( shaderLocation, m_pD3DDevice, "Maya_unlit", 
																			"mainVS", "mainPS", layout, numLayoutElements );
			}

			// All elements must exist for success
			if (m_hWnd && m_pD3DDevice && m_pD3DDeviceCtx && m_pTextureOutput && m_pTextureOutputView &&
				m_pTextureInterm && m_pTextureIntermView )
			{
				status = MStatus::kSuccess;
			}
		}
	}

	// If for any reason we failed. Cleanup what we can.
	if (status != MStatus::kSuccess)
	{
		uninitialize();
	}
#else
	status = MStatus::kSuccess;
#endif

	return status;
}