C++ IDirect3DTexture9::GetSurfaceLevel方法代码示例

// TexturedSquare
TexturedSquare::TexturedSquare(LPDIRECT3DDEVICE9 device, const D3DXVECTOR3& vect, const D3DXVECTOR3& shift, float size, 
                               std::vector<LPCWSTR> mipmapFilenames, int wid, bool useTex)
: TexturedObject(device, useTex) {

    std::vector<TEXTURE_VERTEX_WITH_NORMAL> vertices;
    D3DXVECTOR3 normal = vect;
    D3DXVec3Normalize(&normal, &normal);

    const int n = 10;
    const float min = -size / 2;
    const float max = size / 2;
    const float step = size / n;

    for (float u = min; u < max - step; u += step)
    {
        for (float v = min; v < max - step; v += step)
        {
            D3DXVECTOR3 u1, u2, u3, u4;
            if (normal.y != 0) {
                u1 = { u + shift.x, -(normal.x * u + normal.z * v) / normal.y + shift.y, v + shift.z };
                u2 = { u + step + shift.x, -(normal.x * (u + step) + normal.z * v) / normal.y + shift.y, v + shift.z };
                u3 = { u + shift.x, -(normal.x * u + normal.z * (v + step)) / normal.y + shift.y, v + step + shift.z };
                u4 = { u + step + shift.x, -(normal.x * (u + step) + normal.z * (v + step)) / normal.y + shift.y, v + step + shift.z };
            }
            else if (normal.z != 0) {
                u1 = { u + shift.x, v + shift.y, -(normal.x * u + normal.y * v) / normal.z + shift.z };
                u2 = { u + step + shift.x, v + shift.y, -(normal.x * (u + step) + normal.y * v) / normal.z + shift.z };
                u3 = { u + shift.x, v + step + shift.y, -(normal.x * u + normal.y * (v + step)) / normal.z + shift.z };
                u4 = { u + step + shift.x, v + step + shift.y, -(normal.x * (u + step) + normal.y * (v + step)) / normal.z + shift.z };
            }
            else if (normal.x != 0) {
                u1 = { -(normal.y * u + normal.z * v) / normal.x + shift.x, u + shift.y, v + shift.z };
                u2 = { -(normal.y * (u + step) + normal.z * v) / normal.x + shift.x, u + step + shift.y, v + shift.z };
                u3 = { -(normal.y * u + normal.z * (v + step)) / normal.x + shift.x, u + shift.y, v + step + shift.z };
                u4 = { -(normal.y * (u + step) + normal.z * (v + step)) / normal.x + shift.x, u + step + shift.y, v + step + shift.z };
            }

            TEXTURE_VERTEX_WITH_NORMAL v1 = { u1.x, u1.y, u1.z, normal, u / size + 0.5f, v / size + 0.5f};
            TEXTURE_VERTEX_WITH_NORMAL v2 = { u2.x, u2.y, u2.z, normal, (u + step) / size + 0.5f, v / size + 0.5f };
            TEXTURE_VERTEX_WITH_NORMAL v3 = { u3.x, u3.y, u3.z, normal, u / size + 0.5f, (v + step) / size + 0.5f };
            TEXTURE_VERTEX_WITH_NORMAL v4 = { u4.x, u4.y, u4.z, normal, (u + step) / size + 0.5f, (v + step) / size + 0.5f };

            vertices.push_back(v1);
            vertices.push_back(v2);
            vertices.push_back(v3);

            vertices.push_back(v3);
            vertices.push_back(v2);
            vertices.push_back(v4);
        }
    }
    const UINT width = wid;
    const UINT height = wid;
    IDirect3DTexture9* prevTexture = NULL;

    D3DXCreateTexture(d3dDevice, width, height, mipmapFilenames.size(), 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &this->pTexture);
    D3DXCreateTexture(d3dDevice, width, height, mipmapFilenames.size(), 0, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &prevTexture);

    for (int i = 0; i < (int) mipmapFilenames.size(); ++i)
    {
        IDirect3DSurface9 *pSurf;
        prevTexture->GetSurfaceLevel(i, &pSurf);
        D3DXLoadSurfaceFromFile(pSurf, NULL, NULL, mipmapFilenames[i], NULL, D3DX_DEFAULT, 0, NULL);
        pSurf->Release();
    }

    d3dDevice->UpdateTexture(prevTexture, pTexture);
    prevTexture->Release();

    setVertices(vertices);
}

		void CD3D9RenderTarget::setTexture(const core::array<ITexture*>& texture, ITexture* depthStencil)
		{
			bool textureUpdate = (Texture != texture) ? true : false;
			bool depthStencilUpdate = (DepthStencil != depthStencil) ? true : false;

			if (textureUpdate || depthStencilUpdate)
			{
				// Set color attachments.

				if (textureUpdate)
				{
					if (texture.size() > Driver->ActiveRenderTarget.size())
					{
						core::stringc message = "This GPU supports up to ";
						message += Driver->ActiveRenderTarget.size();
						message += " textures per render target.";

						os::Printer::log(message.c_str(), ELL_WARNING);
					}

					const u32 size = core::min_(texture.size(), static_cast<u32>(Driver->ActiveRenderTarget.size()));

					for (u32 i = 0; i < Surface.size(); ++i)
					{
						if (Surface[i])
							Surface[i]->Release();
					}

					Surface.set_used(size);

					for (u32 i = 0; i < Texture.size(); ++i)
					{
						if (Texture[i])
							Texture[i]->drop();
					}

					Texture.set_used(size);

					for (u32 i = 0; i < size; ++i)
					{
						CD3D9Texture* currentTexture = (texture[i] && texture[i]->getDriverType() == DriverType) ? static_cast<CD3D9Texture*>(texture[i]) : 0;

						IDirect3DTexture9* textureID = 0;

						if (currentTexture)
						{
							if (currentTexture->getType() == ETT_2D)
								textureID = currentTexture->getDX9Texture();
							else
								os::Printer::log("This driver doesn't support render to cubemaps.", ELL_WARNING);
						}

						if (textureID)
						{
							Texture[i] = texture[i];
							Texture[i]->grab();

							IDirect3DSurface9* currentSurface = 0;
							textureID->GetSurfaceLevel(0, &currentSurface);

							Surface[i] = currentSurface;
						}
						else
						{
							Surface[i] = 0;
							Texture[i] = 0;
						}
					}
				}

				// Set depth and stencil attachments.

				if (depthStencilUpdate)
				{
					if (DepthStencilSurface)
					{
						DepthStencilSurface->Release();
						DepthStencilSurface = 0;
					}

					if (DepthStencil)
					{
						DepthStencil->drop();
						DepthStencil = 0;

						DepthStencilSurface = 0;
					}

					CD3D9Texture* currentTexture = (depthStencil && depthStencil->getDriverType() == DriverType) ? static_cast<CD3D9Texture*>(depthStencil) : 0;

					IDirect3DTexture9* textureID = 0;

					if (currentTexture)
					{
						if (currentTexture->getType() == ETT_2D)
							textureID = currentTexture->getDX9Texture();
						else
							os::Printer::log("This driver doesn't support render to cubemaps.", ELL_WARNING);
					}

//.........这里部分代码省略.........

void D3D9RenderTarget::BuildRenderTarget()
{
	XTRACE_FUNCTION;

	ASSERT( m_Params.Width );
	ASSERT( m_Params.Height );

	STATIC_HASHED_STRING( Render );
	CATPRINTF( sRender, 1, "Building render target...\n" );

	uint ColorUsage = D3DUSAGE_RENDERTARGET;
	if( m_Params.AutoGenMipMaps )
	{
		ColorUsage |= D3DUSAGE_AUTOGENMIPMAP;
	}

	uint DepthStencilUsage = D3DUSAGE_DEPTHSTENCIL;

	if( m_Params.ColorFormat != ERTF_None )
	{
		CATPRINTF( sRender, 1, "Trying to create color texture with format %d\n", m_Params.ColorFormat );

		const ERenderTargetFormat SupportedFormat = m_Renderer->GetBestSupportedRenderTargetFormat( m_Params.ColorFormat );
		CATPRINTF( sRender, 1, "Creating color texture with format %d...\n", SupportedFormat );

		IDirect3DTexture9* ColorTexture;
		HRESULT hr = m_D3DDevice->CreateTexture(
			m_Params.Width,
			m_Params.Height,
			1,
			ColorUsage,
			GetD3DFormat( SupportedFormat ),
			D3DPOOL_DEFAULT,
			&ColorTexture,
			NULL );
		ASSERT( hr == D3D_OK );
		m_ColorTexture = new D3D9Texture( m_D3DDevice, ColorTexture );
		ColorTexture->GetSurfaceLevel( 0, &m_ColorSurface );
	}

	if( m_Params.DepthStencilFormat != ERTF_None )
	{
		if( m_Params.DepthStencilFormat != ERTF_UseDefault )
		{
			CATPRINTF( sRender, 1, "Trying to create depth/stencil texture with format %d\n", m_Params.DepthStencilFormat );

			const ERenderTargetFormat SupportedFormat = m_Renderer->GetBestSupportedRenderTargetFormat( m_Params.DepthStencilFormat );
			CATPRINTF( sRender, 1, "Creating depth/stencil texture with format %d...\n", SupportedFormat );

			IDirect3DTexture9* DepthStencilTexture;
			HRESULT hr = m_D3DDevice->CreateTexture(
				m_Params.Width,
				m_Params.Height,
				1,
				DepthStencilUsage,
				GetD3DFormat( SupportedFormat ),
				D3DPOOL_DEFAULT,
				&DepthStencilTexture, NULL );
			ASSERT( hr == D3D_OK );
			m_DepthStencilTexture = new D3D9Texture( m_D3DDevice, DepthStencilTexture );
			DepthStencilTexture->GetSurfaceLevel( 0, &m_DepthStencilSurface );
		}
		else
		{
			m_DepthStencilSurface = ( IDirect3DSurface9* )( m_Renderer->GetDefaultRenderTarget()->GetDepthStencilRenderTargetHandle() );
			m_DepthStencilSurface->AddRef();
		}
	}

	CATPRINTF( sRender, 1, "Render target built.\n" );
}

//---------------------------------------------------------------------
void DrawFrame()
{
	HRESULT hr;

	// Update flash movie if necessarily
	unsigned int numDirtyRects; const RECT* dirtyRects;
	if (g_flashPlayer->IsNeedUpdate(NULL, &dirtyRects, &numDirtyRects))
	{
		IDirect3DTexture9* pTexToUpdate = g_texturesRotation[g_currentTexture];
		if (++g_currentTexture == num_textures_in_rotation)
			g_currentTexture = 0;

		IDirect3DSurface9* pSrcSurface;
		hr = pTexToUpdate->GetSurfaceLevel(0, &pSrcSurface);
		assert(SUCCEEDED(hr));

		HDC surfaceDC;
		hr = pSrcSurface->GetDC(&surfaceDC);
		assert(SUCCEEDED(hr));

		// Draw flash frame
		g_flashPlayer->DrawFrame(surfaceDC);

		hr = pSrcSurface->ReleaseDC(surfaceDC);
		assert(SUCCEEDED(hr));

		// Update our GUI texture
		IDirect3DSurface9* pDestSurface;
		hr = g_textureGUI->GetSurfaceLevel(0, &pDestSurface);
		assert(SUCCEEDED(hr));

		for (unsigned int i = 0; i < numDirtyRects; ++i)
		{
			POINT destPoint = { dirtyRects[i].left, dirtyRects[i].top };
			hr = g_device->UpdateSurface(pSrcSurface, dirtyRects + i, pDestSurface, &destPoint);
			assert(SUCCEEDED(hr));
		}

		pDestSurface->Release();
		pSrcSurface->Release();
	}

	//---------------------------------------------------------------------
	struct TLVERTEX
	{
		float x;
		float y;
		float z;
		float rhw;
		D3DCOLOR color;
		float u;
		float v;
	};

	const DWORD D3DFVF_TLVERTEX = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1;

	float halfInvWindowWidth = 1.0f / g_windowWidth * 0.5f;
	float halfInvWindowHeight = 1.0f / g_windowHeight * 0.5f;

	// Create quad vertices
	TLVERTEX vertices[4];
	vertices[0].x = 0; vertices[0].y = 0;
	vertices[0].z = 0.0f; vertices[0].rhw = 1.0f;
	vertices[0].color = 0xFFFFFFFF;
	vertices[0].u = halfInvWindowWidth; vertices[0].v = halfInvWindowHeight;

	vertices[1].x = (float)g_windowWidth; vertices[1].y = 0;
	vertices[1].z = 0.0f; vertices[1].rhw = 1.0f;
	vertices[1].color = 0xFFFFFFFF;
	vertices[1].u = 1.0f + halfInvWindowWidth; vertices[1].v = halfInvWindowHeight;

	vertices[2].x = (float)g_windowWidth; vertices[2].y = (float)g_windowHeight;
	vertices[2].z = 0.0f; vertices[2].rhw = 1.0f;
	vertices[2].color = 0xFFFFFFFF;
	vertices[2].u = 1.0f + halfInvWindowWidth; vertices[2].v = 1.0f + halfInvWindowHeight;

	vertices[3].x = 0; vertices[3].y = (float)g_windowHeight;
	vertices[3].z = 0.0f; vertices[3].rhw = 1.0f;
	vertices[3].color = 0xFFFFFFFF;
	vertices[3].u = halfInvWindowWidth; vertices[3].v = 1.0f + halfInvWindowHeight;

	// Begin frame
	hr = g_device->BeginScene();
	assert(SUCCEEDED(hr));
	hr = g_device->Clear(0, NULL, D3DCLEAR_TARGET, 0xFF000000, 1.0f, 0);
	assert(SUCCEEDED(hr));

	// Draw the quad
	hr = g_device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
	assert(SUCCEEDED(hr));

	hr = g_device->SetRenderState(D3DRS_FOGENABLE, false);
	assert(SUCCEEDED(hr));
	hr = g_device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
	assert(SUCCEEDED(hr));

	// Use alpha channel in texture for alpha
	hr = g_device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
	assert(SUCCEEDED(hr));
//.........这里部分代码省略.........

/*
==================
Creates a texture
==================
*/
IDirect3DTexture9 *DirectXTextureBuilder::createTexture(BYTE *pImage,
        int pBlockWidth,
        int pBlockHeight,
        int pSrcBpp,
        D3DFORMAT pSrcFormat,
        D3DFORMAT pDstFormat) {
	HRESULT mHr;

	IDirect3DTexture9 *mNewTexture;

	// ----- Texture creation -----

	LPDIRECT3DDEVICE9 d3ddeviceptr = _render->_wrappedRenderer->GetDevice();  //Here we break encapsulation with frienship to access internal ptr!!!
	mHr = D3DXCreateTexture(d3ddeviceptr,
	                        pBlockWidth,
	                        pBlockHeight,
	                        1,
	                        0,
	                        pDstFormat,
	                        D3DPOOL_MANAGED,
	                        &mNewTexture);

	if (FAILED(mHr)) {
		g_debug->header("Error creating the texture", 2);
		exit(0);  // TODO: Free objects?
	}

	// ----- D3D Surface creation -----

	IDirect3DSurface9 *_surface;

	// The surfaces points to the texture
	mHr = mNewTexture->GetSurfaceLevel(0, &_surface);
	if (FAILED(mHr)) {
		g_debug->header("Error creating the surface", 2);
		exit(0);  // TODO: free objects
	}

	// ----- Add the source image into the surface -----

	// Source image
	RECT mSrcRect;
	mSrcRect.left       = 0;
	mSrcRect.top        = 0;
	mSrcRect.right      = pBlockWidth;
	mSrcRect.bottom     = pBlockHeight;

	mHr = D3DXLoadSurfaceFromMemory(_surface,
	                                0,
	                                0,
	                                pImage,
	                                pSrcFormat,
	                                pBlockWidth * pSrcBpp,
	                                0,
	                                &mSrcRect,
	                                D3DX_FILTER_NONE,
	                                0);

	if (FAILED(mHr)) {
		g_debug->header("Error loading the block to the surface", 2);
		exit(0);  // TODO: free objects
	}

	// Free memory
	_surface->Release();

	return mNewTexture;
}

/**
*
* Sets up the radiant light surface and texture.
* Since this surface exists in the scratch pool, it does not need to be restored when the device is lost.
*
* @author Jade Abbott
* @return True if creation was successful.
*
*/
bool
CRadialMenu::CreateRadiance()
{
	assert(m_pRenderer);

	CSurfaceManager& rSurfaceManager = m_pRenderer->GetSurfaceManager();

	IDirect3DTexture9* pTexture = 0;
	if (FAILED(rSurfaceManager.CreateTexture(m_uiDiameter,
											 m_uiDiameter,
											 D3DFMT_A8R8G8B8,
											 D3DPOOL_MANAGED,
											 &pTexture)))
	{
		return false;
	}

	// Get the texture's surface.
	IDirect3DSurface9* pSurface = 0;
	if (FAILED(pTexture->GetSurfaceLevel(0, &pSurface)))
	{
		pTexture->Release();
		return false;
	}

	const float kfRadius = m_uiDiameter * 0.5f;
	const float kfRadiusFraction = 1.0f / kfRadius;

	D3DLOCKED_RECT surfaceRect;
	HRESULT hr = pSurface->LockRect(&surfaceRect, 0, 0);
	if (SUCCEEDED(hr))
	{
		D3DCOLOR* pPixels = reinterpret_cast<D3DCOLOR*>(surfaceRect.pBits);
		unsigned int uiNumPixelsWide = surfaceRect.Pitch / 4;	// Includes dirty region.

		// set the colour and alpha for every texel.
		for (unsigned int uiWidth = 0; uiWidth < m_uiDiameter; ++uiWidth)
		{
			for (unsigned int uiHeight = 0; uiHeight < m_uiDiameter; ++uiHeight)
			{
				D3DXVECTOR2 vecRelativePixelPos(static_cast<float>(uiWidth) - kfRadius,
												static_cast<float>(uiHeight) - kfRadius);	// This texel's position relative to the centre of the image.

				float fTexelAlpha = D3DXVec2Length(&vecRelativePixelPos) * kfRadiusFraction;	// Scalar value between 0.0f and 1.0f (capped at 1.0f).
				fTexelAlpha = 1.0f - (fTexelAlpha * fTexelAlpha);	// Squaring the value makes the radiant light stand out more.

				pPixels[(uiHeight * uiNumPixelsWide) + uiWidth] = D3DCOLOR_ARGB(fTexelAlpha <= 0.0f ? 0 : static_cast<unsigned char>(fTexelAlpha * MathUtility::kMaxUC), 192, 128, 32);
			}
		}

		pSurface->UnlockRect();
	}
	else
	{
		assert(false);
		pSurface->Release();
		pTexture->Release();
		return false;
	}

	// Release the surface (texture has it's own reference).
	pSurface->Release();

	// Save the texture to the texture manager.
	CTextureManager& rTextureManager = m_pRenderer->GetTextureManager();

	if (m_iRadiantTextureID != Utility::INVALID_ID)
	{
		rTextureManager.RemoveTexture(m_iRadiantTextureID);
	}

	m_iRadiantTextureID = m_pRenderer->GetTextureManager().LoadTextureMemory(pTexture);

	if (m_iRadiantTextureID == Utility::INVALID_ID)
	{
		pTexture->Release();
		return false;
	}

	return true;
}

bool Surface::swap()
{
    if (mSwapChain)
    {
        IDirect3DTexture9 *flipTexture = mFlipTexture;
        flipTexture->AddRef();

        IDirect3DSurface9 *renderTarget = mRenderTarget;
        renderTarget->AddRef();

        EGLint oldWidth = mWidth;
        EGLint oldHeight = mHeight;

        checkForWindowResize();

        IDirect3DDevice9 *device = mDisplay->getDevice();

        IDirect3DSurface9 *textureSurface;
        flipTexture->GetSurfaceLevel(0, &textureSurface);

        mDisplay->endScene();
        device->StretchRect(renderTarget, NULL, textureSurface, NULL, D3DTEXF_NONE);
        renderTarget->Release();

        applyFlipState(device);
        device->SetTexture(0, flipTexture);

        float xscale = (float)mWidth / oldWidth;
        float yscale = (float)mHeight / oldHeight;

        // Render the texture upside down into the back buffer
        // Texcoords are chosen to pin a potentially resized image into the upper-left corner without scaling.
        float quad[4][6] = {{     0 - 0.5f,       0 - 0.5f, 0.0f, 1.0f, 0.0f,   1.0f       },
                            {mWidth - 0.5f,       0 - 0.5f, 0.0f, 1.0f, xscale, 1.0f       },
                            {mWidth - 0.5f, mHeight - 0.5f, 0.0f, 1.0f, xscale, 1.0f-yscale},
                            {     0 - 0.5f, mHeight - 0.5f, 0.0f, 1.0f, 0.0f,   1.0f-yscale}};   // x, y, z, rhw, u, v

        mDisplay->startScene();
        device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, quad, 6 * sizeof(float));

        flipTexture->Release();
        textureSurface->Release();

        restoreState(device);

        mDisplay->endScene();
        HRESULT result = mSwapChain->Present(NULL, NULL, NULL, NULL, mDisplay->getPresentInterval());

        if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DRIVERINTERNALERROR)
        {
            return error(EGL_BAD_ALLOC, false);
        }

        if (result == D3DERR_DEVICELOST)
        {
            return error(EGL_CONTEXT_LOST, false);
        }

        ASSERT(SUCCEEDED(result));

    }

    return true;
}