kc3-lang/angle/src/libGLESv2/renderer/d3d/ProgramD3D.cpp

• Show log

  Commit

• Hash : bdee2d59
  Author :
  Date : 2014-09-17T11:02:51
  

  Fix incorrect error check.
  
  The registers variable became a pointer but this error check was not
  updated.
  
  BUG=angle:743
  
  Change-Id: Id2cd7b5ba39180281a3bbc408cd7c31bc663500c
  Reviewed-on: https://chromium-review.googlesource.com/218507
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Tested-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libGLESv2/renderer/d3d/ProgramD3D.cpp

• //
  // Copyright (c) 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.
  //
  
  // ProgramD3D.cpp: Defines the rx::ProgramD3D class which implements rx::ProgramImpl.
  
  #include "libGLESv2/renderer/d3d/ProgramD3D.h"
  
  #include "common/utilities.h"
  #include "libGLESv2/ProgramBinary.h"
  #include "libGLESv2/renderer/Renderer.h"
  #include "libGLESv2/renderer/ShaderExecutable.h"
  #include "libGLESv2/renderer/d3d/DynamicHLSL.h"
  #include "libGLESv2/renderer/d3d/ShaderD3D.h"
  #include "libGLESv2/main.h"
  
  namespace rx
  {
  
  ProgramD3D::ProgramD3D(rx::Renderer *renderer)
      : ProgramImpl(),
        mRenderer(renderer),
        mDynamicHLSL(NULL),
        mVertexWorkarounds(rx::ANGLE_D3D_WORKAROUND_NONE),
        mPixelWorkarounds(rx::ANGLE_D3D_WORKAROUND_NONE),
        mVertexUniformStorage(NULL),
        mFragmentUniformStorage(NULL)
  {
      mDynamicHLSL = new rx::DynamicHLSL(renderer);
  }
  
  ProgramD3D::~ProgramD3D()
  {
      reset();
      SafeDelete(mDynamicHLSL);
  }
  
  ProgramD3D *ProgramD3D::makeProgramD3D(ProgramImpl *impl)
  {
      ASSERT(HAS_DYNAMIC_TYPE(ProgramD3D*, impl));
      return static_cast<ProgramD3D*>(impl);
  }
  
  const ProgramD3D *ProgramD3D::makeProgramD3D(const ProgramImpl *impl)
  {
      ASSERT(HAS_DYNAMIC_TYPE(const ProgramD3D*, impl));
      return static_cast<const ProgramD3D*>(impl);
  }
  
  bool ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
  {
      stream->readString(&mVertexHLSL);
      stream->readInt(&mVertexWorkarounds);
      stream->readString(&mPixelHLSL);
      stream->readInt(&mPixelWorkarounds);
      stream->readBool(&mUsesFragDepth);
  
      const size_t pixelShaderKeySize = stream->readInt<unsigned int>();
      mPixelShaderKey.resize(pixelShaderKeySize);
      for (size_t pixelShaderKeyIndex = 0; pixelShaderKeyIndex < pixelShaderKeySize; pixelShaderKeyIndex++)
      {
          stream->readInt(&mPixelShaderKey[pixelShaderKeyIndex].type);
          stream->readString(&mPixelShaderKey[pixelShaderKeyIndex].name);
          stream->readString(&mPixelShaderKey[pixelShaderKeyIndex].source);
          stream->readInt(&mPixelShaderKey[pixelShaderKeyIndex].outputIndex);
      }
  
      return true;
  }
  
  bool ProgramD3D::save(gl::BinaryOutputStream *stream)
  {
      stream->writeString(mVertexHLSL);
      stream->writeInt(mVertexWorkarounds);
      stream->writeString(mPixelHLSL);
      stream->writeInt(mPixelWorkarounds);
      stream->writeInt(mUsesFragDepth);
  
      const std::vector<rx::PixelShaderOutputVariable> &pixelShaderKey = mPixelShaderKey;
      stream->writeInt(pixelShaderKey.size());
      for (size_t pixelShaderKeyIndex = 0; pixelShaderKeyIndex < pixelShaderKey.size(); pixelShaderKeyIndex++)
      {
          const rx::PixelShaderOutputVariable &variable = pixelShaderKey[pixelShaderKeyIndex];
          stream->writeInt(variable.type);
          stream->writeString(variable.name);
          stream->writeString(variable.source);
          stream->writeInt(variable.outputIndex);
      }
  
      return true;
  }
  
  rx::ShaderExecutable *ProgramD3D::getPixelExecutableForOutputLayout(gl::InfoLog &infoLog, const std::vector<GLenum> &outputSignature,
                                                                      const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
                                                                      bool separatedOutputBuffers)
  {
      std::string finalPixelHLSL = mDynamicHLSL->generatePixelShaderForOutputSignature(mPixelHLSL, mPixelShaderKey, mUsesFragDepth,
                                                                                       outputSignature);
  
      // Generate new pixel executable
      rx::ShaderExecutable *pixelExecutable = mRenderer->compileToExecutable(infoLog, finalPixelHLSL.c_str(), rx::SHADER_PIXEL,
                                                                             transformFeedbackLinkedVaryings, separatedOutputBuffers,
                                                                             mPixelWorkarounds);
  
      return pixelExecutable;
  }
  
  rx::ShaderExecutable *ProgramD3D::getVertexExecutableForInputLayout(gl::InfoLog &infoLog,
                                                                      const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS],
                                                                      const sh::Attribute shaderAttributes[],
                                                                      const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
                                                                      bool separatedOutputBuffers)
  {
      // Generate new dynamic layout with attribute conversions
      std::string finalVertexHLSL = mDynamicHLSL->generateVertexShaderForInputLayout(mVertexHLSL, inputLayout, shaderAttributes);
  
      // Generate new vertex executable
      rx::ShaderExecutable *vertexExecutable = mRenderer->compileToExecutable(infoLog, finalVertexHLSL.c_str(),
                                                                              rx::SHADER_VERTEX,
                                                                              transformFeedbackLinkedVaryings, separatedOutputBuffers,
                                                                              mVertexWorkarounds);
  
      return vertexExecutable;
  }
  
  bool ProgramD3D::link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
                        const std::vector<std::string> &transformFeedbackVaryings, int *registers,
                        std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int, gl::VariableLocation> *outputVariables)
  {
      rx::ShaderD3D *vertexShaderD3D = rx::ShaderD3D::makeShaderD3D(vertexShader->getImplementation());
      rx::ShaderD3D *fragmentShaderD3D = rx::ShaderD3D::makeShaderD3D(fragmentShader->getImplementation());
  
      mPixelHLSL = fragmentShaderD3D->getTranslatedSource();
      mPixelWorkarounds = fragmentShaderD3D->getD3DWorkarounds();
  
      mVertexHLSL = vertexShaderD3D->getTranslatedSource();
      mVertexWorkarounds = vertexShaderD3D->getD3DWorkarounds();
  
      // Map the varyings to the register file
      rx::VaryingPacking packing = { NULL };
      *registers = mDynamicHLSL->packVaryings(infoLog, packing, fragmentShaderD3D, vertexShaderD3D, transformFeedbackVaryings);
  
      if (*registers < 0)
      {
          return false;
      }
  
      if (!gl::ProgramBinary::linkVaryings(infoLog, fragmentShader, vertexShader))
      {
          return false;
      }
  
      if (!mDynamicHLSL->generateShaderLinkHLSL(infoLog, *registers, packing, mPixelHLSL, mVertexHLSL,
                                                fragmentShaderD3D, vertexShaderD3D, transformFeedbackVaryings,
                                                linkedVaryings, outputVariables, &mPixelShaderKey, &mUsesFragDepth))
      {
          return false;
      }
  
      return true;
  }
  
  void ProgramD3D::initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms)
  {
      // Compute total default block size
      unsigned int vertexRegisters = 0;
      unsigned int fragmentRegisters = 0;
      for (size_t uniformIndex = 0; uniformIndex < uniforms.size(); uniformIndex++)
      {
          const gl::LinkedUniform &uniform = *uniforms[uniformIndex];
  
          if (!gl::IsSampler(uniform.type))
          {
              if (uniform.isReferencedByVertexShader())
              {
                  vertexRegisters = std::max(vertexRegisters, uniform.vsRegisterIndex + uniform.registerCount);
              }
              if (uniform.isReferencedByFragmentShader())
              {
                  fragmentRegisters = std::max(fragmentRegisters, uniform.psRegisterIndex + uniform.registerCount);
              }
          }
      }
  
      mVertexUniformStorage = mRenderer->createUniformStorage(vertexRegisters * 16u);
      mFragmentUniformStorage = mRenderer->createUniformStorage(fragmentRegisters * 16u);
  }
  
  void ProgramD3D::reset()
  {
      mVertexHLSL.clear();
      mVertexWorkarounds = rx::ANGLE_D3D_WORKAROUND_NONE;
  
      mPixelHLSL.clear();
      mPixelWorkarounds = rx::ANGLE_D3D_WORKAROUND_NONE;
      mUsesFragDepth = false;
      mPixelShaderKey.clear();
  
      SafeDelete(mVertexUniformStorage);
      SafeDelete(mFragmentUniformStorage);
  }
  
  }
  

Download