Ejemplo n.º 1
0
//-----------------------------------------------------------------------------
// Name: Init()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CParticleSystem::Init( LPDIRECT3DDEVICE9 pd3dDevice )
{
    HRESULT hr;

    // Initialize the particle system
    if( FAILED( hr = RestoreDeviceObjects( pd3dDevice ) ) )
        return hr;

    // Get max point size
    D3DCAPS9 d3dCaps;
    pd3dDevice->GetDeviceCaps( &d3dCaps );
    m_fMaxPointSize = d3dCaps.MaxPointSize;

    // Check and see if we can change the size of point sprites
    // in hardware by sending D3DFVF_PSIZE with the FVF.

    if( d3dCaps.FVFCaps & D3DFVFCAPS_PSIZE )
        m_bDeviceSupportsPSIZE = true;
    else
        m_bDeviceSupportsPSIZE = false;

    // Load Texture Map for particles
    if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, m_chTexFile, &m_ptexParticle ) ) )
        return E_FAIL;

    return S_OK;
}
Ejemplo n.º 2
0
int CBgDisp2::CheckMultiTexOk( LPDIRECT3DDEVICE9 pd3ddev )
{

	HRESULT hr;
	D3DCAPS9 caps8;
	hr = pd3ddev->GetDeviceCaps( &caps8 );
	if( hr != D3D_OK ){
		DbgOut( "bgdisp2 : checkmultitexok : GetDeviceCaps error !!!\n" );
		_ASSERT( 0 );
		return 1;
	}

	WORD maxtexblendnum = (WORD)( caps8.FVFCaps & D3DFVFCAPS_TEXCOORDCOUNTMASK );
	DWORD maxstages = caps8.MaxTextureBlendStages;
	DWORD maxsimu = caps8.MaxSimultaneousTextures;
	DWORD modu = caps8.TextureOpCaps & D3DTEXOPCAPS_MODULATE;

	DbgOut( "bgdisp2 : CheckMultiTexOk : caps : maxtexcoord %d, maxstages %d, maxsimu %d, moduleop %d\n", maxtexblendnum, maxstages, maxsimu, modu );

	if( (maxtexblendnum >= 2) && (maxstages >= 2) && (maxsimu >= 2) && (modu > 0) ){
		multitexok = 1;
	}else{
		multitexok = 0;
	}


	DbgOut( "bgdisp2 : multitexok %d\n", multitexok );


	return 0;
}
Ejemplo n.º 3
0
IHLSLCodeGenerator::CodeVersion DxStdMtl2::GetPixelShaderSupport(LPDIRECT3DDEVICE9 pd3dDevice, DWORD & instSlots)
{
	D3DCAPS9	Caps;
	IHLSLCodeGenerator::CodeVersion code;
	pd3dDevice->GetDeviceCaps(&Caps);
	UINT major = D3DSHADER_VERSION_MAJOR(Caps.PixelShaderVersion);
	UINT minor = D3DSHADER_VERSION_MINOR(Caps.PixelShaderVersion);

	instSlots = 96;

	if(major < 2 )
		code = IHLSLCodeGenerator::PS_1_X;
	else if(major == 2)
	{
		instSlots = Caps.PS20Caps.NumInstructionSlots;
		if(minor > 0)
			code = IHLSLCodeGenerator::PS_2_X;
		else
			code = IHLSLCodeGenerator::PS_2_0;
	}
	else if(major >=3)
	{
		instSlots = Caps.MaxPixelShader30InstructionSlots;
		code = IHLSLCodeGenerator::PS_3_0;
	}
	else
	{
		code = IHLSLCodeGenerator::PS_1_X;
	}

	return code;

}
Ejemplo n.º 4
0
BOOL InitD3D(HWND hwnd)
{
	HRESULT hr;
	D3DDISPLAYMODE disp_mode;
	D3DPRESENT_PARAMETERS pp;

	if (g_bSetupOK) return TRUE;

	if (g_pD3D) return FALSE;

	g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
	if (!g_pD3D) return FALSE;
	
	hr = g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &disp_mode);
	if (FAILED(hr)) 
	{
		g_pD3D->Release();
		g_pD3D = NULL;
		return FALSE;
	}
	
	ZeroMemory(&pp, sizeof(D3DPRESENT_PARAMETERS));
	pp.Windowed = true;
	pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	pp.BackBufferFormat = disp_mode.Format;
	pp.EnableAutoDepthStencil = TRUE;
	pp.AutoDepthStencilFormat = D3DFMT_D16;
    pp.BackBufferCount = 1;

	BOOL flgSoft = GetPrivateProfileInt("GENERIC","LEVEL",1,".\\TDWGame.ini");

	char buff[256];
	wsprintf(buff,"%d",flgSoft);
	WritePrivateProfileString("GENERIC","LEVEL",buff,".\\TDWGame.ini");

	hr = g_pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_HARDWARE_VERTEXPROCESSING,&pp,&g_pD3DDevice);
	if (FAILED(hr))
	{
		hr = g_pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&pp,&g_pD3DDevice);
		if (FAILED(hr)) 
		{
			hr = g_pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_REF,hwnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&pp,&g_pD3DDevice);
			if (FAILED(hr)) 
			{
				g_pD3D->Release();
				g_pD3D = NULL;
				return FALSE;
			}
		}
	}

	D3DCAPS9 DX9DCaps;
	g_pD3DDevice->GetDeviceCaps(&DX9DCaps);
	g_bSetupOK = TRUE;
	return TRUE;	
}
Ejemplo n.º 5
0
bool CDXGraphicsContext::Initialize(HWND hWnd, HWND hWndStatus,
									 uint32 dwWidth, uint32 dwHeight,
									 BOOL bWindowed )
{
	HRESULT hr;

	if( g_GraphicsInfo.hStatusBar )
	{
		SetWindowText(g_GraphicsInfo.hStatusBar,"Initializing DirectX Device, please wait");
	}

	Lock();

	// Create the Direct3D object
	m_pD3D = Direct3DCreate9( D3D_SDK_VERSION );
	if( m_pD3D == NULL )
	{
		Unlock();
		DisplayD3DErrorMsg( D3DAPPERR_NODIRECT3D, MSGERR_APPMUSTEXIT );
		return false;
	}

	CGraphicsContext::Initialize(hWnd, hWndStatus, dwWidth, dwHeight, bWindowed );
	
	hr = Create3D( bWindowed );

	// Clear/Update a few times to ensure that all of the buffers are cleared
	if ( m_pd3dDevice )
	{
		Clear(CLEAR_COLOR_AND_DEPTH_BUFFER);
		m_pd3dDevice->BeginScene();
		m_pd3dDevice->EndScene();
		UpdateFrame();
	}

	D3DVIEWPORT9 vp = {
		0, 
			windowSetting.toolbarHeightToUse, 
			windowSetting.uDisplayWidth, 
			windowSetting.uDisplayHeight, 0, 1
	};
	gD3DDevWrapper.SetViewport(&vp);
	
	Unlock();

	g_pD3DDev->GetDeviceCaps(&g_D3DDeviceCaps);

	if( g_GraphicsInfo.hStatusBar )
	{
		SetWindowText(g_GraphicsInfo.hStatusBar,"DirectX device is ready");
	}

	return hr==S_OK;
}
Ejemplo n.º 6
0
bool InitResourceDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();

	D3DCAPS9 caps;
	device->GetDeviceCaps(&caps);

	if ( caps.PixelShaderVersion < D3DPS_VERSION(3,0) )
	{
		printf("Requires Pixel Shader 3.0\n");
		return false;
	}

	for ( int i=0; i<TEX_TEXTURES; i++ )
	{
		g_pTextures[i] = NULL;
		g_pSurfaces[i] = NULL;
	}

	if ( !ReInitResourceDX9() )
		return false;

	g_pParticleFX = GutLoadFXShaderDX9("../../shaders/GPUParticle.fx");
	if ( NULL==g_pParticleFX )
		return false;

	g_pParticleRenderFX = GutLoadFXShaderDX9("../../shaders/GPUParticle_render.fx");
	if ( NULL==g_pParticleRenderFX )
		return false;

	g_pPostFX = GutLoadFXShaderDX9("../../shaders/Posteffect.fx");
	if ( NULL==g_pPostFX )
		return false;

	g_pNoiseTexture = GutLoadTexture_DX9("../../textures/noise_512x512.tga");
	if ( NULL==g_pNoiseTexture )
		return false;

	g_pParticleTexture = GutLoadTexture_DX9("../../textures/particle.tga");
	if ( NULL==g_pParticleTexture )
		return false;

	return true;
}
Ejemplo n.º 7
0
/*************************************************************************
	method to do work of constructor
*************************************************************************/
void DirectX9Renderer::constructor_impl(LPDIRECT3DDEVICE9 device, const Size& display_size)
{
	d_device        = device;
	d_queueing      = true;
	d_currTexture   = 0;
	d_buffer        = 0;
	d_bufferPos     = 0;

	// initialise renderer display area
	d_display_area.d_left	= 0;
	d_display_area.d_top	= 0;
	d_display_area.setSize(display_size);

	// Create a vertex buffer
	if (FAILED(d_device->CreateVertexBuffer(
		(VERTEXBUFFER_CAPACITY * sizeof(QuadVertex)), 
		D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, 
		VERTEX_FVF, 
		D3DPOOL_DEFAULT, 
		&d_buffer,
		0)))
	{
		// Ideally, this would have been a RendererException, but we can't use that until the System object is created
		// and that requires a Renderer passed to the constructor, so we throw this instead.
		throw std::exception("Creation of VertexBuffer for Renderer object failed");
	}

	// get the maximum available texture size.
	D3DCAPS9	devCaps;
	if (FAILED(device->GetDeviceCaps(&devCaps)))
	{
		// release vertex buffer
		d_buffer->Release();
		throw std::exception("Unable to retrieve device capabilities from Direct3DDevice9.");
	}

	// set max texture size the the smaller of max width and max height.
	d_maxTextureSize = ceguimin(devCaps.MaxTextureWidth, devCaps.MaxTextureHeight);

	d_device->AddRef();

    // set ID string
    d_identifierString = "CEGUI::DirectX81Renderer - Official Direct3D 9 based renderer module for CEGUI";
}
Ejemplo n.º 8
0
//----------------------------------------------------------------------------//
Direct3D9Renderer::Direct3D9Renderer(LPDIRECT3DDEVICE9 device) :
    d_device(device),
    d_displaySize(getViewportSize()),
    d_displayDPI(96, 96),
    d_defaultTarget(0)
{
    D3DCAPS9 caps;
    device->GetDeviceCaps(&caps);

    if (!caps.RasterCaps && D3DPRASTERCAPS_SCISSORTEST)
        CEGUI_THROW(RendererException(
            "Hardware does not support D3DPRASTERCAPS_SCISSORTEST. "
            "Unable to proceed."));

    d_maxTextureSize = ceguimin(caps.MaxTextureHeight, caps.MaxTextureWidth);

    d_supportNonSquareTex = !(caps.TextureCaps & D3DPTEXTURECAPS_SQUAREONLY);

    d_supportNPOTTex = !(caps.TextureCaps & D3DPTEXTURECAPS_POW2) ||
                       (caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL);

    d_defaultTarget = new Direct3D9ViewportTarget(*this);
}
Ejemplo n.º 9
0
HRESULT HookIDirect3DDevice9::GetDeviceCaps(LPVOID _this, D3DCAPS9* pCaps)
{
	LOG_API();
	return pD3Dev->GetDeviceCaps(pCaps);
}
Ejemplo n.º 10
0
INT CrenderTarget::CreateRenderSurface()
{
	HRESULT hr=-1;

	DWORD				dMip = 1;
	LPDIRECT3DSURFACE9	pSfC = NULL;
	LPDIRECT3DSURFACE9	pSfD = NULL;
	D3DSURFACE_DESC		dscC;
	D3DSURFACE_DESC		dscD;

	D3DCAPS9			m_Caps;

	m_pDev->GetRenderTarget(0,&pSfC);
	m_pDev->GetDepthStencilSurface(&pSfD);

    pSfC->GetDesc(&dscC);
	pSfD->GetDesc(&dscD);

	m_pDev->GetDeviceCaps(&m_Caps);

	pSfC->Release();
	pSfD->Release();

	if(m_iW<0)
		m_iW = dscC.Width;
	
	if(m_iH<0)
		m_iH = dscC.Height;


	m_dC = dscC.Format;
	m_dD = dscD.Format;

	if(LCX_TARGET_HDR16 == m_nType)
		m_dC = D3DFMT_A16B16G16R16F;

	if(LCX_TARGET_HDR32 == m_nType)
		m_dC = D3DFMT_A32B32G32R32F;


	
	hr = D3DXCreateRenderToSurface(m_pDev
							, m_iW
							, m_iH
							, (D3DFORMAT)m_dC
							, TRUE
							, (D3DFORMAT)m_dD
							, &m_pRts);

	if(FAILED(hr))
		return -1;

	hr = D3DXCreateTexture(m_pDev
							, m_iW
							, m_iH
							, dMip
							, D3DUSAGE_RENDERTARGET
							, (D3DFORMAT)m_dC
							, D3DPOOL_DEFAULT
							, &m_pTxP);

	if(FAILED(hr))
        return -1;

	hr = m_pTxP->GetSurfaceLevel(0, &m_pSfc);

	if(FAILED(hr))
		return -1;

	// Clear 0x0
	m_pDev->ColorFill(m_pSfc, NULL, 0x0);
	

	return hr;
}
Ejemplo n.º 11
0
bool InitialiseDirectX()
{
    const D3DFORMAT backBufferFormat = D3DFMT_D16;
    const D3DFORMAT textureFormat = D3DFMT_A8R8G8B8;

    if(FAILED(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        ShowMessageBox("Direct3D interface creation has failed");
        return false;
    }

    // Build present params
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory(&d3dpp, sizeof(d3dpp));

    D3DMULTISAMPLE_TYPE antiAliasingLvl;
    bool antiAliasing = false;
    if(SUCCEEDED(d3d->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, 
        D3DDEVTYPE_HAL, textureFormat, true, D3DMULTISAMPLE_2_SAMPLES, nullptr)))
    {
        d3dpp.MultiSampleType = D3DMULTISAMPLE_2_SAMPLES;
        antiAliasingLvl = D3DMULTISAMPLE_2_SAMPLES;
        antiAliasing = true;
    }

    d3dpp.hDeviceWindow = hWnd;
    d3dpp.Windowed = true;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = textureFormat;
    d3dpp.BackBufferWidth = WINDOW_WIDTH; 
    d3dpp.BackBufferHeight = WINDOW_HEIGHT;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = backBufferFormat; 

    if(FAILED(d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, 
        D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &d3ddev)))
    {
        ShowMessageBox("Direct3D interface creation has failed");
        return false;
    }

    // Create Z-buffer
    if(FAILED(d3ddev->CreateDepthStencilSurface(WINDOW_WIDTH, WINDOW_HEIGHT, backBufferFormat,
        antiAliasing ? antiAliasingLvl : D3DMULTISAMPLE_NONE, NULL, TRUE, &backBuffer, NULL)))
    {
        ShowMessageBox("Z-buffer creation has failed");
        return false;
    }
    d3ddev->SetRenderTarget(0,backBuffer);

    // Set render states
    d3ddev->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, antiAliasing);

    // Check shader capabilities
    D3DCAPS9 caps;
    d3ddev->GetDeviceCaps(&caps);

    // Check for vertex shader version 2.0 support.
    if(caps.VertexShaderVersion < D3DVS_VERSION(2, 0)) 
    {
        ShowMessageBox("Shader model 2.0 or higher is required");
        return false;
    }

    return true;
}
Ejemplo n.º 12
0
//-----------------------------------------------------------------------------
//Desc: 生成蒙皮网格模型(含有每个顶点的混合权重、索引和一个骨骼组合表)
//-----------------------------------------------------------------------------
HRESULT DexAllocateHierarchy::GenerateGameSkinMesh(LPDIRECT3DDEVICE9 device, stDexMeshContainerEx *pMeshContainer)
{
	getLog()->BeginLog();
	HRESULT hr = S_OK;

	if (pMeshContainer->pSkinInfo == NULL)
		return hr;

	_SafeRelease( pMeshContainer->MeshData.pMesh );
	_SafeRelease( pMeshContainer->pBoneCombinationBuf );

	D3DCAPS9 d3dCaps;
	device->GetDeviceCaps( &d3dCaps );

	UINT MaxMatrices = 26; 
	pMeshContainer->NumPaletteEntries = min(MaxMatrices, pMeshContainer->pSkinInfo->GetNumBones());

	DWORD Flags = D3DXMESHOPT_VERTEXCACHE;
	if (d3dCaps.VertexShaderVersion >= D3DVS_VERSION(1, 1))
	{
		Flags |= D3DXMESH_MANAGED;
	}
	else
	{
		getLog()->Log(log_allert, ".X Animation file shader 錯誤!");
	}


	//_SafeRelease(pMeshContainer->MeshData.pMesh);

	if(1)
	{
		DWORD NumMaxFaceInfl;
		DWORD Flags = D3DXMESHOPT_VERTEXCACHE;

		LPDIRECT3DINDEXBUFFER9 pIB;
		hr = pMeshContainer->pOrigMesh->GetIndexBuffer( &pIB );
		if( FAILED( hr ) )
			return hr;

		hr = pMeshContainer->pSkinInfo->GetMaxFaceInfluences( pIB,
			pMeshContainer->pOrigMesh->GetNumFaces(),
			&NumMaxFaceInfl );
		pIB->Release();
		if( FAILED( hr ) )
			return hr;

		// 12 entry palette guarantees that any triangle (4 independent influences per vertex of a tri)
		// can be handled
		NumMaxFaceInfl = min( NumMaxFaceInfl, 12 );

		if( d3dCaps.MaxVertexBlendMatrixIndex + 1 < NumMaxFaceInfl )
		{
			// HW does not support indexed vertex blending. Use SW instead
			pMeshContainer->NumPaletteEntries = min( 256, pMeshContainer->pSkinInfo->GetNumBones() );
			Flags |= D3DXMESH_SYSTEMMEM;
		}
		else
		{
			// using hardware - determine palette size from caps and number of bones
			// If normals are present in the vertex data that needs to be blended for lighting, then 
			// the number of matrices is half the number specified by MaxVertexBlendMatrixIndex.
			pMeshContainer->NumPaletteEntries = min( ( d3dCaps.MaxVertexBlendMatrixIndex + 1 ) / 2,
				pMeshContainer->pSkinInfo->GetNumBones() );
			Flags |= D3DXMESH_MANAGED;
		}

		hr = pMeshContainer->pSkinInfo->ConvertToIndexedBlendedMesh
			(
			pMeshContainer->pOrigMesh,
			Flags,
			pMeshContainer->NumPaletteEntries,
			pMeshContainer->pAdjacency,
			NULL, NULL, NULL,
			&pMeshContainer->NumInfl,
			&pMeshContainer->NumAttributeGroups,
			&pMeshContainer->pBoneCombinationBuf,
			&pMeshContainer->MeshData.pMesh );
		if( FAILED( hr ) )
			return hr;
		return 1;
	}

	//生成蒙皮网格模型
	hr = pMeshContainer->pSkinInfo->ConvertToIndexedBlendedMesh
		(
		pMeshContainer->pOrigMesh,
		Flags, 
		pMeshContainer->NumPaletteEntries, 
		pMeshContainer->pAdjacency, 
		NULL, NULL, NULL,             
		&pMeshContainer->NumInfl,
		&pMeshContainer->NumAttributeGroups, 
		&pMeshContainer->pBoneCombinationBuf, 
		&pMeshContainer->MeshData.pMesh);
	if (FAILED(hr))
		return hr;


	// FVF has to match our declarator. Vertex shaders are not as forgiving as FF pipeline
	DWORD NewFVF = (pMeshContainer->MeshData.pMesh->GetFVF() & D3DFVF_POSITION_MASK) | D3DFVF_NORMAL | D3DFVF_TEX1 | D3DFVF_LASTBETA_UBYTE4;
	if (NewFVF != pMeshContainer->MeshData.pMesh->GetFVF())
	{
		LPD3DXMESH pMesh;
		hr = pMeshContainer->MeshData.pMesh->CloneMeshFVF(pMeshContainer->MeshData.pMesh->GetOptions(), NewFVF, device, &pMesh);
		if (!FAILED(hr))
		{
			pMeshContainer->MeshData.pMesh->Release();
			pMeshContainer->MeshData.pMesh = pMesh;
			pMesh = NULL;
		}
	}

	D3DVERTEXELEMENT9 pDecl[MAX_FVF_DECL_SIZE];
	LPD3DVERTEXELEMENT9 pDeclCur;
	hr = pMeshContainer->MeshData.pMesh->GetDeclaration(pDecl);
	if (FAILED(hr))
		return hr;

	// the vertex shader is expecting to interpret the UBYTE4 as a D3DCOLOR, so update the type 
	//   NOTE: this cannot be done with CloneMesh, that would convert the UBYTE4 data to float and then to D3DCOLOR
	//          this is more of a "cast" operation
	pDeclCur = pDecl;
	while (pDeclCur->Stream != 0xff)
	{
		if ((pDeclCur->Usage == D3DDECLUSAGE_BLENDINDICES) && (pDeclCur->UsageIndex == 0))
			pDeclCur->Type = D3DDECLTYPE_D3DCOLOR;
		pDeclCur++;
	}

	hr = pMeshContainer->MeshData.pMesh->UpdateSemantics(pDecl);
	if (FAILED(hr))
		return hr;

	// allocate a buffer for bone matrices, but only if another mesh has not allocated one of the same size or larger
	if( m_NumBoneMatricesMax < pMeshContainer->pSkinInfo->GetNumBones() )
	{
		m_NumBoneMatricesMax = pMeshContainer->pSkinInfo->GetNumBones();

		// Allocate space for blend matrices
		delete[] m_pBoneMatrices; 
		m_pBoneMatrices  = new D3DXMATRIX[m_NumBoneMatricesMax];
		if( m_pBoneMatrices == NULL )
		{
			hr = E_OUTOFMEMORY;
			return hr;
		}
	}
	return hr;
}
Ejemplo n.º 13
0
//-----------------------------------------------------------------------------
// Name: create
// Desc: Initializes the font
//-----------------------------------------------------------------------------
bool GUIFont::create(LPDIRECT3DDEVICE9 d3dDevice, const char* fontName, DWORD height, bool bold, bool italic)
{
  // Validate parameters
  if (!d3dDevice || !fontName || !height) return false;

  // Make sure the font is clear
  destroy();

  // These variables are used within this method
  HFONT hFont = NULL;
  HFONT hFontOld = NULL;
  HDC hDC = NULL;
  HBITMAP hbmBitmap = NULL;
  HGDIOBJ hbmOld = NULL;

  // Assume that fonts drawn onto the texture do not need scaling unless the texture size
  // required is larger than the device's maximum
  myTextScale = 1.0f;

  // Create a device context for text to draw into
  hDC = CreateCompatibleDC(NULL);
  SetMapMode(hDC, MM_TEXT);

  // Generate the font
  if (!createGDIFont(hDC, &hFont, fontName, height, bold, italic ))
  {
    // Free our context
    DeleteDC(hDC);

    // Return failure
    return false;
  }

  // Set this new font up for use (but store the old one so we can restore it later
  hFontOld = (HFONT)SelectObject(hDC, hFont);

  // Get this device's ability information
  D3DCAPS9 d3dCaps;
  d3dDevice->GetDeviceCaps(&d3dCaps);

  // Usually the required texture is at least 128x128 pixels.
  myTexWidth = myTexHeight = 128;

  // Holds the result of painting the font
  PaintAlphabetResult par;

  // Calculate the size of the smallest power-of-two texture which will hold all the
  // printable characters we need.  First, we try making the texture larger until it gets
  // bigger than the device can support.  Then, we scale down the text to fit the largest
  // texture.
  do
  {
    // If the texture size matches the device's maximum and we've started another
    // iteration, that means the text is too big.  Scale it down.
    if (myTexWidth == d3dCaps.MaxTextureWidth)
      myTextScale *= 0.9f;

    // If this texture is smaller than the device's maximum size, scale it up
    if (myTexWidth < d3dCaps.MaxTextureWidth)
    {
      myTexWidth *= 2;
      myTexHeight *= 2;
    }

    // If the texture is larger than the device can support, scale the text a bit and
    // make the texture the maximum size.
    if (myTexWidth > d3dCaps.MaxTextureWidth)
    {
      // Calculate the text scaling amount
      myTextScale = (float)d3dCaps.MaxTextureWidth / (float)myTexWidth;
      myTexWidth = myTexHeight = d3dCaps.MaxTextureWidth;
    }

    // If we are at the maximum sized texture, the text has been scaled so it needs to
    // be recreated.
    if (myTexWidth == d3dCaps.MaxTextureWidth)
    {
      // Get rid of the new font and put the old font back in
      DeleteObject(SelectObject(hDC, hFontOld));

      // Create the new font
      if (!createGDIFont(hDC, &hFont, fontName, height, bold, italic))
      {
        // Free information
        DeleteDC(hDC);

        // Return failure
        return false;
      }

      // Select the new font
      hFontOld = (HFONT)SelectObject(hDC, hFont);
    }

  } while(PAR_FAILED_NOTENOUGHSPACE == (par = paintAlphabet(hDC, true)));

  // Check to make sure the function didn't fail
  if (par != PAR_SUCCEEDED)
  {
    // Put the old font back into the device context
    SelectObject(hDC, hFontOld);

    // Delete used information
    DeleteObject(hFont);
    DeleteDC(hDC);

    // Erase internal info
    zero();

    // This method failed
    return false;
  }

  // Create the font's texture
  if (FAILED(d3dDevice->CreateTexture(myTexWidth, myTexHeight, 1, 0, D3DFMT_A4R4G4B4,
                      D3DPOOL_MANAGED, &myTexture, NULL)))
  {
    // Put the old font back into the device context
    SelectObject(hDC, hFontOld);

    // Delete used information
    DeleteObject(hFont);
    DeleteDC(hDC);

    // Erase internal info
    zero();

    // Return failure
    return false;
  }

  // Prepare to create the bitmap
  DWORD* bitmapBits;
  BITMAPINFO bmi;
  ZeroMemory(&bmi.bmiHeader, sizeof(BITMAPINFOHEADER));
  bmi.bmiHeader.biSize    = sizeof(BITMAPINFOHEADER);
  bmi.bmiHeader.biWidth     =  (int)myTexWidth;
  bmi.bmiHeader.biHeight    = -(int)myTexHeight;
  bmi.bmiHeader.biPlanes    = 1;
  bmi.bmiHeader.biCompression = BI_RGB;
  bmi.bmiHeader.biBitCount  = 32;

  // Create a bitmap for the font
  hbmBitmap = CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, (void**)&bitmapBits, NULL, 0);
  hbmOld = SelectObject(hDC, hbmBitmap);

  // Set up the text properties
  SetTextColor(hDC, RGB(255,255,255));
  SetBkColor(  hDC, 0x00000000);
  SetTextAlign(hDC, TA_TOP);

  // Actually draw the alphabet
  if (PAR_SUCCEEDED != paintAlphabet(hDC, false))
  {
    // Get rid of created Windows information
    SelectObject(hDC, hbmOld);
    SelectObject(hDC, hFontOld);
    DeleteObject(hbmBitmap);
    DeleteObject(hFont);
    DeleteDC(hDC);

    // Free internal data
    destroy();

    // Return error
    return false;
  }

  // Lock the surface and manually write the alpha values for the pixels
  D3DLOCKED_RECT d3dlr;
  if (FAILED(myTexture->LockRect(0, &d3dlr, 0, 0)))
  {
    // Get rid of created Windows information
    SelectObject(hDC, hbmOld);
    SelectObject(hDC, hFontOld);
    DeleteObject(hbmBitmap);
    DeleteObject(hFont);
    DeleteDC(hDC);

    // Free internal data
    destroy();

    // Return error
    return false;
  }

  // This data is used to fill in the texture
  BYTE* destRow;
  destRow = (BYTE*)d3dlr.pBits;
  WORD* dest16;
  BYTE alpha;
  DWORD x, y;

  // Write the alpha values
  for (y = 0; y < myTexHeight; ++y)
  {
    dest16 = (WORD*)destRow;
    for (x = 0; x < myTexWidth; ++x)
    {
      // Determine whether or not a pixel was written here
      alpha = (BYTE)((bitmapBits[myTexWidth * y + x] & 0xFF) >> 4);

      // Write the alpha value
      if (alpha > 0)
        *dest16++ = ((WORD)(alpha << 12) | 0x0FFF); // updated to remove alpha b/c it causes rendering artifacts
      else
        *dest16++ = 0x0000;
    }

    // Move to the next row
    destRow += d3dlr.Pitch;
  }

  // Unlock the texture
  myTexture->UnlockRect(0);

  // Restore states and delete temporary information
  SelectObject(hDC, hbmOld);
  SelectObject(hDC, hFontOld);
  DeleteObject(hbmBitmap);
  DeleteObject(hFont);
  DeleteDC(hDC);

  // Success
  return true;
}
Ejemplo n.º 14
0
HRESULT KG3DGraphicsEngine::InitDevice(UINT uAdapter, D3DDEVTYPE DeviceType, HWND hwnd)
{
    HRESULT hr = S_OK;
    DWORD dwBehaviorFlags = 0;//D3DCREATE_MULTITHREADED;
	D3DPRESENT_PARAMETERS PresentParam;
	memcpy(&PresentParam, &m_PresentParam, sizeof(D3DPRESENT_PARAMETERS));
	
	_ASSERTE(g_pd3dDevice == NULL);

    hr = m_pD3D->CreateDevice(uAdapter, 
		DeviceType, 
		hwnd, 
		D3DCREATE_MIXED_VERTEXPROCESSING | dwBehaviorFlags, 
		&PresentParam, 
		&g_pd3dDevice);
    KG_COM_PROCESS_SUCCESS(hr);

	memcpy(&PresentParam, 
		&m_PresentParam, 
		sizeof(D3DPRESENT_PARAMETERS));
    hr = m_pD3D->CreateDevice(uAdapter, 
		DeviceType, 
		hwnd, 
		D3DCREATE_HARDWARE_VERTEXPROCESSING | dwBehaviorFlags, 
		&PresentParam, 
		&g_pd3dDevice);
    KG_COM_PROCESS_SUCCESS(hr);

	memcpy(&PresentParam, 
		&m_PresentParam, 
		sizeof(D3DPRESENT_PARAMETERS));
    hr = m_pD3D->CreateDevice(uAdapter, 
		DeviceType, 
		hwnd, 
		D3DCREATE_SOFTWARE_VERTEXPROCESSING | dwBehaviorFlags, 
		&PresentParam, 
		&g_pd3dDevice);
    KG_COM_PROCESS_SUCCESS(hr);

    KGLOG_COM_PROCESS_ERROR(hr);
    KGLOG_PROCESS_ERROR(g_pd3dDevice);

Exit1:
	memcpy(&m_PresentParam, &PresentParam, sizeof(D3DPRESENT_PARAMETERS));
	//检查设备能力
	{
		ZeroMemory(&m_EngineCaps, sizeof(m_EngineCaps));
		HRESULT hrTemp = g_pd3dDevice->GetDeviceCaps(&m_EngineCaps.D3DCaps);
		if (SUCCEEDED(hrTemp))
		{
			for (size_t i = 0; i < _countof(m_EngineCaps.IsShadowTypeAvailable); ++i)
			{
				m_EngineCaps.IsShadowTypeAvailable[i] = TRUE;
			}
            m_EngineCaps.IsShadowTypeAvailable[EM_MODEL_SHADOW_TYPE_LOW] = 
                (m_EngineCaps.D3DCaps.StencilCaps & D3DSTENCILCAPS_INCR) && 
                (m_EngineCaps.D3DCaps.StencilCaps & D3DSTENCILCAPS_DECR);
			//其它类型的影子的能力检查还没有写
		}
		else
		{
			KGLogPrintf(KGLOG_WARNING, "无法得到设备信息,可能显示不正常");
		}
	}

Exit0:
    if (hr == D3DERR_DEVICELOST)
        m_bDeviceLost = true;
    else
        KGLOG_COM_CHECK_ERROR(hr);
    return hr;
}
Ejemplo n.º 15
0
	virtual const char* open( unsigned buffer_width, unsigned buffer_height, HWND hWnd )
	{
		if ( this->hWnd )
			return "Display already open";

		this->hWnd = hWnd;

		lpd3d = Direct3DCreate9( D3D_SDK_VERSION );
		if ( ! lpd3d )
			return "Creating Direct3D 9 object";

		D3DDISPLAYMODE mode;
		lpd3d->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, & mode );

		ZeroMemory(&dpp, sizeof(dpp));
		dpp.Flags                  = D3DPRESENTFLAG_VIDEO;
		dpp.SwapEffect             = D3DSWAPEFFECT_FLIP;
		dpp.hDeviceWindow          = hWnd;
		dpp.BackBufferCount        = 1;
		dpp.MultiSampleType        = D3DMULTISAMPLE_NONE;
		dpp.MultiSampleQuality     = 0;
		dpp.EnableAutoDepthStencil = false;
		dpp.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
		dpp.PresentationInterval   = D3DPRESENT_INTERVAL_IMMEDIATE;
		dpp.Windowed               = TRUE;
		dpp.BackBufferFormat       = D3DFMT_UNKNOWN;
		dpp.BackBufferWidth        = 640;
		dpp.BackBufferHeight       = 480;

		if ( lpd3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, & dpp, & lpdev ) != D3D_OK )
			return "Creating Direct3D 9 device object";

		lpdev->GetDeviceCaps(&d3dcaps);

		bool dynamic = !!(d3dcaps.Caps2 & D3DCAPS2_DYNAMICTEXTURES);

		if(dynamic)
		{
			flags.t_usage = D3DUSAGE_DYNAMIC;
			flags.v_usage = D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC;
			flags.t_pool  = D3DPOOL_DEFAULT;
			flags.v_pool  = D3DPOOL_DEFAULT;
			flags.lock    = D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD;
		}
		else
		{
			flags.t_usage = 0;
			flags.v_usage = D3DUSAGE_WRITEONLY;
			flags.t_pool  = D3DPOOL_MANAGED;
			flags.v_pool  = D3DPOOL_MANAGED;
			flags.lock    = D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD;
		}

		input_width = buffer_width;
		input_height = buffer_height;

		surface_width = rounded_power_of_two( buffer_width );
		surface_height = rounded_power_of_two( buffer_height );

		if ( surface_width > d3dcaps.MaxTextureWidth || surface_height > d3dcaps.MaxTextureHeight )
			return "Device texture size limit is too small";

		restore_objects();

		update_position();

		clear();

		retry_count = 0;

		return 0;
	}
Ejemplo n.º 16
0
HRESULT InitScene()
{
	HRESULT hr;
	D3DCAPS9 caps;

	SetWindowText(hwnd, TITLE);

	device->GetDeviceCaps(&caps);

	if( caps.VertexShaderVersion < D3DVS_VERSION(2, 0) || caps.PixelShaderVersion < D3DPS_VERSION(2, 0) )
	{
		MYERROR("This demo requires Shader Model 2.0 capable video card");
		return E_FAIL;
	}

	palm = new DXObject(device);
	sandplane = new DXObject(device);
	waterplane = new DXObject(device);

	if( !palm->Load("../media/meshes/palm.qm") )
	{
		MYERROR("Could not load palm");
		return E_FAIL;
	}

	if( !sandplane->CreatePlane(50, 50, 10, 10) )
	{
		MYERROR("Could not create sand plane");
		return E_FAIL;
	}

	if( !waterplane->CreatePlane(50, 50, 5, 5) )
	{
		MYERROR("Could not create water plane");
		return E_FAIL;
	}

	waterplane->GenerateTangentFrame();

	MYVALID(D3DXLoadMeshFromXA("../media/meshes/sky.X", D3DXMESH_MANAGED, device, NULL, NULL, NULL, NULL, &skymesh));
	MYVALID(D3DXCreateCubeTextureFromFileA(device, "../media/textures/sky7.dds", &skytex));

	MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/bark.jpg", &bark));
	MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/leaf.jpg", &leaves));
	MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/sand.jpg", &sand));
	MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/wave2.png", &waves));

	MYVALID(DXCreateEffect("../media/shaders/ambient.fx", device, &ambient));
	MYVALID(DXCreateEffect("../media/shaders/blinnphong.fx", device, &specular));
	MYVALID(DXCreateEffect("../media/shaders/water.fx", device, &water));
	MYVALID(DXCreateEffect("../media/shaders/simplebloom.fx", device, &bloom));
	MYVALID(DXCreateEffect("../media/shaders/godray.fx", device, &godray));
	MYVALID(DXCreateEffect("../media/shaders/sky.fx", device, &skyeffect));

	MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &refraction, NULL));
	MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, &reflection, NULL));
	MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8, D3DPOOL_DEFAULT, &occluders, NULL));
	MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8, D3DPOOL_DEFAULT, &blurtex, NULL));
	MYVALID(device->CreateTexture(screenwidth, screenheight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &sceneldr, NULL));

	MYVALID(device->CreateTexture(screenwidth / 2, screenheight / 2, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &bloomtex1, NULL));
	MYVALID(device->CreateTexture(screenwidth / 2, screenheight / 2, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &bloomtex2, NULL));

	refraction->GetSurfaceLevel(0, &refractsurf);
	reflection->GetSurfaceLevel(0, &reflectsurf);
	occluders->GetSurfaceLevel(0, &occludersurf);
	blurtex->GetSurfaceLevel(0, &blursurf);
	sceneldr->GetSurfaceLevel(0, &sceneldrsurf);
	bloomtex1->GetSurfaceLevel(0, &bloomsurf1);
	bloomtex2->GetSurfaceLevel(0, &bloomsurf2);

	D3DVERTEXELEMENT9 elem[] =
	{
		{ 0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0 },
		{ 0, 16, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
		D3DDECL_END()
	};

	MYVALID(device->CreateVertexDeclaration(elem, &quaddecl));

	cameraangle = D3DXVECTOR2(-1.13f * D3DX_PI, 0.55f);

	return S_OK;
}
Ejemplo n.º 17
0
HRESULT cFont::InitDeviceObjects(LPDIRECT3DDEVICE9 pDevice)
{
    HRESULT hr;
    this->m_pDevice= pDevice;
    m_fTextScale = 1.0f;

    if (dwFontHeight > 40)dwWidth = dwHeight = 1024;
    else if (dwFontHeight > 20)dwWidth = dwHeight = 512;
    else
        dwWidth = dwHeight = 256;


    D3DCAPS9 d3dCaps;
    pDevice->GetDeviceCaps(&d3dCaps);

    if (dwWidth > d3dCaps.MaxTextureWidth)
    {
        m_fTextScale = (FLOAT)d3dCaps.MaxTextureWidth / (FLOAT)dwWidth;
        dwWidth =dwHeight = d3dCaps.MaxTextureWidth;
    }


    hr = pDevice->CreateTexture(dwWidth, dwHeight, 1,0, D3DFMT_A4R4G4B4,D3DPOOL_MANAGED, &m_pTexture, 0);
    if (FAILED(hr))return hr;

    DWORD*      pBitmapBits;
    BITMAPINFO bmi;
    ZeroMemory(&bmi.bmiHeader, sizeof(BITMAPINFOHEADER));
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = (int)dwWidth;
    bmi.bmiHeader.biHeight = -(int)dwHeight;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biBitCount = 32;


    HDC     hDC = CreateCompatibleDC(NULL);
    HBITMAP hbmBitmap = CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, (void**)&pBitmapBits, NULL, 0);
    SetMapMode(hDC, MM_TEXT);

    INT nHeight = -MulDiv(dwFontHeight, (INT)(GetDeviceCaps(hDC, LOGPIXELSY) * m_fTextScale), 72);

    DWORD dwBold =   (dwFontFlags & D3DFONT_BOLD)   ? FW_EXTRABOLD : FW_NORMAL;
    DWORD dwItalic = (dwFontFlags & D3DFONT_ITALIC) ? TRUE         : FALSE;

    HFONT hFont = CreateFont(nHeight, 0, 0, 0, dwBold, dwItalic,
                             FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
                             CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
                             VARIABLE_PITCH, strFontName);
    if (NULL == hFont)
        return E_FAIL;

    HGDIOBJ hPrevBitmap = SelectObject(hDC, hbmBitmap);
    HGDIOBJ hPrevFont = SelectObject(hDC, hFont);
    SetTextColor(hDC, RGB(255, 255, 255));
    SetBkColor(hDC, 0x00000000);
    SetTextAlign(hDC, TA_TOP);
    DWORD x = 0;
    DWORD y = 0;
    char str[2] = "x";
    SIZE size;

    for (int c = 32; c <= MAX_CHAR_INDEX; c++)
    {
        str[0] = c;
        GetTextExtentPoint32A(hDC, str, 1, &size);

        if ((DWORD)(x + size.cx + 1) > dwWidth)
        {
            x = 0;
            y += size.cy + 1;
        }

        ExtTextOutA(hDC, x + 0, y + 0, ETO_OPAQUE, NULL, str, 1, NULL);

        m_fTexCoords[c - 32][0] = ((FLOAT)(x + 0)) / dwWidth;
        m_fTexCoords[c - 32][1] = ((FLOAT)(y + 0)) / dwWidth;
        m_fTexCoords[c - 32][2] = ((FLOAT)(x + 0 + size.cx)) / dwWidth;
        m_fTexCoords[c - 32][3] = ((FLOAT)(y + 0 + size.cy)) / dwWidth;

        x += size.cx + 1;
    }


    D3DLOCKED_RECT d3dlr;
    m_pTexture->LockRect(0, &d3dlr, 0, 0);
    BYTE* pDstRow = (BYTE*)d3dlr.pBits;
    WORD* pDst16;
    BYTE bAlpha;

    for (y = 0; y < dwHeight; y++)
    {
        pDst16 = (WORD*)pDstRow;
        for (x = 0; x < dwWidth; x++)
        {
            bAlpha = (BYTE)((pBitmapBits[dwWidth*y + x] & 0xff) >> 4);
            if (bAlpha > 0)
            {
                *pDst16++ = (bAlpha << 12) | 0x0fff;
            }
            else
            {
                *pDst16++ = 0x0000;
            }
        }
        pDstRow += d3dlr.Pitch;
    }
    m_pTexture->UnlockRect(0);


    SelectObject(hDC, hPrevBitmap);
    SelectObject(hDC, hPrevFont);

    DeleteObject(hbmBitmap);
    DeleteDC(hDC);
    DeleteObject(hFont);

    return S_OK;
}