kc3-lang/angle/src/libANGLE/renderer/d3d/d3d9/Query9.cpp

• Show log

  Commit

• Hash : ad3ae90a
  Author :
  Date : 2018-03-09T13:40:42
  

  Use packed enums for QueryType.
  
  BUG=angleproject:2169
  
  Change-Id: I129a9d8e295859daa071a298dab9fe1895315cc0
  Reviewed-on: https://chromium-review.googlesource.com/957318
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/d3d9/Query9.cpp

• //
  // Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // Query9.cpp: Defines the rx::Query9 class which implements rx::QueryImpl.
  
  #include "libANGLE/renderer/d3d/d3d9/Query9.h"
  #include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h"
  #include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
  
  #include <GLES2/gl2ext.h>
  
  namespace rx
  {
  Query9::Query9(Renderer9 *renderer, gl::QueryType type)
      : QueryImpl(type),
        mGetDataAttemptCount(0),
        mResult(GL_FALSE),
        mQueryFinished(false),
        mRenderer(renderer),
        mQuery(nullptr)
  {
  }
  
  Query9::~Query9()
  {
      SafeRelease(mQuery);
  }
  
  gl::Error Query9::begin()
  {
      D3DQUERYTYPE d3dQueryType = gl_d3d9::ConvertQueryType(getType());
      if (mQuery == nullptr)
      {
          HRESULT result = mRenderer->getDevice()->CreateQuery(d3dQueryType, &mQuery);
          if (FAILED(result))
          {
              return gl::OutOfMemory() << "Internal query creation failed, " << gl::FmtHR(result);
          }
      }
  
      if (d3dQueryType != D3DQUERYTYPE_EVENT)
      {
          HRESULT result = mQuery->Issue(D3DISSUE_BEGIN);
          ASSERT(SUCCEEDED(result));
          if (FAILED(result))
          {
              return gl::OutOfMemory() << "Failed to begin internal query, " << gl::FmtHR(result);
          }
      }
  
      return gl::NoError();
  }
  
  gl::Error Query9::end()
  {
      ASSERT(mQuery);
  
      HRESULT result = mQuery->Issue(D3DISSUE_END);
      ASSERT(SUCCEEDED(result));
      if (FAILED(result))
      {
          return gl::OutOfMemory() << "Failed to end internal query, " << gl::FmtHR(result);
      }
  
      mQueryFinished = false;
      mResult = GL_FALSE;
  
      return gl::NoError();
  }
  
  gl::Error Query9::queryCounter()
  {
      UNIMPLEMENTED();
      return gl::InternalError() << "Unimplemented";
  }
  
  template <typename T>
  gl::Error Query9::getResultBase(T *params)
  {
      while (!mQueryFinished)
      {
          gl::Error error = testQuery();
          if (error.isError())
          {
              return error;
          }
  
          if (!mQueryFinished)
          {
              Sleep(0);
          }
      }
  
      ASSERT(mQueryFinished);
      *params = static_cast<T>(mResult);
      return gl::NoError();
  }
  
  gl::Error Query9::getResult(GLint *params)
  {
      return getResultBase(params);
  }
  
  gl::Error Query9::getResult(GLuint *params)
  {
      return getResultBase(params);
  }
  
  gl::Error Query9::getResult(GLint64 *params)
  {
      return getResultBase(params);
  }
  
  gl::Error Query9::getResult(GLuint64 *params)
  {
      return getResultBase(params);
  }
  
  gl::Error Query9::isResultAvailable(bool *available)
  {
      gl::Error error = testQuery();
      if (error.isError())
      {
          return error;
      }
  
      *available = mQueryFinished;
  
      return gl::NoError();
  }
  
  gl::Error Query9::testQuery()
  {
      if (!mQueryFinished)
      {
          ASSERT(mQuery);
  
          HRESULT result = S_OK;
          switch (getType())
          {
              case gl::QueryType::AnySamples:
              case gl::QueryType::AnySamplesConservative:
              {
                  DWORD numPixels = 0;
                  result = mQuery->GetData(&numPixels, sizeof(numPixels), D3DGETDATA_FLUSH);
                  if (result == S_OK)
                  {
                      mQueryFinished = true;
                      mResult        = (numPixels > 0) ? GL_TRUE : GL_FALSE;
                  }
                  break;
              }
  
              case gl::QueryType::CommandsCompleted:
              {
                  BOOL completed = FALSE;
                  result = mQuery->GetData(&completed, sizeof(completed), D3DGETDATA_FLUSH);
                  if (result == S_OK)
                  {
                      mQueryFinished = true;
                      mResult        = (completed == TRUE) ? GL_TRUE : GL_FALSE;
                  }
                  break;
              }
  
              default:
                  UNREACHABLE();
                  break;
          }
  
          if (!mQueryFinished)
          {
              if (d3d9::isDeviceLostError(result))
              {
                  mRenderer->notifyDeviceLost();
                  return gl::OutOfMemory() << "Failed to test get query result, device is lost.";
              }
  
              mGetDataAttemptCount++;
              bool checkDeviceLost =
                  (mGetDataAttemptCount % kPollingD3DDeviceLostCheckFrequency) == 0;
              if (checkDeviceLost && mRenderer->testDeviceLost())
              {
                  mRenderer->notifyDeviceLost();
                  return gl::OutOfMemory() << "Failed to test get query result, device is lost.";
              }
          }
      }
  
      return gl::NoError();
  }
  
  }
  

Download