kc3-lang/angle/src/compiler/translator/blocklayoutHLSL.cpp

• Show log

  Commit

• Hash : 73941deb
  Author :
  Date : 2015-02-25T14:34:49
  

  Disable the HLSL code in Angle if it is not being used.
  
  We're only using the HLSL code in Windows so
  it's not necessary to compile and distribute it on other platforms.
  
  This adds a defined ANGLE_ENABLE_HLSL that can be checked in files that
  are used by non-HLSL code as well. Mostly the HLSL code is just not
  include by the build system.
  
  Details of the space savings (heavily truncated)
  
  Total change: -165717 bytes
  ===========================
   -606 - Source: angle/src/common/utilities.cpp
   -627 - Source: angle/src/compiler/translator/FlagStd140Structs.cpp
   -695 - Source: /usr/include/c++/4.8/bits/stl_algo.h
   -710 - Source: angle/src/compiler/translator/TranslatorHLSL.cpp
   -713 - Source: angle/src/compiler/translator/IntermNode.h
   -863 - Source: /usr/include/c++/4.8/bits/stl_map.h
   -935 - Source: angle/src/compiler/translator/blocklayout.cpp
   -1515 - Source: angle/src/compiler/translator/BuiltInFunctionEmulator.cpp
   -1655 - Source: angle/src/compiler/translator/UnfoldShortCircuit.cpp
   -2375 - Source: /usr/include/c++/4.8/bits/vector.tcc
   -3135 - Source: angle/src/compiler/translator/RewriteElseBlocks.cpp
   -4656 - Source: angle/src/compiler/translator/UtilsHLSL.cpp
   -5265 - Source: angle/src/compiler/translator/BuiltInFunctionEmulatorHLSL.cpp
   -6505 - Source: /usr/include/c++/4.8/bits/stl_tree.h
   -11480 - Source: angle/src/compiler/translator/UniformHLSL.cpp
   -13580 - Source: angle/src/compiler/translator/StructureHLSL.cpp
   -18964 - Source: ??
      (constant strings and a few vtbls)
   -89332 - Source: angle/src/compiler/translator/OutputHLSL.cpp
  
  Change-Id: I23ccc98abd0a21f847dd34f9482800b3ba679d56
  Reviewed-on: https://chromium-review.googlesource.com/251528
  Tested-by: bratell at Opera <bratell@opera.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/compiler/translator/blocklayoutHLSL.cpp

• //
  // Copyright (c) 2013-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.
  //
  // blocklayout.cpp:
  //   Implementation for block layout classes and methods.
  //
  
  #include "compiler/translator/blocklayoutHLSL.h"
  
  #include "common/mathutil.h"
  #include "common/utilities.h"
  
  namespace sh
  {
  
  HLSLBlockEncoder::HLSLBlockEncoder(HLSLBlockEncoderStrategy strategy)
      : mEncoderStrategy(strategy),
        mTransposeMatrices(false)
  {
  }
  
  void HLSLBlockEncoder::enterAggregateType()
  {
      nextRegister();
  }
  
  void HLSLBlockEncoder::exitAggregateType()
  {
  }
  
  void HLSLBlockEncoder::getBlockLayoutInfo(GLenum typeIn, unsigned int arraySize, bool isRowMajorMatrix, int *arrayStrideOut, int *matrixStrideOut)
  {
      GLenum type = (mTransposeMatrices ? gl::TransposeMatrixType(typeIn) : typeIn);
  
      // We assume we are only dealing with 4 byte components (no doubles or half-words currently)
      ASSERT(gl::VariableComponentSize(gl::VariableComponentType(type)) == BytesPerComponent);
  
      int matrixStride = 0;
      int arrayStride = 0;
  
      // if variables are not to be packed, or we're about to
      // pack a matrix or array, skip to the start of the next
      // register
      if (!isPacked() ||
          gl::IsMatrixType(type) ||
          arraySize > 0)
      {
          nextRegister();
      }
  
      if (gl::IsMatrixType(type))
      {
          matrixStride = ComponentsPerRegister;
  
          if (arraySize > 0)
          {
              const int numRegisters = gl::MatrixRegisterCount(type, isRowMajorMatrix);
              arrayStride = ComponentsPerRegister * numRegisters;
          }
      }
      else if (arraySize > 0)
      {
          arrayStride = ComponentsPerRegister;
      }
      else if (isPacked())
      {
          int numComponents = gl::VariableComponentCount(type);
          if ((numComponents + (mCurrentOffset % ComponentsPerRegister)) > ComponentsPerRegister)
          {
              nextRegister();
          }
      }
  
      *matrixStrideOut = matrixStride;
      *arrayStrideOut = arrayStride;
  }
  
  void HLSLBlockEncoder::advanceOffset(GLenum typeIn, unsigned int arraySize, bool isRowMajorMatrix, int arrayStride, int matrixStride)
  {
      GLenum type = (mTransposeMatrices ? gl::TransposeMatrixType(typeIn) : typeIn);
  
      if (arraySize > 0)
      {
          mCurrentOffset += arrayStride * (arraySize - 1);
      }
  
      if (gl::IsMatrixType(type))
      {
          ASSERT(matrixStride == ComponentsPerRegister);
          const int numRegisters = gl::MatrixRegisterCount(type, isRowMajorMatrix);
          const int numComponents = gl::MatrixComponentCount(type, isRowMajorMatrix);
          mCurrentOffset += ComponentsPerRegister * (numRegisters - 1);
          mCurrentOffset += numComponents;
      }
      else if (isPacked())
      {
          mCurrentOffset += gl::VariableComponentCount(type);
      }
      else
      {
          mCurrentOffset += ComponentsPerRegister;
      }
  }
  
  void HLSLBlockEncoder::skipRegisters(unsigned int numRegisters)
  {
      mCurrentOffset += (numRegisters * ComponentsPerRegister);
  }
  
  HLSLBlockEncoder::HLSLBlockEncoderStrategy HLSLBlockEncoder::GetStrategyFor(ShShaderOutput outputType)
  {
      switch (outputType)
      {
        case SH_HLSL9_OUTPUT: return ENCODE_LOOSE;
        case SH_HLSL11_OUTPUT: return ENCODE_PACKED;
        default: UNREACHABLE(); return ENCODE_PACKED;
      }
  }
  
  template <class ShaderVarType>
  void HLSLVariableRegisterCount(const ShaderVarType &variable, HLSLBlockEncoder *encoder)
  {
      if (variable.isStruct())
      {
          for (size_t arrayElement = 0; arrayElement < variable.elementCount(); arrayElement++)
          {
              encoder->enterAggregateType();
  
              for (size_t fieldIndex = 0; fieldIndex < variable.fields.size(); fieldIndex++)
              {
                  HLSLVariableRegisterCount(variable.fields[fieldIndex], encoder);
              }
  
              encoder->exitAggregateType();
          }
      }
      else
      {
          // We operate only on varyings and uniforms, which do not have matrix layout qualifiers
          encoder->encodeType(variable.type, variable.arraySize, false);
      }
  }
  
  unsigned int HLSLVariableRegisterCount(const Varying &variable, bool transposeMatrices)
  {
      HLSLBlockEncoder encoder(HLSLBlockEncoder::ENCODE_PACKED);
      encoder.setTransposeMatrices(transposeMatrices);
      HLSLVariableRegisterCount(variable, &encoder);
  
      const size_t registerBytes = (encoder.BytesPerComponent * encoder.ComponentsPerRegister);
      return static_cast<unsigned int>(rx::roundUp<size_t>(encoder.getBlockSize(), registerBytes) / registerBytes);
  }
  
  unsigned int HLSLVariableRegisterCount(const Uniform &variable, ShShaderOutput outputType)
  {
      HLSLBlockEncoder encoder(HLSLBlockEncoder::GetStrategyFor(outputType));
      HLSLVariableRegisterCount(variable, &encoder);
  
      const size_t registerBytes = (encoder.BytesPerComponent * encoder.ComponentsPerRegister);
      return static_cast<unsigned int>(rx::roundUp<size_t>(encoder.getBlockSize(), registerBytes) / registerBytes);
  }
  
  }
  

Download