C++ IDirect3DQuery9::Issue方法代码示例

int
D3DOverdrawWindow::
Loop(void)
{
    int nOverdraw = 0;
    IDirect3DQuery9* pOcclusionQuery;
    DWORD numberOfPixelsDrawn;
    d3d->CreateQuery(D3DQUERYTYPE_OCCLUSION, &pOcclusionQuery);

    for (unsigned int iViewpoint = 0; iViewpoint < m_nViewpointCount;
         iViewpoint++)
    {
        // Add an end marker to the command buffer queue.
        pOcclusionQuery->Issue(D3DISSUE_BEGIN);
        // Draw scene
        SetupDraw(iViewpoint);
        DrawModel();
        d3d->EndScene();
        d3d->Present(NULL, NULL, NULL, NULL);
        // Add an end marker to the command buffer queue.
        pOcclusionQuery->Issue(D3DISSUE_END);

        // Force the driver to execute the commands from the command buffer.
        // Empty the command buffer and wait until the GPU is idle.
        while (S_FALSE == pOcclusionQuery->GetData(&numberOfPixelsDrawn,
                                                   sizeof(DWORD), D3DGETDATA_FLUSH))
            ;

        nOverdraw += numberOfPixelsDrawn;
    }

    pOcclusionQuery->Release();
    return nOverdraw;
}

void Graphics::renderOcclusionQuery(uint occlusionQuery, int triangles) {
	IDirect3DQuery9* pQuery = queryPool[occlusionQuery];
	if (pQuery != nullptr) {
		pQuery->Issue(D3DISSUE_BEGIN);
		device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, triangles);
		pQuery->Issue(D3DISSUE_END);
	}
}

      void onBeginFrame()
      {
         if(!frequencyQuery)
         {
            static_cast<GFXPCD3D9Device*>(GFX)->getDevice()->CreateQuery(D3DQUERYTYPE_TIMESTAMPDISJOINT, &disjointQuery);
            static_cast<GFXPCD3D9Device*>(GFX)->getDevice()->CreateQuery(D3DQUERYTYPE_TIMESTAMPFREQ, &frequencyQuery);
         }

         disjointQuery->Issue(D3DISSUE_BEGIN);
         frequencyQuery->Issue(D3DISSUE_END);
      }

void CRenderSystemDX::FlushGPU()
{
  IDirect3DQuery9* pEvent = NULL;

  m_pD3DDevice->CreateQuery(D3DQUERYTYPE_EVENT, &pEvent);
  if (pEvent != NULL)
  {
    pEvent->Issue(D3DISSUE_END);
    while (S_FALSE == pEvent->GetData(NULL, 0, D3DGETDATA_FLUSH))
      Sleep(1);
  }
}

	void D3D9HardwareOcclusionQuery::endOcclusionQuery() 
	{ 
		IDirect3DDevice9* pCurDevice  = D3D9RenderSystem::getActiveD3D9Device();				
		DeviceToQueryIterator it      = mMapDeviceToQuery.find(pCurDevice);
		
		if (it == mMapDeviceToQuery.end())
		{
			OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, 
				"End occlusion called without matching begin call !!", 
				"D3D9HardwareOcclusionQuery::endOcclusionQuery" );
		}

		IDirect3DQuery9* pOccQuery = mMapDeviceToQuery[pCurDevice];

		if (pOccQuery != NULL)
			pOccQuery->Issue(D3DISSUE_END); 
	}	

void Display::sync(bool block)
{
    HRESULT result;

    IDirect3DQuery9* query = allocateEventQuery();
    if (!query)
    {
        return;
    }

    result = query->Issue(D3DISSUE_END);
    ASSERT(SUCCEEDED(result));

    do
    {
        result = query->GetData(NULL, 0, D3DGETDATA_FLUSH);

        if(block && result == S_FALSE)
        {
            // Keep polling, but allow other threads to do something useful first
            Sleep(0);
            // explicitly check for device loss
            // some drivers seem to return S_FALSE even if the device is lost
            // instead of D3DERR_DEVICELOST like they should
            if (testDeviceLost())
            {
                result = D3DERR_DEVICELOST;
            }
        }
    }
    while(block && result == S_FALSE);

    freeEventQuery(query);

    if (isDeviceLostError(result))
    {
        notifyDeviceLost();
    }
}

 void onEndFrame()
 {
    disjointQuery->Issue(D3DISSUE_END);
 }