kc3-lang/angle/src/libGLESv2/angletypes.cpp

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2014-02-04 16:04:06
  Hash : 3078d0f7
  Message : Add VertexFormat internal struct to represent vertex inputs. A VertexFormat is similar to a simplified VertexAttribute, without extra unncessary data. VertexFormats will be useful for GPU vertex conversions with dynamic shader compilation. Change-Id: I4e60e0a12d5f081fb52d95c8977c43d481b33bff Reviewed-on: https://chromium-review.googlesource.com/184398 Reviewed-by: Geoff Lang <geofflang@chromium.org> Reviewed-by: Shannon Woods <shannonwoods@chromium.org> Tested-by: Jamie Madill <jmadill@chromium.org>

• src/libGLESv2/angletypes.cpp

• #include "precompiled.h"
  //
  // 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.
  //
  
  // angletypes.h : Defines a variety of structures and enum types that are used throughout libGLESv2
  
  #include "libGLESv2/angletypes.h"
  #include "libGLESv2/ProgramBinary.h"
  #include "libGLESv2/VertexAttribute.h"
  
  namespace gl
  {
  
  static void MinMax(int a, int b, int *minimum, int *maximum)
  {
      if (a < b)
      {
          *minimum = a;
          *maximum = b;
      }
      else
      {
          *minimum = b;
          *maximum = a;
      }
  }
  
  bool ClipRectangle(const Rectangle &source, const Rectangle &clip, Rectangle *intersection)
  {
      int minSourceX, maxSourceX, minSourceY, maxSourceY;
      MinMax(source.x, source.x + source.width, &minSourceX, &maxSourceX);
      MinMax(source.y, source.y + source.height, &minSourceY, &maxSourceY);
  
      int minClipX, maxClipX, minClipY, maxClipY;
      MinMax(clip.x, clip.x + clip.width, &minClipX, &maxClipX);
      MinMax(clip.y, clip.y + clip.height, &minClipY, &maxClipY);
  
      if (minSourceX >= maxClipX || maxSourceX <= minClipX || minSourceY >= maxClipY || maxSourceY <= minClipY)
      {
          if (intersection)
          {
              intersection->x = minSourceX;
              intersection->y = maxSourceY;
              intersection->width = maxSourceX - minSourceX;
              intersection->height = maxSourceY - minSourceY;
          }
  
          return false;
      }
      else
      {
          if (intersection)
          {
              intersection->x = std::max(minSourceX, minClipX);
              intersection->y = std::max(minSourceY, minClipY);
              intersection->width  = std::min(maxSourceX, maxClipX) - std::max(minSourceX, minClipX);
              intersection->height = std::min(maxSourceY, maxClipY) - std::max(minSourceY, minClipY);
          }
  
          return true;
      }
  }
  
  VertexFormat::VertexFormat()
      : mType(GL_NONE),
        mNormalized(GL_FALSE),
        mComponents(0),
        mPureInteger(false)
  {}
  
  VertexFormat::VertexFormat(GLenum type, GLboolean normalized, GLuint components, bool pureInteger)
      : mType(type),
        mNormalized(normalized),
        mComponents(components),
        mPureInteger(pureInteger)
  {
      // Float data can not be normalized, so ignore the user setting
      if (mType == GL_FLOAT || mType == GL_HALF_FLOAT || mType == GL_FIXED)
      {
          mNormalized = GL_FALSE;
      }
  }
  
  VertexFormat::VertexFormat(const VertexAttribute &attribute)
      : mType(attribute.mType),
        mNormalized(attribute.mNormalized ? GL_TRUE : GL_FALSE),
        mComponents(attribute.mSize),
        mPureInteger(attribute.mPureInteger)
  {
      // Ensure we aren't initializing a vertex format which should be using
      // the current-value type
      ASSERT(attribute.mArrayEnabled);
  
      // Float data can not be normalized, so ignore the user setting
      if (mType == GL_FLOAT || mType == GL_HALF_FLOAT || mType == GL_FIXED)
      {
          mNormalized = GL_FALSE;
      }
  }
  
  VertexFormat::VertexFormat(const VertexAttribute &attribute, GLenum currentValueType)
      : mType(attribute.mType),
        mNormalized(attribute.mNormalized ? GL_TRUE : GL_FALSE),
        mComponents(attribute.mSize),
        mPureInteger(attribute.mPureInteger)
  {
      if (!attribute.mArrayEnabled)
      {
          mType = currentValueType;
          mNormalized = GL_FALSE;
          mComponents = 4;
          mPureInteger = (currentValueType != GL_FLOAT);
      }
  
      // Float data can not be normalized, so ignore the user setting
      if (mType == GL_FLOAT || mType == GL_HALF_FLOAT || mType == GL_FIXED)
      {
          mNormalized = GL_FALSE;
      }
  }
  
  void VertexFormat::GetInputLayout(VertexFormat *inputLayout,
                                    ProgramBinary *programBinary,
                                    const VertexAttribute *attributes,
                                    const gl::VertexAttribCurrentValueData *currentValues)
  {
      for (unsigned int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
      {
          int semanticIndex = programBinary->getSemanticIndex(attributeIndex);
  
          if (semanticIndex != -1)
          {
              inputLayout[semanticIndex] = VertexFormat(attributes[attributeIndex], currentValues[attributeIndex].Type);
          }
      }
  }
  
  bool VertexFormat::operator==(const VertexFormat &other) const
  {
      return (mType == other.mType                &&
              mComponents == other.mComponents    &&
              mNormalized == other.mNormalized    &&
              mPureInteger == other.mPureInteger  );
  }
  
  bool VertexFormat::operator!=(const VertexFormat &other) const
  {
      return !(*this == other);
  }
  
  bool VertexFormat::operator<(const VertexFormat& other) const
  {
      if (mType != other.mType)
      {
          return mType < other.mType;
      }
      if (mNormalized != other.mNormalized)
      {
          return mNormalized < other.mNormalized;
      }
      if (mComponents != other.mComponents)
      {
          return mComponents < other.mComponents;
      }
      return mPureInteger < other.mPureInteger;
  }
  
  }