kc3-lang/angle/util/Vector.h

• Show log

  Commit

• Hash : 9fc3682c
  Author :
  Date : 2015-11-18T13:08:07
  

  D3D: Rework varying packing code.
  
  In D3D we pack varyings by making a register map, and using the
  recommended GLSL ES algorithm to reserve register space. We use
  this map to assign row and column slots to each varying and then
  produce a semantic index value.
  
  The existing scheme had a number of bugs, and was failing several
  angle_end2end_tests. The new design cleans up the code somewhat
  and uses a different counting scheme for the semantic indexes:
  just sort the varyings in packing order and use a simple
  incrementing semantic index per varying. In SM4+, the HLSL compiler
  sorts and packs the varyings correctly itself, and in SM3, handle
  the cases we don't support by returning an error instead of a D3D
  compiler link error.
  
  Also refactor how we store varying information for TF Feedback/
  StreamOut. Only store the necessary D3D information, instead of
  extra information like the name and type.
  
  This fixes several tests in GLSLTest/*. This also will allow us to
  fix interpolation qualifier packing and the structure packing in
  HLSL, which seems to work differently than the rest of the varying
  types.
  
  BUG=angleproject:1202
  TEST=bots,dEQP-GLES3.functional.transform_feedback.*
  
  Change-Id: Ie5bfbb4f71d8bf97f39115fc46d2e61b131df639
  Reviewed-on: https://chromium-review.googlesource.com/311241
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• util/Vector.h

• //
  // 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.
  //
  // Vector:
  //   Vector class for linear math.
  //
  
  #ifndef UTIL_VECTOR_H
  #define UTIL_VECTOR_H
  
  #include <ostream>
  
  struct Vector2
  {
      Vector2();
      Vector2(float x, float y);
  
      bool operator==(const Vector2 &vec) const;
      bool operator!=(const Vector2 &vec) const;
  
      static float length(const Vector2 &vec);
      static float lengthSquared(const Vector2 &vec);
  
      static Vector2 normalize(const Vector2 &vec);
  
      float *data() { return &x; }
      const float *data() const { return &x; }
  
      float x, y;
  };
  
  std::ostream &operator<<(std::ostream &stream, const Vector2 &vec);
  
  struct Vector3
  {
      Vector3();
      Vector3(float x, float y, float z);
  
      static float length(const Vector3 &vec);
      static float lengthSquared(const Vector3 &vec);
  
      static Vector3 normalize(const Vector3 &vec);
  
      static float dot(const Vector3 &a, const Vector3 &b);
      static Vector3 cross(const Vector3 &a, const Vector3 &b);
  
      float *data() { return &x; }
      const float *data() const { return &x; }
  
      float x, y, z;
  };
  
  Vector3 operator*(const Vector3 &a, const Vector3 &b);
  Vector3 operator*(const Vector3 &a, const float &b);
  Vector3 operator/(const Vector3 &a, const Vector3 &b);
  Vector3 operator/(const Vector3 &a, const float &b);
  Vector3 operator+(const Vector3 &a, const Vector3 &b);
  Vector3 operator-(const Vector3 &a, const Vector3 &b);
  
  struct Vector4
  {
      Vector4();
      Vector4(float x, float y, float z, float w);
  
      static float length(const Vector4 &vec);
      static float lengthSquared(const Vector4 &vec);
  
      static Vector4 normalize(const Vector4 &vec);
  
      static float dot(const Vector4 &a, const Vector4 &b);
  
      float *data() { return &x; }
      const float *data() const { return &x; }
  
      float x, y, z, w;
  };
  
  #endif  // UTIL_VECTOR_H
  

Download