Example #1
0
bool DG8Graphics::SetupGraphics(void)
{
	if((m_Direct3D = Direct3DCreate8(D3D_SDK_VERSION)) != NULL){
		if(m_Direct3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&m_DisplayMode) == D3D_OK){
			// Set up the structure used to create the D3DDevice
			D3DPRESENT_PARAMETERS d3dpp;
			memset(&d3dpp,0,sizeof(d3dpp) );
			d3dpp.Windowed = TRUE;
			d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
			d3dpp.BackBufferFormat = m_DisplayMode.Format;

			if(m_Direct3D->CreateDevice(	D3DADAPTER_DEFAULT, 
											D3DDEVTYPE_HAL, 
											m_platform->m_hwnd,
											D3DCREATE_SOFTWARE_VERTEXPROCESSING,
											&d3dpp,
											&m_RenderDevice) == D3D_OK){
				
				m_RenderDevice->SetRenderState(D3DRS_ZENABLE,D3DZB_TRUE);
				m_RenderDevice->SetRenderState(D3DRS_ZFUNC,D3DCMP_LESSEQUAL);

				Disable(IGraphics::LIGHTING);
				SetClearColour(0,0,0);

				return true;
			}
		}
	}


	return false;
}
Example #2
0
BOOL CDX8Disp::OnInitDialog() 
{
	CDialog::OnInitDialog();

	d3d_interface = Direct3DCreate8( D3D_SDK_VERSION );

	// User does not have DX8 installed; disable all functionality
   	if( d3d_interface == NULL ) 
	{
		GetDlgItem(IDC_DX8_NOT_INSTALLED)->ShowWindow(TRUE);
		GetDlgItem(IDC_GEN_CAPS)->ShowWindow(FALSE);
		GetDlgItem(IDC_ADAPTER_LIST)->ShowWindow(FALSE);
		GetDlgItem(IDC_RES_LIST)->ShowWindow(FALSE);
		GetDlgItem(IDC_CDEPTH_LIST)->ShowWindow(FALSE);
		GetDlgItem(IDC_ANTIALIAS_LIST)->ShowWindow(FALSE);
		MessageBox("You do not have DX8.1 installed; cannot offer D3D8 options", "Error", MB_ICONERROR);
		return TRUE;
	}

	color_depthDX[0].cdepth = 16;
	strcpy(color_depthDX[0].text, "16-bit");
	color_depthDX[1].cdepth = 32;
	strcpy(color_depthDX[1].text, "32-bit");

	m_dx8_initialised_ok = true;

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}
Example #3
0
bool CGraphicsDevice::Create()
{
	m_pD3D = Direct3DCreate8(D3D_SDK_VERSION);
	if (!m_pD3D)
	{
		printf("Cannot init D3D\n");
		return false;
	}

	HRESULT hr;
	D3DDISPLAYMODE dispMode;
	D3DPRESENT_PARAMETERS presentParams;

	m_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &dispMode);

	ZeroMemory(&presentParams, sizeof(presentParams));
	presentParams.Windowed = TRUE;
	presentParams.hDeviceWindow = GetConsoleWindow();
	presentParams.SwapEffect = D3DSWAPEFFECT_COPY;
	presentParams.BackBufferWidth = 8;
	presentParams.BackBufferHeight = 8;
	presentParams.BackBufferFormat = dispMode.Format;

	hr = m_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, NULL, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &presentParams, &m_pD3DDevice);
	if (FAILED(hr))
	{
		printf("Cannot init D3D device: %08x\n", hr);
		m_pD3D->Release();
    return false;
	}
  return true;
}
Example #4
0
HRESULT RacorX5::OneTimeSceneInit()
{
	IDirect3D8* d3d = Direct3DCreate8(D3D_SDK_VERSION);
	if (d3d == nullptr)
	{
		MessageBox(m_hWnd, L"Direct3DCreate8 failed!", L"Error", 0);
		return E_FAIL;
	}
	m_spD3D.reset(d3d, [](IDirect3D8* d3d) { d3d->Release(); });
	m_spD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &m_D3DCaps);

	D3DXMatrixPerspectiveFovLH(&m_mtProj, D3DX_PI*0.5, static_cast<float>(m_iWidth) / m_iHeight, m_fObjectRadius / 64.0f,
		m_fObjectRadius*200.0f);
	D3DXMatrixTranslation(&m_mtWorld, -m_vObjectCenter.x, -m_vObjectCenter.x, -m_vObjectCenter.x);

	m_ArcBall.SetWindow(m_iWidth, m_iHeight, 0.85f);
	m_ArcBall.SetRadius(m_fObjectRadius);

	m_Viewport = { 0, 0, m_iWidth, m_iHeight };

	m_spBPatch = std::make_shared<CD3DBPatch>();

	m_vLightColor[0] = D3DXVECTOR4(0.3f, 0.1f, 0.1f, 1.0f);
	m_vLightColor[1] = D3DXVECTOR4(0.1f, 0.5f, 0.1f, 1.0f);
	m_vLightColor[2] = D3DXVECTOR4(0.0f, 0.1f, 0.4f, 1.0f);

	return S_OK;
}
Example #5
0
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
    // Create the D3D object.
    if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
        return E_FAIL;

    // Get the current desktop display mode, so we can set up a back
    // buffer of the same format
    D3DDISPLAYMODE d3ddm;
    if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
        return E_FAIL;

    // Set up the structure used to create the D3DDevice
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;

    // Create the D3DDevice
    if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, &g_pd3dDevice ) ) )
    {
        return E_FAIL;
    }

    // Turn off culling, so we see the front and back of the triangle
    g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

    // Turn off D3D lighting, since we are providing our own vertex colors
    g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );

    return S_OK;
}
Example #6
0
Export int DX8Init(HWND Window) {
  Global = new DX8FXGlobal();
	SoftFX::Load();
  Global->D3D = Direct3DCreate8(D3D_SDK_VERSION);
  Global->Window = Window;
	InstallOverrides();
	return (Global->D3D != 0);
}
Example #7
0
void MFRenderer_InitModulePlatformSpecific()
{
	// create D3D interface
	d3d8 = Direct3DCreate8(D3D_SDK_VERSION);

	if(!d3d8)
		MFDebug_Assert(false ,"Unable to Create the D3D Device.");

	d3d8->GetDeviceCaps(0, D3DDEVTYPE_HAL, &deviceCaps);
}
//---------------------------------------------------------------------
// Function:    CDX8RenderCore
// Description: Constructor
// Parameters:  objMan = pointer to external object manager
// Returns:     .
//---------------------------------------------------------------------
BOOL CDX8RenderCore::Initialize()
{
    // Create new Direct3D object
    m_pD3D = Direct3DCreate8( D3D_SDK_VERSION );
    if (m_pD3D == NULL)
    {
        m_LastError = D3DERR_NOTAVAILABLE;
        gLogger->Print(_T("Unable to Create DirectX 8 3D object"));
        return FALSE;
    }
    
    return TRUE;
}
Example #9
0
HRESULT HelloShadowVolume::OneTimeSceneInit()
{
    IDirect3D8* d3d = Direct3DCreate8(D3D_SDK_VERSION);
    if (!d3d)
    {
        MessageBox(0, L"Direct3DCreate8 error", 0, 0);
        return E_FAIL;
    }
    m_spD3D.reset(d3d, [](IDirect3D8* d3d) {
        d3d->Release();
    });

    return S_OK;
}
Example #10
0
bool
CScene::initDirectX()
{
    //First of all, create the main D3D object. If it is created successfully we
    //should get a pointer to an IDirect3D8 interface.
    g_pD3D = Direct3DCreate8(D3D_SDK_VERSION);
    if(g_pD3D == NULL)
    {
        return false;
    }

    //Get the current display mode
    D3DDISPLAYMODE d3ddm;
    if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
    {
        return false;
    }

    //Create a structure to hold the settings for our device
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory(&d3dpp, sizeof(d3dpp));

    //Fill the structure.
    //We want our program to be windowed, and set the back buffer to a format
    //that matches our current display mode
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_COPY_VSYNC;
    d3dpp.BackBufferFormat = d3ddm.Format;
	d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	d3dpp.EnableAutoDepthStencil = TRUE;

    //Create a Direct3D device.
    if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &g_pD3DDevice)))
    {
        return false;
    }
    
    // Turn on back face culling. This is because we want to hide the back of our polygons
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);

    // Turn off lighting becuase we are specifying that our vertices have colour
    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

	// Turn on depth-buffering
	g_pD3DDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

	dxInit = true;
	return true;
}
Example #11
0
int32 CRenderLib::m_CreateDevice(int32 type)
{
   HRESULT hr;

   p_D3D = Direct3DCreate8(D3D_SDK_VERSION);
   if (type==HARDWARE_DEVICE) p_DeviceType=D3DDEVTYPE_HAL;
   else
   if (type==SOFTWARE_DEVICE) p_DeviceType=D3DDEVTYPE_REF;

   hr=p_D3D->GetDeviceCaps(D3DADAPTER_DEFAULT, p_DeviceType, &p_DeviceInfo.Caps);
   if (hr != D3D_OK) return(0);

   // ----------   il device puo' disegnare in finestra   ------------
   if (p_DeviceInfo.Caps.Caps2 & D3DCAPS2_CANRENDERWINDOWED)
      p_DeviceInfo.CanDoWindowed=TRUE;
   else p_DeviceInfo.CanDoWindowed=FALSE;

   if (type==SOFTWARE_DEVICE)
   {
      p_DeviceInfo.Behavior=D3DCREATE_SOFTWARE_VERTEXPROCESSING;
      p_VSHardwareSupport=0;
   }
   else
   {
     // -----------  T&L e capacità di processo dei vertici  -----------
     if (p_DeviceInfo.Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
	 {
        if (p_DeviceInfo.Caps.VertexShaderVersion >= D3DVS_VERSION(1, 1))
		{
           // if (p_DeviceInfo.Caps.DevCaps & D3DDEVCAPS_PUREDEVICE)
           p_DeviceInfo.Behavior=D3DCREATE_HARDWARE_VERTEXPROCESSING;
			                   //| D3DCREATE_PUREDEVICE;
           p_VSHardwareSupport=(1<<16) | (1);
		}
        else
		{
	       p_DeviceInfo.Behavior=D3DCREATE_MIXED_VERTEXPROCESSING;
           p_VSHardwareSupport=0;
		}
	 }
     else
	 {
	    p_DeviceInfo.Behavior=D3DCREATE_SOFTWARE_VERTEXPROCESSING;
		p_VSHardwareSupport=0;
	 }

   }
   p_IsDeviceCreated=1;
   return(1);
}
Example #12
0
int GameInit(){
	HRESULT r = 0;//return values

	g_pD3D = Direct3DCreate8(D3D_SDK_VERSION);//COM object
	if( g_pD3D == NULL){
		SetError("Could not create IDirect3D8 object");
		return E_FAIL;
	}

	r = InitDirect3DDevice(g_hWndMain, 640, 480, FALSE, D3DFMT_X8R8G8B8, g_pD3D, &g_pDevice);
	if(FAILED(r)){//FAILED is a macro that returns false if return value is a failure - safer than using value itself
		SetError("Initialization of the device failed");
		return E_FAIL;
	}

	return S_OK;
}
Example #13
0
void InitD3D()
{
	ShutdownD3D();

	
	RECT rcClient;
	GetClientRect( g_hWnd, &rcClient );

	g_ScreenWidth  = rcClient.right - rcClient.left;
	g_ScreenHeight = rcClient.bottom - rcClient.top;
	
	// Initialize D3D.
	g_pDirect3D = Direct3DCreate8( D3D_SDK_VERSION );

    // Get the current desktop display mode, so we can set up a back
    // buffer of the same format
    D3DDISPLAYMODE d3ddm;
    g_pDirect3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm );


    // Set up the structure used to create the D3DDevice
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;
	d3dpp.EnableAutoDepthStencil = TRUE;
	d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
	d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;

	HRESULT hr = g_pDirect3D->CreateDevice(
		D3DADAPTER_DEFAULT,
		D3DDEVTYPE_HAL,
		g_hWnd,
		D3DCREATE_SOFTWARE_VERTEXPROCESSING,
		&d3dpp,
		&g_pDevice);
	if( FAILED(hr) )
	{
		Sys_Error( "CreateDevice failed (%s)", DXGetErrorString8(hr) );
	}

    g_pDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
	g_pDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
}
Example #14
0
//-----------------------------------------------------------------------------
// Name: Create()
// Desc: Create the app
//-----------------------------------------------------------------------------
HRESULT CXBApplication::Create()
{
    HRESULT hr;

    // Create the Direct3D object
//    OUTPUT_DEBUG_STRING( "XBApp: Creating Direct3D...\n" );
    if( NULL == ( m_pD3D = Direct3DCreate8(D3D_SDK_VERSION) ) )
    {
//        OUTPUT_DEBUG_STRING( "XBApp: Unable to create Direct3D!\n" );
        return E_FAIL;
    }

    // Create the device
  //  OUTPUT_DEBUG_STRING( "XBApp: Creating the D3D device...\n" );
    if( FAILED( hr = m_pD3D->CreateDevice( 0, D3DDEVTYPE_HAL, NULL, 
                                           D3DCREATE_HARDWARE_VERTEXPROCESSING, 
                                           &m_d3dpp, &m_pd3dDevice ) ) )
    {
//        OUTPUT_DEBUG_STRING( "XBApp: Could not create D3D device!\n" );
        return hr;
    }

    // Allow global access to the device
    g_pd3dDevice = m_pd3dDevice;

    // Store pointers to the depth and back buffers
    m_pd3dDevice->GetDepthStencilSurface( &m_pDepthBuffer );
    m_pd3dDevice->GetBackBuffer( 0, 0, &m_pBackBuffer );

    // Initialize core peripheral port support. Note: If these parameters
    // are 0 and NULL, respectively, then the default number and types of 
    // controllers will be initialized.
    XInitDevices( m_dwNumInputDeviceTypes, m_InputDeviceTypes );

    // Initialize the app's device-dependent objects
//    OUTPUT_DEBUG_STRING( "XBApp: Initializing the app...\n" );
    if( FAILED( hr = Initialize() ) )
    {
//        OUTPUT_DEBUG_STRING( "XBApp: Call to Initialize() failed!\n" );
        return hr;
    }

    return S_OK;
}
Example #15
0
HRESULT CRacorX::OneTimeSceneInit()
{
	IDirect3D8* d3d = Direct3DCreate8(D3D_SDK_VERSION);
	m_spD3D.reset(d3d, [](IDirect3D8* d3d) { d3d->Release(); });
	m_spD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &m_D3DCaps);

	m_Viewport = { 0, 0, m_iWidth, m_iHeight };

	D3DXVECTOR3 eye = { 0.0f, 0.0f, -200.0f };
	D3DXVECTOR3 target = { 0.0f, 0.0f, 0.0f };
	D3DXVECTOR3 up = { 0.0f, 1.0f, 0.0f };
	D3DXMatrixLookAtLH(&m_mtView, &eye, &target, &up);
	float aspect = static_cast<float>(m_iWidth) / m_iHeight;
	D3DXMatrixPerspectiveFovLH(&m_mtProj, D3DX_PI*0.5, aspect, 1.0f, 1000.0f);

	D3DXMatrixIdentity(&m_mtWorld);

	return S_OK;
}
Example #16
0
void InitialiseD3D()
{

	g_pD3D = Direct3DCreate8(D3D_SDK_VERSION);

	D3DPRESENT_PARAMETERS d3dpp; 
	
	ZeroMemory(&d3dpp, sizeof(d3dpp));
	
	d3dpp.BackBufferWidth = 640;
	d3dpp.BackBufferHeight = 480;
	d3dpp.BackBufferFormat = D3DFMT_LIN_X8R8G8B8;
	d3dpp.BackBufferCount = 1;
	d3dpp.EnableAutoDepthStencil = TRUE;
	d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	g_pD3D->CreateDevice(0, D3DDEVTYPE_HAL, NULL, 
							D3DCREATE_HARDWARE_VERTEXPROCESSING, 
							&d3dpp, &g_pD3DDevice);

	g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
	g_pD3DDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
	g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);

	g_pD3DDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
	g_pD3DDevice->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_DIFFUSE);

	g_pD3DDevice->SetTextureStageState(0, D3DTSS_COLORKEYOP, D3DTCOLORKEYOP_KILL);
	g_pD3DDevice->SetTextureStageState(0, D3DTSS_COLORKEYCOLOR, D3DCOLOR_XRGB( 150, 200, 250));

	g_pD3DDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
	g_pD3DDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
	g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);


	g_pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER, D3DTEXF_ANISOTROPIC);
	g_pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER, D3DTEXF_ANISOTROPIC);

	g_pD3DDevice->SetTextureStageState(0, D3DTSS_MAXANISOTROPY, 1 );

	g_pD3DDevice->SetTextureStageState(0, D3DTSS_MIPMAPLODBIAS, *((LPDWORD)(&g_fMipMapLodBias)));
	g_pD3DDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
}
Example #17
0
D3D::D3D(char *n,int w,int h){
	Render=this;
	vb=new D3DVERTEX[256];
	if(!vb) error("out of memory");
	WNDCLASSEX wc={sizeof(WNDCLASSEX),CS_VREDRAW|CS_HREDRAW|CS_OWNDC,WndProc,0,0,hInst,0,0,0,0,n,0};
	RegisterClassEx(&wc);
	hWnd=CreateWindowEx(WS_EX_APPWINDOW|WS_EX_TOPMOST,n,n,0,0,0,w,h,0,0,hInst,0);
	ShowWindow(hWnd,0);
	SetFocus(hWnd);
	ShowCursor(0);
	UpdateWindow(hWnd);
	d3d=Direct3DCreate8(D3D_SDK_VERSION);
	if(!d3d) error("can`t create d3d");
	D3DDISPLAYMODE d3ddm;
	ZeroMemory(&d3ddm,sizeof(d3ddm));
	d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&d3ddm);
	D3DPRESENT_PARAMETERS d3dpp;
	ZeroMemory(&d3dpp,sizeof(d3dpp));
	d3dpp.SwapEffect=D3DSWAPEFFECT_FLIP;
	d3dpp.BackBufferWidth=w;
	d3dpp.BackBufferHeight=h;
	d3dpp.BackBufferFormat=D3DFMT_A8R8G8B8;
	d3dpp.BackBufferCount=1;
	d3dpp.EnableAutoDepthStencil=1;
	d3dpp.AutoDepthStencilFormat=D3DFMT_D16;
	d3d->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hWnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dpp,&d3dd);
	if(!d3dd) error("can`t create d3dd");
	d3dd->SetVertexShader(D3DFVF_D3DVERTEX);
	d3dd->SetRenderState(D3DRS_LIGHTING,1);
	d3dd->SetRenderState(D3DRS_NORMALIZENORMALS,1);
    d3dd->SetRenderState(D3DRS_POINTSPRITEENABLE,1);
    d3dd->SetRenderState(D3DRS_POINTSCALEENABLE,1);
	d3dd->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
	d3dd->SetRenderState(D3DRS_ALPHABLENDENABLE,0);
	d3dd->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
	d3dd->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
	d3dd->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_BLENDDIFFUSEALPHA);
	d3dd->SetRenderState(D3DRS_ZWRITEENABLE,1);
	d3dd->SetRenderState(D3DRS_SHADEMODE,D3DSHADE_FLAT);
	d3dd->SetTexture(0,0);
	d3dd->SetTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_POINT);
	d3dd->SetTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_POINT);
}
Example #18
0
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
    // Create the D3D object.
    if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
        return E_FAIL;

    // Get the current desktop display mode, so we can set up a back
    // buffer of the same format
    D3DDISPLAYMODE d3ddm;
    if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
        return E_FAIL;

    // Set up the structure used to create the D3DDevice. Since we are now
    // using more complex geometry, we will create a device with a zbuffer.
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

    // Create the D3DDevice
    if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, &g_pd3dDevice ) ) )
    {
        return E_FAIL;
    }

    // Turn off culling
    g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

    // Turn off D3D lighting
    g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );

    // Turn on the zbuffer
    g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );

    return S_OK;
}
Example #19
0
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
    // Create the D3D object, which is needed to create the D3DDevice.
    if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
        return E_FAIL;

    // Get the current desktop display mode
    D3DDISPLAYMODE d3ddm;
    if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
        return E_FAIL;

    // Set up the structure used to create the D3DDevice. Most parameters are
    // zeroed out. We set Windowed to TRUE, since we want to do D3D in a
    // window, and then set the SwapEffect to "discard", which is the most
    // efficient method of presenting the back buffer to the display.  And 
    // we request a back buffer format that matches the current desktop display 
    // format.
    D3DPRESENT_PARAMETERS d3dpp; 
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;

    // Create the Direct3D device. Here we are using the default adapter (most
    // systems only have one, unless they have multiple graphics hardware cards
    // installed) and requesting the HAL (which is saying we want the hardware
    // device rather than a software one). Software vertex processing is 
    // specified since we know it will work on all cards. On cards that support 
    // hardware vertex processing, though, we would see a big performance gain 
    // by specifying hardware vertex processing.
    if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, &g_pd3dDevice ) ) )
    {
        return E_FAIL;
    }

    // Device state would normally be set here

    return S_OK;
}
Example #20
0
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT Renderer::InitD3D()
{
    // Create the D3D object.
    if( nullptr == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
        return E_FAIL;

    // Set up the structure used to create the D3DDevice.
    D3DPRESENT_PARAMETERS d3dpp; 
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.BackBufferWidth        = 640;
    d3dpp.BackBufferHeight       = 480;
    d3dpp.BackBufferFormat       = D3DFMT_X8R8G8B8;
    d3dpp.BackBufferCount        = 1;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
    d3dpp.SwapEffect             = D3DSWAPEFFECT_DISCARD;

    // Create the Direct3D device.
    if( FAILED( g_pD3D->CreateDevice( 0, D3DDEVTYPE_HAL, nullptr,
                                      D3DCREATE_HARDWARE_VERTEXPROCESSING,
                                      &d3dpp, &g_pd3dDevice ) ) )
        return E_FAIL;

    // Turn off culling
    g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

    // Turn off D3D lighting
    g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );

    // Turn on the zbuffer
    g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );

    g_pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
    g_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
    //g_pd3dDevice->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
    //g_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
    return S_OK;
}
Example #21
0
BOOL Init_DX( HWND hWnd )
{
	D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory ( &d3dpp, sizeof ( d3dpp ) );
    d3dpp.Windowed   = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_FLIP;
    d3dpp.BackBufferWidth	= SCREENWIDTH;
	d3dpp.BackBufferHeight	= SCREENHEIGHT;
	d3dpp.BackBufferFormat	= D3DFMT_R5G6B5;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	
	lpD3D = Direct3DCreate8 ( D3D_SDK_VERSION ) ;
   

	if( FAILED( lpD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                     D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                     &d3dpp, &lpDevice ) ) )
	{
		
		d3dpp.BackBufferFormat = D3DFMT_X1R5G5B5;

		if ( FAILED ( lpD3D->CreateDevice ( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                         D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                         &d3dpp, &lpDevice ) ) )
										 return false;

	}

	D3DCAPS8 DevCaps;
	ZeroMemory( &DevCaps, sizeof ( D3DCAPS8 ) );
	lpDevice->GetDeviceCaps ( &DevCaps );


	return TRUE;
}
Example #22
0
HRESULT RacorX8::OneTimeSceneInit()
{
	IDirect3D8* d3d = Direct3DCreate8(D3D_SDK_VERSION);
	if (d3d == nullptr)
	{
		MessageBox(m_hWnd, L"Direct3DCreate8 failed!", L"Error", 0);
		return E_FAIL;
	}
	m_spD3D.reset(d3d, [](IDirect3D8* d3d) { d3d->Release(); });
	m_spD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &m_D3DCaps);

	D3DXMatrixPerspectiveFovLH(&m_mtProj,0.55f, static_cast<float>(m_iWidth) / m_iHeight, 1.0f, 10000.0f);

	//D3DXMatrixTranslation(&m_mtWorld, -m_vObjectCenter.x, -m_vObjectCenter.x, -m_vObjectCenter.x);
	D3DXMatrixIdentity(&m_mtWorld);
	D3DXMatrixRotationX(&m_mtWorld, D3DX_PI / 2);
	m_ArcBall.SetWindow(m_iWidth, m_iHeight, 0.85f);
	m_ArcBall.SetRadius(m_fObjectRadius);

	m_Viewport = { 0, 0, m_iWidth, m_iHeight };


	return S_OK;
}
Example #23
0
void JRenderServer::Init()
{
    m_hWnd = (HWND)g_pWindowServer->GetRootHandle();

    if (m_bInited) return;
    
    SetName( "render" );

    rlog.msg( "Creating d3d8 render device..." );
    m_pD3D = Direct3DCreate8( D3D_SDK_VERSION );
    if (m_pD3D == NULL)
    {
        rlog.err( "Could not initialize d3d8." );
        return;
    }
    
    D3DDISPLAYMODE d3ddm;
    m_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm );
    
    ZeroMemory( &m_PresParam, sizeof( m_PresParam ) );

    JScreenMode mode = g_pWindowServer->GetScreenMode();
    BOOL bWindowed = (mode == smWindow || mode == smDesktop);

    bool bHasStencil = true;

    m_PresParam.Windowed                  = bWindowed;
    m_PresParam.SwapEffect                = bWindowed ? D3DSWAPEFFECT_COPY_VSYNC : D3DSWAPEFFECT_FLIP;
    m_PresParam.EnableAutoDepthStencil    = TRUE;
    m_PresParam.AutoDepthStencilFormat    = D3DFMT_D16;
    m_PresParam.BackBufferFormat          = d3ddm.Format;
    m_PresParam.BackBufferCount           = 1;
    m_PresParam.hDeviceWindow             = m_hWnd;

    if (bHasStencil) 
    {
        m_PresParam.AutoDepthStencilFormat = D3DFMT_D24S8;
        m_bHasStencil = true;
    }

    RECT cRect;
    GetClientRect( m_hWnd, &cRect );

    m_PresParam.BackBufferWidth        = cRect.right - cRect.left;
    m_PresParam.BackBufferHeight       = cRect.bottom - cRect.top;

    DWORD flags = D3DCREATE_MIXED_VERTEXPROCESSING;
    D3DDEVTYPE devType = D3DDEVTYPE_HAL;

    rlog.msg( "Creating d3d8 render device..." );

    /*
    //  fixme: this takes precious startup time
    D3DADAPTER_IDENTIFIER8 adapterID;
    m_pD3D->GetAdapterIdentifier( 0, 0, &adapterID );
    rlog.msg( "Adapter: %s", adapterID.Description );
    rlog.msg( "Driver: %s, product: %d, ver: %d, subver: %d, build: %d", 
                adapterID.Driver, 
                HIWORD(adapterID.DriverVersion.HighPart),
                LOWORD(adapterID.DriverVersion.HighPart),
                HIWORD(adapterID.DriverVersion.LowPart),
                LOWORD(adapterID.DriverVersion.LowPart) );

    rlog.msg( "Vendor ID: %d, Device ID: %d, Subsystem ID: %d, Revision: %d", 
                adapterID.VendorId, 
                adapterID.DeviceId,
                adapterID.SubSysId,
                adapterID.Revision );
    */

    // Create the D3DDevice
    HRESULT res = m_pD3D->CreateDevice( 0, devType, m_hWnd, flags, &m_PresParam, &m_pDevice ); 
    if (!m_pDevice) 
    {
        rlog.warn( "Could not create render device. Switching to software vertex processing." );
        
        flags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
        res = m_pD3D->CreateDevice( 0, devType, m_hWnd, flags, &m_PresParam, &m_pDevice );
        
        if (!m_pDevice)
        {
            rlog.err( "Could not create render device. %s", GetDXError( res ) );
            return;
        }
    }

    rlog.msg( "Render device created OK." );
    
    SAFE_RELEASE( m_pBackBuffer );
    SAFE_RELEASE( m_pDepthStencil );
    m_pDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &m_pBackBuffer );
    m_pDevice->GetDepthStencilSurface( &m_pDepthStencil );

    m_bInited = true;

    //  register stock vertex types
    for (int vtype = VertexType_Unknown; vtype < VertexType_Last; vtype++)
    {
        int typeID = GetVDeclID( GetStockVDecl( (VertexType)vtype ) );
        assert( typeID == vtype );
    }

    CreateQuadIB();
} // JRenderServer::Init
Example #24
0
int D3DM_InitDevices( HWND hwnd, int w, int h, int full, HMENU menu )
{
	char	buf[256];
	int		i,j;
		LPDIRECTDRAW7 pDD = NULL;	
		HRESULT hr;
		if( FAILED( hr = DirectDrawCreateEx( NULL, (VOID**)&pDD, IID_IDirectDraw7, NULL ) ) )
			return DDENUMRET_CANCEL;

		D3DCapsStruct.m_ddCaps.dwSize = sizeof(DDCAPS);
		pDD->GetCaps( &D3DCapsStruct.m_ddCaps, NULL );
		if(pDD) {
			pDD->Release();
			pDD = NULL;
		}
	ZeroMemory( d3dTexture, sizeof(D3DD_TEXTURE)*D3DD_MAX_TEXTURE_AMOUNT );
	ZeroMemory( d3dText, sizeof(D3DD_TEXT)*D3DD_MAX_TEXT_AMOUNT );
	ZeroMemory( d3dDisp, sizeof(D3DD_DISP)*D3DD_MAX_DISP_AMOUNT );


	
	pD3D = Direct3DCreate8(D3D_SDK_VERSION);
	if(pD3D == NULL){
		MessageBox(NULL,"Direct3Dオブジェクトの生成に失敗しました。[DirectX8.1が入っていない?]","致命的なエラー", MB_OK | MB_ICONSTOP);
		return FALSE;
	}

	
	if( FAILED(pD3D->GetDeviceCaps( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &D3DCapsStruct.m_d3dCaps)) ){
		MessageBox(NULL,"デバイス能力の取得に失敗しました","致命的なエラー", MB_OK | MB_ICONSTOP);
		return FALSE;
	}
	
	EnumAdapters(D3DADAPTER_DEFAULT);

	
	if( (int)D3DCapsStruct.m_d3dCaps.MaxTextureWidth < D3DD_TEXTURE_CONTROL_SIZE ){
		DebugBox( NULL, "このビデオカードは、幅 %d pixel 以上のサイズのテクスチャを生成できません。[%s]", D3DD_TEXTURE_CONTROL_SIZE);
		return FALSE;
	}else if( (int)D3DCapsStruct.m_d3dCaps.MaxTextureHeight < D3DD_TEXTURE_CONTROL_SIZE ){
		DebugBox( NULL, "このビデオカードは、高さ %d pixel 以上のサイズのテクスチャを生成できません。[%s]", D3DD_TEXTURE_CONTROL_SIZE );
		return FALSE;
	}

	if( !(D3DCapsStruct.m_d3dCaps.ShadeCaps&D3DPSHADECAPS_ALPHAGOURAUDBLEND) ){
		MessageBox(NULL,"このビデオデバイスはグーロブレンディングに対応していません。\nゲームの画像が乱れることがあります","警告", MB_OK | MB_ICONSTOP);
	}
	if( !(D3DCapsStruct.m_d3dCaps.ShadeCaps&D3DPSHADECAPS_COLORGOURAUDRGB) ){
		MessageBox(NULL,"このビデオデバイスはグーロシェーディングに対応していません。\nゲームの画像が乱れることがあります","警告", MB_OK | MB_ICONSTOP);
	}

	if( D3DCapsStruct.m_d3dCaps.TextureCaps&D3DPTEXTURECAPS_SQUAREONLY ){
		DebugBox( NULL, "このビデオカードは長方形テクスチャを生成できません。[デバッグ用ダイアログ]" );
	}

	
	if( FAILED(pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&D3DCapsStruct.m_NowDisplayMode)) ){	
		MessageBox(NULL,"ディスプレイモードの取得に失敗しました。[なにゆえ?]","致命的なエラー", MB_OK | MB_ICONSTOP);
		return FALSE;
	}
	D3DCapsStruct.m_WindowDisplayMode = D3DCapsStruct.m_NowDisplayMode;
	D3DMain.m_DrawHwnd = hwnd;
	D3DMain.m_MenuHwnd = menu;
	if( GetSystemMetrics(SM_CXFULLSCREEN)<=800 || GetSystemMetrics(SM_CYFULLSCREEN)<=600){
		D3DMain.m_FullScreenOnly = TRUE;
		D3DMain.m_WindowMode = FALSE;
	}else{
		D3DMain.m_FullScreenOnly = FALSE;
		D3DMain.m_WindowMode = !full;
	}


	ZeroMemory(&d3dppApp,sizeof(d3dppApp));
	


	WinWidth  = w;
	WinHeight = h;



	d3dppApp.SwapEffect = D3DSWAPEFFECT_COPY;

	d3dppApp.BackBufferFormat = D3DCapsStruct.m_NowDisplayMode.Format;
	d3dppApp.BackBufferCount = 1;
	d3dppApp.BackBufferWidth  = WinWidth;
	d3dppApp.BackBufferHeight = WinHeight;





	d3dppApp.Windowed = TRUE;							
	d3dppApp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;

	
	HRESULT	ret;
	ret = pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_HARDWARE_VERTEXPROCESSING,&d3dppApp,&pD3DDevice);
	if( FAILED(ret) ){	
		ret = pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dppApp,&pD3DDevice);
		if( FAILED(ret) ){	
			D3DMain.m_FullScreenOnly = TRUE;
		}
	}
	if(D3DMain.m_FullScreenOnly==TRUE){
		RELEASE_3D(pD3DDevice);

		D3DMain.m_WindowMode = FALSE;
		ZeroMemory(&d3dppApp,sizeof(d3dppApp));
		for(i=0;i<D3DCapsStruct.m_DisplayModeNum;i++){
			if( D3DCapsStruct.m_DisplayMode[i].Width  == 800 && D3DCapsStruct.m_DisplayMode[i].Height == 600 ){
				switch( D3DCapsStruct.m_DisplayMode[i].Format ){
					case D3DFMT_R5G6B5:		case D3DFMT_X1R5G5B5:
					case D3DFMT_A1R5G5B5:	case D3DFMT_A4R4G4B4:
					case D3DFMT_X4R4G4B4:
						D3DCapsStruct.m_FullModeNum=i;

						d3dppApp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
						d3dppApp.Windowed = D3DMain.m_WindowMode;		
						d3dppApp.SwapEffect = FULL_FLIP;		
						d3dppApp.BackBufferFormat = D3DCapsStruct.m_DisplayMode[i].Format;	
						d3dppApp.BackBufferCount = 1;
						d3dppApp.BackBufferWidth  = WinWidth;
						d3dppApp.BackBufferHeight = WinHeight;



						break;
				}
			}
			if(d3dppApp.SwapEffect) break;
		}
		if(!full){
			wsprintf( buf, "このビデオカードの現在のモードではゲームを実行できません。フルスクリーン化しますか?\n[%d]", D3DCapsStruct.m_DisplayMode[i].RefreshRate );
			if( MessageBox( NULL, buf, "問い合わせ", MB_YESNO )==IDNO ){
				RELEASE_3D(pD3D);
				return FALSE;
			}
		}

		ret = pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_HARDWARE_VERTEXPROCESSING,&d3dppApp,&pD3DDevice);
		if( FAILED(ret) ){	
			ret = pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dppApp,&pD3DDevice);
			if( FAILED(ret) ){	
				switch(ret){
				default:
				case D3DERR_OUTOFVIDEOMEMORY:
					DebugBox( NULL, "Direct3D が処理を行うのに十分なディスプレイ メモリがありません。" );
					RELEASE_3D(pD3D);
					return FALSE;
				case D3DERR_INVALIDCALL:
					DebugBox( NULL, "Direct3Dの初期化に失敗しました[D3DERR_INVALIDCALL]\nこのグラフィックカードは必要な機能をサポートしていないか、\nあるいはDirectX8に対応したドライバが入っていません。" );
					RELEASE_3D(pD3D);
					return FALSE;
				case D3DERR_NOTAVAILABLE:
					DebugBox( NULL, "Direct3Dの初期化に失敗しました[D3DERR_NOTAVAILABLE]\nこのグラフィックカードは必要な機能をサポートしていないか、\nあるいはDirectX8に対応したドライバが入っていません。" );
					RELEASE_3D(pD3D);
					return FALSE;
				}
			}
		}
	}else{
		if(D3DMain.m_WindowMode){	
		}else{
			RELEASE_3D(pD3DDevice);
			ZeroMemory(&d3dppApp,sizeof(d3dppApp));

	
			d3dppApp.SwapEffect = FULL_FLIP;
	
	
			d3dppApp.BackBufferCount = 1;
			d3dppApp.BackBufferWidth  = WinWidth;
			d3dppApp.BackBufferHeight = WinHeight;

		
			d3dppApp.Windowed = FALSE;							
			d3dppApp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;


			if(DrawSetting.full_16bit){
				d3dppApp.BackBufferFormat=D3DFMT_UNKNOWN;
				for(i=0;i<D3DCapsStruct.m_DisplayModeNum;i++){
					if( D3DCapsStruct.m_DisplayMode[i].Width  == 800 && D3DCapsStruct.m_DisplayMode[i].Height == 600 ){
						switch( D3DCapsStruct.m_DisplayMode[i].Format ){
							case D3DFMT_R5G6B5:		case D3DFMT_X1R5G5B5:
							case D3DFMT_A1R5G5B5:	case D3DFMT_A4R4G4B4:
							case D3DFMT_X4R4G4B4:
								D3DCapsStruct.m_FullModeNum=i;
								d3dppApp.BackBufferFormat = D3DCapsStruct.m_DisplayMode[i].Format;	
								break;
						}
					}
					if(d3dppApp.BackBufferFormat!=D3DFMT_UNKNOWN) break;
				}
			}else{
				d3dppApp.BackBufferFormat = D3DCapsStruct.m_NowDisplayMode.Format;
			}

			ret = pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_HARDWARE_VERTEXPROCESSING,&d3dppApp,&pD3DDevice);
			if( FAILED(ret) ){	
				ret = pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dppApp,&pD3DDevice);
				if( FAILED(ret) ){	
					switch(ret){
					default:
					case D3DERR_OUTOFVIDEOMEMORY:
						DebugBox( NULL, "Direct3D が処理を行うのに十分なディスプレイ メモリがありません。" );
						RELEASE_3D(pD3D);
						return FALSE;
					case D3DERR_INVALIDCALL:
						DebugBox( NULL, "Direct3Dの初期化に失敗しました[D3DERR_INVALIDCALL]\nこのグラフィックカードは必要な機能をサポートしていないか、\nあるいはDirectX8に対応したドライバが入っていません。" );
						RELEASE_3D(pD3D);
						return FALSE;
					case D3DERR_NOTAVAILABLE:
						DebugBox( NULL, "Direct3Dの初期化に失敗しました[D3DERR_NOTAVAILABLE]\nこのグラフィックカードは必要な機能をサポートしていないか、\nあるいはDirectX8に対応したドライバが入っていません。" );
						RELEASE_3D(pD3D);
						return FALSE;
					}
				}
			}
		}
	}



	if( FAILED(pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&D3DCapsStruct.m_NowDisplayMode)) ){	
		MessageBox(NULL,"ディスプレイモードの取得に失敗しました。[なにゆえ?]","致命的なエラー", MB_OK | MB_ICONSTOP);
		RELEASE_3D(pD3D);
		return FALSE;
	}
	D3DCapsStruct.m_ttCaps.m_R8G8B8		= IsTextureFormatOk( D3DFMT_R8G8B8,   D3DCapsStruct.m_NowDisplayMode.Format);
	D3DCapsStruct.m_ttCaps.m_X8R8G8B8	= IsTextureFormatOk( D3DFMT_X8R8G8B8, D3DCapsStruct.m_NowDisplayMode.Format);
	D3DCapsStruct.m_ttCaps.m_A8R8G8B8	= IsTextureFormatOk( D3DFMT_A8R8G8B8, D3DCapsStruct.m_NowDisplayMode.Format);

	D3DCapsStruct.m_ttCaps.m_R5G6B5		= IsTextureFormatOk( D3DFMT_R5G6B5,   D3DCapsStruct.m_NowDisplayMode.Format);
	D3DCapsStruct.m_ttCaps.m_X1R5G5B5	= IsTextureFormatOk( D3DFMT_X1R5G5B5, D3DCapsStruct.m_NowDisplayMode.Format);
	D3DCapsStruct.m_ttCaps.m_A1R5G5B5	= IsTextureFormatOk( D3DFMT_A1R5G5B5, D3DCapsStruct.m_NowDisplayMode.Format);

	D3DCapsStruct.m_ttCaps.m_X4R4G4B4	= IsTextureFormatOk( D3DFMT_X4R4G4B4, D3DCapsStruct.m_NowDisplayMode.Format);
	D3DCapsStruct.m_ttCaps.m_A4R4G4B4	= IsTextureFormatOk( D3DFMT_A4R4G4B4, D3DCapsStruct.m_NowDisplayMode.Format);

	D3DCapsStruct.m_ttCaps.m_A8P8		= IsTextureFormatOk( D3DFMT_A8P8,     D3DCapsStruct.m_NowDisplayMode.Format);
	D3DCapsStruct.m_ttCaps.m_P8			= IsTextureFormatOk( D3DFMT_P8,       D3DCapsStruct.m_NowDisplayMode.Format);
	D3DCapsStruct.m_ttCaps.m_A8			= IsTextureFormatOk( D3DFMT_A8,       D3DCapsStruct.m_NowDisplayMode.Format);
	
	D3DD_SetBackBuffer( WinWidth, WinHeight );
	pD3DDevice->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_ARGB(0,0,0,0),1.0,0);

	if(0){
		char	buf2[512];

		wsprintf( buf, "実行ディスプレイモード[%s]\n", TxFmtMode[ LIM(d3dppApp.BackBufferFormat,0,D3DFMT_D3DD_MAX-1) ] );
		MBS_CPY(buf2,buf);

		MBS_CAT(buf2,"使用可能テクスチャ列挙\n");
		for(i=1;i<D3DFMT_D3DD_MAX-1;i++){
			if( TxFmtMode[i] ){
				j = IsTextureFormatOk( (D3DFORMAT)i, D3DCapsStruct.m_NowDisplayMode.Format);
				if(j){
					wsprintf(buf,"%-15s[%s]\n", TxFmtMode[i], (j==2)?"OK":"OK(NotRenderTarget)" );
					MBS_CAT(buf2,buf);
				}else{
					wsprintf(buf,"%-15s[%s]\n", TxFmtMode[i], "--Not--" );
					MBS_CAT(buf2,buf);
				}
			}
		}

		
		DebugBox(NULL,buf2);



	}

	D3DD_CreateTable();

	return TRUE;
}
Example #25
0
//*******
// this function initializes Direct3D... 
bool init3D(HWND hWnd)
{
   D3DDISPLAYMODE d3ddm;   // Direct3D Display Mode..
   D3DPRESENT_PARAMETERS d3dpp;   // d3d present parameters..details on how it should present
         // a scene.. such as swap effect.. size.. windowed or full screen.. 
   HFONT fnt;

   // create D3D8.. if error (like that ever happens..) return false..
   if (NULL == (lpD3D8 = Direct3DCreate8(D3D_SDK_VERSION)))
      return false;
   //  get display adapter mode.. if error return false..
   if (FAILED(lpD3D8->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
      return false;

   // NOTE:  it's possible that this example will not work as is
   //        in windowed mode due to display format and depth buffer format
   ZeroMemory(&d3dpp, sizeof(d3dpp));            // blank the memory for good measure..
   //   d3dpp.Windowed = true;                   // use this for window mode..
   d3dpp.Windowed = false;                       // use this for full screen... it's that easy!
   d3dpp.BackBufferWidth = 1024;                 // rather useless for windowed version
   d3dpp.BackBufferHeight = 768;                 // ditto..but left it in anyway for full screen
   d3dpp.SwapEffect = D3DSWAPEFFECT_FLIP;        // flip using a back buffer...easy performance
   d3dpp.BackBufferFormat = D3DFMT_R5G6B5;       // just set back buffer format from display mode
   d3dpp.EnableAutoDepthStencil = true;
   d3dpp.AutoDepthStencilFormat =  D3DFMT_D16;   // 16 bit depth buffer..

   // Create the D3DDevice
   if (FAILED(lpD3D8->CreateDevice(D3DADAPTER_DEFAULT,   // which display adapter..
             D3DDEVTYPE_HAL,   
             hWnd, D3DCREATE_MIXED_VERTEXPROCESSING,     // mixed, software, or hardware..
                  &d3dpp, &lpD3DDevice8)))               // sends stuff.. and to receive
   {  // if it fails to create with HAL, then try (usually succeeds) to create
      // with ref (software) using a much lower screen res
      d3dpp.BackBufferWidth = 320;
      d3dpp.BackBufferHeight = 240;
      d3dpp.Windowed = false;
      if (FAILED(lpD3D8->CreateDevice(D3DADAPTER_DEFAULT,
                D3DDEVTYPE_REF,
                hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                &d3dpp, &lpD3DDevice8)))
      {
         return false;     
      }
      else
      {  // create smaller font for software... lower res..
         fnt = CreateFont(20, 10, 2, 0, 500, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
               CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_MODERN, 0);
         // disable dithering for software..
         lpD3DDevice8->SetRenderState( D3DRS_DITHERENABLE, false);
      }
   }
   else
   {  // create larger font for hardware.. higher res
      fnt = CreateFont(50, 22, 2, 0, 500, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
            CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_MODERN, 0);
      // enable dithering for hardware... 
      lpD3DDevice8->SetRenderState( D3DRS_DITHERENABLE, true);
   }

   lpD3DDevice8->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
   lpD3DDevice8->SetRenderState( D3DRS_ZENABLE, false);
   
   lpD3DDevice8->SetRenderState( D3DRS_LIGHTING, false );

   // create a D3DXFont from a windows font created above...
   // for use in drawing text with D3D
   D3DXCreateFont(lpD3DDevice8, fnt, &lpD3DXFont);

   lpD3DDevice8->SetRenderState(D3DRS_ALPHABLENDENABLE , true);
   lpD3DDevice8->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
   lpD3DDevice8->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_SRCALPHA);

   return true;
}
Example #26
0
		ZED_UINT32 XboxRenderer::Create( GraphicsAdapter *p_Adapter,
			const CanvasDescription &p_Canvas )
		{
			ZED_UINT32 ReturnStatus = ZED_FAIL;

			if( NULL ==( m_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
			{
				return ZED_FAIL;
			}

			m_Canvas = p_Canvas;

			m_PresentParams.BackBufferWidth = m_Canvas.GetWidth( );
			m_PresentParams.BackBufferHeight = m_Canvas.GetHeight( );
			m_PresentParams.BackBufferCount = m_Canvas.GetBackBufferCount( );
			m_PresentParams.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

			// Get the colour
			switch( m_Canvas.GetBPP( ) )
			{
			case ZED_FORMAT_ARGB8:
				{
					m_PresentParams.BackBufferFormat = D3DFMT_A8R8G8B8;
					ReturnStatus = ZED_OK;
					break;
				}
			default:
				{
					zedTrace( "Failed to set the back buffer format" );
					return ZED_FAIL;
				}
			}

			// Get the Depth/Stencil
			switch( m_Canvas.GetDepthStencil( ) )
			{
			case ZED_FORMAT_D24S8:
				{
					m_PresentParams.EnableAutoDepthStencil = ZED_TRUE;
					m_PresentParams.AutoDepthStencilFormat = D3DFMT_D24S8;
					ReturnStatus = ZED_OK;
					break;
				}
			default:
				{
					zedTrace( "Failed to set the depth/stencil format" );
					return ZED_FAIL;
				}
			}

			// This needs to be exposed, but how?
			m_PresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD;

			if( FAILED( m_pD3D->CreateDevice( 0, D3DDEVTYPE_HAL, NULL,
				D3DCREATE_HARDWARE_VERTEXPROCESSING, &m_PresentParams,
				&m_pDevice ) ) )
			{
				zedTrace( "Failed to create device" );
				return ZED_FAIL;
			}

#ifdef ZED_BUILD_DEBUG
			ZED_UINT32 ModeCount = m_pD3D->GetAdapterModeCount( D3DADAPTER_DEFAULT );
			D3DDISPLAYMODE *pModes = new D3DDISPLAYMODE[ ModeCount ];
			for( ZED_MEMSIZE i = 0; i < ModeCount; i++ )
			{
				if( FAILED( m_pD3D->EnumAdapterModes( D3DADAPTER_DEFAULT, i,
					&pModes[ i ] ) ) )
				{
					delete pModes;
					return ZED_FAIL;
				}

				ZED_MEMSIZE Len = strlen( FlagsToString( pModes[ i ].Flags ) );
				char *pFlags;
			
				if( Len > 0 )
				{
					pFlags = new char[ Len ];
					strncpy( pFlags, FlagsToString( pModes[ i ].Flags ), Len-1 );
					pFlags[ Len-1 ] = '\0';
				}
				if( Len == 0 )
				{
					// Add one for null-termination
					Len = strlen( "NO FLAGS" )+1;
					pFlags = new char[ Len ];
					strncpy( pFlags, "NO FLAGS", Len );
				}	

				// Print out the adapter's capabilities
				zedTrace( "Mode %d:\n"
					"\tWidth: %d | Height: %d | Refresh Rate: %d | Flags: %s \n",
					i,
					pModes[ i ].Width, pModes[ i ].Height,
					pModes[ i ].RefreshRate,
					pFlags );

				delete pFlags;
			}
#endif

			return ReturnStatus;
		}
void
CRenderCriticalSection::Reaction( long in_SrcSectionID, const CRenderCriticalSection_Get3DEnvironmentInfo& in_rGetInfo )
{
	CLog::Print("CRenderCriticalSection::Reaction( const CRenderCriticalSection_Get3DEnvironmentInfo& in_rGetInfo )\n");
	assert(m_HWnd!=NULL);

	CRenderCriticalSection_3DEnvironmentInfo Collected3DInfo;
	Collected3DInfo.m_bError = true; // will be set to false after successfull 3d info query

	bool Have16bitModes = false;
	bool Have32bitModes = false;
	do
	{
		IDirect3D8* pD3D8 = (m_pD3D8!=NULL) ? m_pD3D8 : Direct3DCreate8( D3D_SDK_VERSION );
		CLocalD3D8Holder LocalD3D8Holder( (m_pD3D8!=NULL) ? NULL : pD3D8 );
		if(NULL==pD3D8)
		{
			break;
		}

		HRESULT res;

		// debug name
		D3DADAPTER_IDENTIFIER8 Ident;
		res = pD3D8->GetAdapterIdentifier( D3DADAPTER_DEFAULT, D3DENUM_NO_WHQL_LEVEL, &Ident );
		if(res!=D3D_OK)
		{
			break;
		}
		CLog::Print("  Primary display adapter name:\n");
		CLog::Print("    '%s'\n",Ident.Description);
		// fill in m_DisplayModes

		UINT NModes = pD3D8->GetAdapterModeCount( D3DADAPTER_DEFAULT );
		CLog::Print("  Primary display adapter has %u modes.\n", NModes);
		Collected3DInfo.m_DisplayModes.reserve(NModes);

		D3DDISPLAYMODE DisplayMode;
		for( UINT i=0; i<NModes; ++i )
		{
			HRESULT res = pD3D8->EnumAdapterModes(D3DADAPTER_DEFAULT,i,&DisplayMode);
			assert( D3D_OK == res );
			char Buffer[1024];
			sprintf(Buffer, "  %ux%u, %u hertz, ", DisplayMode.Width, DisplayMode.Height, DisplayMode.RefreshRate);
			strcat(Buffer,DisplayFormatToString(DisplayMode.Format));
			CLog::Print("%s\n",Buffer);
			//
			RENDER_DISPLAY_MODE_FORMAT RDMFormat = DisplayFormatToRDMF(DisplayMode.Format);
			if( RDMFormat!=RDMF_UNKNOWN )
			{
				Have16bitModes |= (RDMFormat==RDMF_R5G6B5);
				Have32bitModes |= (RDMFormat==RDMF_X8R8G8B8);
				Collected3DInfo.m_DisplayModes.push_back(
					CRenderDisplayMode(
						DisplayMode.Width,
						DisplayMode.Height,
						DisplayMode.RefreshRate,
						RDMFormat
					)
				);
			}
		}

		// fill in m_CanRenderWindowed and m_CurrentDisplayMode

		D3DCAPS8 Caps8;
		res = pD3D8->GetDeviceCaps(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,&Caps8);
		assert( D3D_OK == res );

		CLog::Print("  D3DDEVCAPS_TLVERTEXSYSTEMMEMORY = %s\n",0!=(Caps8.DevCaps&D3DDEVCAPS_TLVERTEXSYSTEMMEMORY)?"YES":"no");
		CLog::Print("  D3DDEVCAPS_TLVERTEXVIDEOMEMORY = %s\n",0!=(Caps8.DevCaps&D3DDEVCAPS_TLVERTEXVIDEOMEMORY)?"YES":"no");
		CLog::Print("  MaxVertexIndex = %08x\n",Caps8.MaxVertexIndex);

		Collected3DInfo.m_CanRenderWindowed = 0!=(Caps8.Caps2&D3DCAPS2_CANRENDERWINDOWED);
		CLog::Print("  Primary display adapter %s render windowed.\n", Collected3DInfo.m_CanRenderWindowed?"CAN":"CANNOT");

		CLog::Print("  MaxTextureBlendStages    = %lu\n", Caps8.MaxTextureBlendStages);
		CLog::Print("  MaxSimultaneousTextures  = %lu\n", Caps8.MaxSimultaneousTextures);

		CLog::Print("  MaxVertexBlendMatrices    = %lu\n", Caps8.MaxVertexBlendMatrices);
		CLog::Print("  MaxVertexBlendMatrixIndex = %lu\n", Caps8.MaxVertexBlendMatrixIndex);

		long VSHi = (Caps8.VertexShaderVersion>>8) & 0xff;
		long VSLo = (Caps8.VertexShaderVersion   ) & 0xff;
		CLog::Print("  VertexShaderVersion  = %d.%d\n", VSHi, VSLo);
		CLog::Print("  MaxVertexShaderConst = %lu\n", Caps8.MaxVertexShaderConst);
		long PSHi = (Caps8.PixelShaderVersion>>8) & 0xff;
		long PSLo = (Caps8.PixelShaderVersion   ) & 0xff;
		CLog::Print("  PixelShaderVersion   = %d.%d\n", PSHi, PSLo);
		CLog::Print("  MaxPixelShaderValue  = %f\n", Caps8.MaxPixelShaderValue);

		res = pD3D8->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&DisplayMode);
		RENDER_DISPLAY_MODE_FORMAT RDMFormat = DisplayFormatToRDMF(DisplayMode.Format);
		assert( RDMFormat != RDMF_UNKNOWN );
		char Buffer[1024];
		sprintf(Buffer, "%ux%u, %u hertz, ", DisplayMode.Width, DisplayMode.Height, DisplayMode.RefreshRate);
		strcat(Buffer,DisplayFormatToString(DisplayMode.Format));
		CLog::Print("  Current display mode: %s\n",Buffer);
		Collected3DInfo.m_CurrentDisplayMode = CRenderDisplayMode(	DisplayMode.Width,
																	DisplayMode.Height,
																	DisplayMode.RefreshRate,
																	RDMFormat );
		if(RDMFormat==RDMF_R5G6B5)
		{
			assert(Have16bitModes);
		}
		else // RDMFormat==RDMF_X8R8G8B8
		{
			assert(Have32bitModes);
		}

		// fill in depth buffer flags

		if(Have16bitModes)
		{
			CLog::Print("  16bit:\n");
			Collected3DInfo.m_16Depth = (
				D3D_OK == pD3D8->CheckDeviceFormat(	D3DADAPTER_DEFAULT,
													D3DDEVTYPE_HAL,
													D3DFMT_R5G6B5,
													D3DUSAGE_DEPTHSTENCIL,
													D3DRTYPE_SURFACE,
													D3DFMT_D16)
			);
			CLog::Print("    Depth        = %s\n",Collected3DInfo.m_16Depth?"YES":"no");
			Collected3DInfo.m_16DepthStencil = false; // 16bit modes support only 1bit stencil, which is crap.
			CLog::Print("    DepthStencil = %s\n",Collected3DInfo.m_16DepthStencil?"YES":"no");
		}
		if(Have32bitModes)
		{
			CLog::Print("  32bit:\n");
			Collected3DInfo.m_32Depth = (
				D3D_OK==pD3D8->CheckDeviceFormat(	D3DADAPTER_DEFAULT,
													D3DDEVTYPE_HAL,
													D3DFMT_X8R8G8B8,
													D3DUSAGE_DEPTHSTENCIL,
													D3DRTYPE_SURFACE,
													D3DFMT_D32)
			) || (
				D3D_OK==pD3D8->CheckDeviceFormat(	D3DADAPTER_DEFAULT,
													D3DDEVTYPE_HAL,
													D3DFMT_X8R8G8B8,
													D3DUSAGE_DEPTHSTENCIL,
													D3DRTYPE_SURFACE,
													D3DFMT_D24X8)
			);
			CLog::Print("    Depth        = %s\n",Collected3DInfo.m_32Depth?"YES":"no");
			Collected3DInfo.m_32DepthStencil = (
				D3D_OK==pD3D8->CheckDeviceFormat(	D3DADAPTER_DEFAULT,
													D3DDEVTYPE_HAL,
													D3DFMT_X8R8G8B8,
													D3DUSAGE_DEPTHSTENCIL,
													D3DRTYPE_SURFACE,
													D3DFMT_D24S8)
			) || (
				D3D_OK==pD3D8->CheckDeviceFormat(	D3DADAPTER_DEFAULT,
													D3DDEVTYPE_HAL,
													D3DFMT_X8R8G8B8,
													D3DUSAGE_DEPTHSTENCIL,
													D3DRTYPE_SURFACE,
													D3DFMT_D24X4S4)
			);
			CLog::Print("    DepthStencil = %s\n",Collected3DInfo.m_32DepthStencil?"YES":"no");

		}

		pD3D8->Release();

		Collected3DInfo.m_bError = false;
	} while(false);
	CTCommandSender<CRenderCriticalSection_3DEnvironmentInfo>::SendCommand(
		in_SrcSectionID,
		Collected3DInfo
	);
	CLog::Print("CRenderCriticalSection::Reaction( const CRenderCriticalSection_Get3DEnvironmentInfo& in_rGetInfo ) end\n");
}
void
CRenderCriticalSection::Reaction( long in_SrcSectionID, const CRenderSection_InitRender& in_rInit )
{
	CLog::Print("CRenderCriticalSection::Reaction( const CRenderSection_InitRender& in_rInit )\n");
	CLog::Print("  width  = %lu\n",in_rInit.m_DX);
	CLog::Print("  height = %lu\n",in_rInit.m_DY);
	CLog::Print("  windowed = %s\n",in_rInit.m_bWindowed?"yes":"no");
	CLog::Print("  depth   = %s\n",in_rInit.m_bDepthBufferRequired?"yes":"no");
	CLog::Print("  stencil = %s\n",in_rInit.m_bStencilBufferRequired?"yes":"no");
	CLog::Print("  refresh = %lu\n",in_rInit.m_FullscreenRefreshRate);
	CLog::Print("  vsync = %s\n",in_rInit.m_bVSync?"yes":"no");
	assert(m_pD3D8==NULL);
	assert(m_HWnd!=NULL);

	assert(in_rInit.m_bWindowed); // TODO: fullscreen initialization

	D3DFORMAT BackBufferFormat;
	bool Ok = false;
	RENDER_VERTEX_PROCESS_TYPE VertexProcessingType = RVP_UNKNOWN;
	do
	{
		m_pD3D8 = Direct3DCreate8( D3D_SDK_VERSION );
		assert(m_pD3D8!=NULL);

		if(in_rInit.m_bWindowed)
		{
			D3DDISPLAYMODE Mode;
			HRESULT Res = m_pD3D8->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &Mode );
			assert(Res==D3D_OK);
			BackBufferFormat = Mode.Format;
		}
		else
		{
			assert(2==5);
			// TODO
		}
		if( TryToCreateDevice( in_rInit, BackBufferFormat, RVP_HARDWARE ) )
			VertexProcessingType = RVP_HARDWARE;
		else
		{
			if( TryToCreateDevice( in_rInit, BackBufferFormat, RVP_SOFTWARE ) )
				VertexProcessingType = RVP_SOFTWARE;
			else {
				assert(false);
			}
		}

		Ok = true;
	} while(false);

	if(!Ok)
	{
		ReleaseRenderObjects();
	}

	CTCommandSender<CRenderCriticalSection_InitRenderResult>::SendCommand(
		in_SrcSectionID,
		CRenderCriticalSection_InitRenderResult(
			Ok ? IRR_OK : IRR_FAIL,
			Ok ? m_pD3D8 : NULL,
			Ok ? m_pD3D8Device : NULL,
			Ok ? VertexProcessingType : RVP_UNKNOWN,
			Ok ? BackBufferFormat : D3DFMT_UNKNOWN
		)
	);
}
Example #29
0
int main(int argc, char* argv[])
{
  int NoProtect = 0;
  AllowLinear = true;
  double MaxMSE = 4.0;

	CmdLineArgs args;

	if (args.size() == 1)
	{
		Usage();
		return 1;
	}

	const char* InputDir = NULL;
	const char* OutputFilename = "Textures.xpr";

	for (unsigned int i = 1; i < args.size(); ++i)
	{
		if (!stricmp(args[i], "-help") || !stricmp(args[i], "-h") || !stricmp(args[i], "-?"))
		{
			Usage();
			return 1;
		}
		else if (!stricmp(args[i], "-input") || !stricmp(args[i], "-i"))
		{
			InputDir = args[++i];
		}
		else if (!stricmp(args[i], "-output") || !stricmp(args[i], "-o"))
		{
			OutputFilename = args[++i];
		}
    else if (!stricmp(args[i], "-noprotect") || !stricmp(args[i], "-p"))
    {
      NoProtect = 1;
    }
    else if (!stricmp(args[i], "-onlyswizzled") || !stricmp(args[i], "-s"))
    {
      AllowLinear = false;
    }
    else if (!stricmp(args[i], "-quality") || !stricmp(args[i], "-q"))
		{
			++i;
			if (!stricmp(args[i], "min"))
			{
				MaxMSE = DBL_MAX;
			}
			else if (!stricmp(args[i], "low"))
			{
				MaxMSE = 20.0;
			}
			else if (!stricmp(args[i], "normal"))
			{
				MaxMSE = 4.0;
			}
			else if (!stricmp(args[i], "high"))
			{
				MaxMSE = 1.5;
			}
			else if (!stricmp(args[i], "max"))
			{
				MaxMSE = 0.0;
			}
			else
			{
				printf("Unrecognised quality setting: %s\n", args[i]);
			}
		}
		else
		{
			printf("Unrecognised command line flag: %s\n", args[i]);
		}
	}

	// Initialize DirectDraw
	pD3D = Direct3DCreate8(D3D_SDK_VERSION);
	if (pD3D == NULL)
	{
		puts("Cannot init D3D");
		return 1;
	}

	HRESULT hr;
	D3DDISPLAYMODE dispMode;
	D3DPRESENT_PARAMETERS presentParams;

	pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &dispMode);

	ZeroMemory(&presentParams, sizeof(presentParams));
	presentParams.Windowed = TRUE;
	presentParams.hDeviceWindow = GetConsoleWindow();
	presentParams.SwapEffect = D3DSWAPEFFECT_COPY;
	presentParams.BackBufferWidth = 8;
	presentParams.BackBufferHeight = 8;
	presentParams.BackBufferFormat = dispMode.Format;

	hr = pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, NULL, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &presentParams, &pD3DDevice);
	if (FAILED(hr))
	{
		printf("Cannot init D3D device: %08x\n", hr);
		pD3D->Release();
		return 1;
	}

	char HomeDir[MAX_PATH];
	GetCurrentDirectory(MAX_PATH, HomeDir);

	XPRFile.OutputBuf = (char*)VirtualAlloc(0, 64 * 1024 * 1024, MEM_RESERVE, PAGE_NOACCESS);
	if (!XPRFile.OutputBuf)
	{
		printf("Memory allocation failure: %08x\n", GetLastError());
		pD3DDevice->Release();
		pD3D->Release();
		return 1;
	}

	Bundler.StartBundle();

	// Scan the input directory (or current dir if false) for media files
	ConvertDirectory(InputDir, NULL, MaxMSE);

	VirtualFree(XPRFile.OutputBuf, 0, MEM_RELEASE);

	pD3DDevice->Release();
	pD3D->Release();

	SetCurrentDirectory(HomeDir);
	DWORD attr = GetFileAttributes(OutputFilename);
	if (attr != -1 && (attr & FILE_ATTRIBUTE_DIRECTORY))
	{
		SetCurrentDirectory(OutputFilename);
		OutputFilename = "Textures.xpr";
	}

	printf("\nWriting bundle: %s", OutputFilename);
  int BundleSize = Bundler.WriteBundle(OutputFilename, NoProtect);
	if (BundleSize == -1)
	{
		printf("\nERROR: %08x\n", GetLastError());
		return 1;
	}

	printf("\nUncompressed texture size: %6dkB\nCompressed texture size: %8dkB\nBundle size:             %8dkB\n\nWasted Pixels: %u/%u (%5.2f%%)\n",
		(UncompressedSize + 1023) / 1024, (((CompressedSize + 1023) / 1024) + 3) & ~3, (BundleSize + 1023) / 1024,
		TotalDstPixels - TotalSrcPixels, TotalDstPixels, 100.f * (float)(TotalDstPixels - TotalSrcPixels) / (float)TotalDstPixels);

	return 0;
}