tor-browser

RendererD3D.cpp (6237B)

---

//
// Copyright 2014 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.
//

// RendererD3D.cpp: Implementation of the base D3D Renderer.

#include "libANGLE/renderer/d3d/RendererD3D.h"

#include "common/MemoryBuffer.h"
#include "common/debug.h"
#include "common/utilities.h"
#include "libANGLE/Context.h"
#include "libANGLE/Display.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/ImageIndex.h"
#include "libANGLE/ResourceManager.h"
#include "libANGLE/State.h"
#include "libANGLE/VertexArray.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/ContextImpl.h"
#include "libANGLE/renderer/TextureImpl.h"
#include "libANGLE/renderer/d3d/BufferD3D.h"
#include "libANGLE/renderer/d3d/DeviceD3D.h"
#include "libANGLE/renderer/d3d/DisplayD3D.h"
#include "libANGLE/renderer/d3d/IndexDataManager.h"
#include "libANGLE/renderer/d3d/ProgramD3D.h"
#include "libANGLE/renderer/d3d/SamplerD3D.h"
#include "libANGLE/renderer/d3d/TextureD3D.h"

namespace rx
{

RendererD3D::RendererD3D(egl::Display *display)
   : mDisplay(display),
     mPresentPathFastEnabled(false),
     mCapsInitialized(false),
     mFeaturesInitialized(false),
     mDisjoint(false),
     mDeviceLost(false)
{}

RendererD3D::~RendererD3D() {}

bool RendererD3D::skipDraw(const gl::State &glState, gl::PrimitiveMode drawMode)
{
   if (drawMode == gl::PrimitiveMode::Points)
   {
       bool usesPointSize = GetImplAs<ProgramD3D>(glState.getProgram())->usesPointSize();

       // ProgramBinary assumes non-point rendering if gl_PointSize isn't written,
       // which affects varying interpolation. Since the value of gl_PointSize is
       // undefined when not written, just skip drawing to avoid unexpected results.
       if (!usesPointSize && !glState.isTransformFeedbackActiveUnpaused())
       {
           // Notify developers of risking undefined behavior.
           WARN() << "Point rendering without writing to gl_PointSize.";
           return true;
       }
   }
   else if (gl::IsTriangleMode(drawMode))
   {
       if (glState.getRasterizerState().cullFace &&
           glState.getRasterizerState().cullMode == gl::CullFaceMode::FrontAndBack)
       {
           return true;
       }
   }

   return false;
}

gl::GraphicsResetStatus RendererD3D::getResetStatus()
{
   if (!mDeviceLost)
   {
       if (testDeviceLost())
       {
           mDeviceLost = true;
           notifyDeviceLost();
           return gl::GraphicsResetStatus::UnknownContextReset;
       }
       return gl::GraphicsResetStatus::NoError;
   }

   if (testDeviceResettable())
   {
       return gl::GraphicsResetStatus::NoError;
   }

   return gl::GraphicsResetStatus::UnknownContextReset;
}

void RendererD3D::notifyDeviceLost()
{
   mDisplay->notifyDeviceLost();
}

void RendererD3D::setGPUDisjoint()
{
   mDisjoint = true;
}

GLint RendererD3D::getGPUDisjoint()
{
   bool disjoint = mDisjoint;

   // Disjoint flag is cleared when read
   mDisjoint = false;

   return disjoint;
}

GLint64 RendererD3D::getTimestamp()
{
   // D3D has no way to get an actual timestamp reliably so 0 is returned
   return 0;
}

void RendererD3D::ensureCapsInitialized() const
{
   if (!mCapsInitialized)
   {
       generateCaps(&mNativeCaps, &mNativeTextureCaps, &mNativeExtensions, &mNativeLimitations);
       mCapsInitialized = true;
   }
}

const gl::Caps &RendererD3D::getNativeCaps() const
{
   ensureCapsInitialized();
   return mNativeCaps;
}

const gl::TextureCapsMap &RendererD3D::getNativeTextureCaps() const
{
   ensureCapsInitialized();
   return mNativeTextureCaps;
}

const gl::Extensions &RendererD3D::getNativeExtensions() const
{
   ensureCapsInitialized();
   return mNativeExtensions;
}

const gl::Limitations &RendererD3D::getNativeLimitations() const
{
   ensureCapsInitialized();
   return mNativeLimitations;
}

ShPixelLocalStorageType RendererD3D::getNativePixelLocalStorageType() const
{
   if (!getNativeExtensions().shaderPixelLocalStorageANGLE)
   {
       return ShPixelLocalStorageType::NotSupported;
   }
   // Read/write UAVs only support "r32*" images.
   return ShPixelLocalStorageType::ImageStoreR32PackedFormats;
}

Serial RendererD3D::generateSerial()
{
   return mSerialFactory.generate();
}

bool InstancedPointSpritesActive(ProgramD3D *programD3D, gl::PrimitiveMode mode)
{
   return programD3D->usesPointSize() && programD3D->usesInstancedPointSpriteEmulation() &&
          mode == gl::PrimitiveMode::Points;
}

angle::Result RendererD3D::initRenderTarget(const gl::Context *context,
                                           RenderTargetD3D *renderTarget)
{
   return clearRenderTarget(context, renderTarget, gl::ColorF(0, 0, 0, 0), 1, 0);
}

const angle::FeaturesD3D &RendererD3D::getFeatures() const
{
   if (!mFeaturesInitialized)
   {
       initializeFeatures(&mFeatures);
       mFeaturesInitialized = true;
   }

   return mFeatures;
}

unsigned int GetBlendSampleMask(const gl::State &glState, int samples)
{
   unsigned int mask = 0;
   if (glState.isSampleCoverageEnabled())
   {
       GLfloat coverageValue = glState.getSampleCoverageValue();
       if (coverageValue != 0)
       {
           float threshold = 0.5f;

           for (int i = 0; i < samples; ++i)
           {
               mask <<= 1;

               if ((i + 1) * coverageValue >= threshold)
               {
                   threshold += 1.0f;
                   mask |= 1;
               }
           }
       }

       bool coverageInvert = glState.getSampleCoverageInvert();
       if (coverageInvert)
       {
           mask = ~mask;
       }
   }
   else
   {
       mask = 0xFFFFFFFF;
   }

   if (glState.isSampleMaskEnabled())
   {
       mask &= glState.getSampleMaskWord(0);
   }

   return mask;
}

GLenum DefaultGLErrorCode(HRESULT hr)
{
   switch (hr)
   {
#ifdef ANGLE_ENABLE_D3D9
       case D3DERR_OUTOFVIDEOMEMORY:
#endif
       case E_OUTOFMEMORY:
           return GL_OUT_OF_MEMORY;
       default:
           return GL_INVALID_OPERATION;
   }
}
}  // namespace rx