Home | History | Annotate | Download | only in libGLESv2 
      1 #include "precompiled.h"
      2 //
      3 // Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
      4 // Use of this source code is governed by a BSD-style license that can be
      5 // found in the LICENSE file.
      6 //
      7 
      8 // angletypes.h : Defines a variety of structures and enum types that are used throughout libGLESv2
      9 
     10 #include "libGLESv2/angletypes.h"
     11 #include "libGLESv2/ProgramBinary.h"
     12 #include "libGLESv2/VertexAttribute.h"
     13 
     14 namespace gl
     15 {
     16 
     17 bool SamplerState::swizzleRequired() const
     18 {
     19     return swizzleRed != GL_RED || swizzleGreen != GL_GREEN ||
     20            swizzleBlue != GL_BLUE || swizzleAlpha != GL_ALPHA;
     21 }
     22 
     23 static void MinMax(int a, int b, int *minimum, int *maximum)
     24 {
     25     if (a < b)
     26     {
     27         *minimum = a;
     28         *maximum = b;
     29     }
     30     else
     31     {
     32         *minimum = b;
     33         *maximum = a;
     34     }
     35 }
     36 
     37 bool ClipRectangle(const Rectangle &source, const Rectangle &clip, Rectangle *intersection)
     38 {
     39     int minSourceX, maxSourceX, minSourceY, maxSourceY;
     40     MinMax(source.x, source.x + source.width, &minSourceX, &maxSourceX);
     41     MinMax(source.y, source.y + source.height, &minSourceY, &maxSourceY);
     42 
     43     int minClipX, maxClipX, minClipY, maxClipY;
     44     MinMax(clip.x, clip.x + clip.width, &minClipX, &maxClipX);
     45     MinMax(clip.y, clip.y + clip.height, &minClipY, &maxClipY);
     46 
     47     if (minSourceX >= maxClipX || maxSourceX <= minClipX || minSourceY >= maxClipY || maxSourceY <= minClipY)
     48     {
     49         if (intersection)
     50         {
     51             intersection->x = minSourceX;
     52             intersection->y = maxSourceY;
     53             intersection->width = maxSourceX - minSourceX;
     54             intersection->height = maxSourceY - minSourceY;
     55         }
     56 
     57         return false;
     58     }
     59     else
     60     {
     61         if (intersection)
     62         {
     63             intersection->x = std::max(minSourceX, minClipX);
     64             intersection->y = std::max(minSourceY, minClipY);
     65             intersection->width  = std::min(maxSourceX, maxClipX) - std::max(minSourceX, minClipX);
     66             intersection->height = std::min(maxSourceY, maxClipY) - std::max(minSourceY, minClipY);
     67         }
     68 
     69         return true;
     70     }
     71 }
     72 
     73 VertexFormat::VertexFormat()
     74     : mType(GL_NONE),
     75       mNormalized(GL_FALSE),
     76       mComponents(0),
     77       mPureInteger(false)
     78 {}
     79 
     80 VertexFormat::VertexFormat(GLenum type, GLboolean normalized, GLuint components, bool pureInteger)
     81     : mType(type),
     82       mNormalized(normalized),
     83       mComponents(components),
     84       mPureInteger(pureInteger)
     85 {
     86     // Float data can not be normalized, so ignore the user setting
     87     if (mType == GL_FLOAT || mType == GL_HALF_FLOAT || mType == GL_FIXED)
     88     {
     89         mNormalized = GL_FALSE;
     90     }
     91 }
     92 
     93 VertexFormat::VertexFormat(const VertexAttribute &attribute)
     94     : mType(attribute.mType),
     95       mNormalized(attribute.mNormalized ? GL_TRUE : GL_FALSE),
     96       mComponents(attribute.mSize),
     97       mPureInteger(attribute.mPureInteger)
     98 {
     99     // Ensure we aren't initializing a vertex format which should be using
    100     // the current-value type
    101     ASSERT(attribute.mArrayEnabled);
    102 
    103     // Float data can not be normalized, so ignore the user setting
    104     if (mType == GL_FLOAT || mType == GL_HALF_FLOAT || mType == GL_FIXED)
    105     {
    106         mNormalized = GL_FALSE;
    107     }
    108 }
    109 
    110 VertexFormat::VertexFormat(const VertexAttribute &attribute, GLenum currentValueType)
    111     : mType(attribute.mType),
    112       mNormalized(attribute.mNormalized ? GL_TRUE : GL_FALSE),
    113       mComponents(attribute.mSize),
    114       mPureInteger(attribute.mPureInteger)
    115 {
    116     if (!attribute.mArrayEnabled)
    117     {
    118         mType = currentValueType;
    119         mNormalized = GL_FALSE;
    120         mComponents = 4;
    121         mPureInteger = (currentValueType != GL_FLOAT);
    122     }
    123 
    124     // Float data can not be normalized, so ignore the user setting
    125     if (mType == GL_FLOAT || mType == GL_HALF_FLOAT || mType == GL_FIXED)
    126     {
    127         mNormalized = GL_FALSE;
    128     }
    129 }
    130 
    131 void VertexFormat::GetInputLayout(VertexFormat *inputLayout,
    132                                   ProgramBinary *programBinary,
    133                                   const VertexAttribute *attributes,
    134                                   const gl::VertexAttribCurrentValueData *currentValues)
    135 {
    136     for (unsigned int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
    137     {
    138         int semanticIndex = programBinary->getSemanticIndex(attributeIndex);
    139 
    140         if (semanticIndex != -1)
    141         {
    142             inputLayout[semanticIndex] = VertexFormat(attributes[attributeIndex], currentValues[attributeIndex].Type);
    143         }
    144     }
    145 }
    146 
    147 bool VertexFormat::operator==(const VertexFormat &other) const
    148 {
    149     return (mType == other.mType                &&
    150             mComponents == other.mComponents    &&
    151             mNormalized == other.mNormalized    &&
    152             mPureInteger == other.mPureInteger  );
    153 }
    154 
    155 bool VertexFormat::operator!=(const VertexFormat &other) const
    156 {
    157     return !(*this == other);
    158 }
    159 
    160 bool VertexFormat::operator<(const VertexFormat& other) const
    161 {
    162     if (mType != other.mType)
    163     {
    164         return mType < other.mType;
    165     }
    166     if (mNormalized != other.mNormalized)
    167     {
    168         return mNormalized < other.mNormalized;
    169     }
    170     if (mComponents != other.mComponents)
    171     {
    172         return mComponents < other.mComponents;
    173     }
    174     return mPureInteger < other.mPureInteger;
    175 }
    176 
    177 }
    178