chromium/third_party/angle/src/compiler/translator/ShaderVars.cpp

//
// Copyright 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.
//
// ShaderVars.cpp:
//  Methods for GL variable types (varyings, uniforms, etc)
//

#include <GLSLANG/ShaderLang.h>

#include "common/debug.h"
#include "common/utilities.h"

namespace sh
{

namespace
{

InterpolationType GetNonAuxiliaryInterpolationType(InterpolationType interpolation)
{ … }
}  // namespace
// The ES 3.0 spec is not clear on this point, but the ES 3.1 spec, and discussion
// on Khronos.org, clarifies that a smooth/flat mismatch produces a link error,
// but auxiliary qualifier mismatch (centroid) does not.
bool InterpolationTypesMatch(InterpolationType a, InterpolationType b)
{ … }

ShaderVariable::ShaderVariable() : … { … }

ShaderVariable::ShaderVariable(GLenum typeIn)
    : … { … }

ShaderVariable::ShaderVariable(GLenum typeIn, unsigned int arraySizeIn) : … { … }

ShaderVariable::~ShaderVariable() { … }

ShaderVariable::ShaderVariable(const ShaderVariable &other)
    : … { … }

ShaderVariable &ShaderVariable::operator=(const ShaderVariable &other)
{ … }

bool ShaderVariable::operator==(const ShaderVariable &other) const
{ … }

void ShaderVariable::setArraySize(unsigned int size)
{ … }

unsigned int ShaderVariable::getInnerArraySizeProduct() const
{ … }

unsigned int ShaderVariable::getArraySizeProduct() const
{ … }

void ShaderVariable::indexIntoArray(unsigned int arrayIndex)
{ … }

unsigned int ShaderVariable::getNestedArraySize(unsigned int arrayNestingIndex) const
{ … }

unsigned int ShaderVariable::getBasicTypeElementCount() const
{ … }

unsigned int ShaderVariable::getExternalSize() const
{ … }

bool ShaderVariable::findInfoByMappedName(const std::string &mappedFullName,
                                          const ShaderVariable **leafVar,
                                          std::string *originalFullName) const
{ … }

const sh::ShaderVariable *ShaderVariable::findField(const std::string &fullName,
                                                    uint32_t *fieldIndexOut) const
{ … }

bool ShaderVariable::isBuiltIn() const
{ … }

bool ShaderVariable::isEmulatedBuiltIn() const
{ … }

bool ShaderVariable::isSameVariableAtLinkTime(const ShaderVariable &other,
                                              bool matchPrecision,
                                              bool matchName) const
{ … }

void ShaderVariable::updateEffectiveLocation(const sh::ShaderVariable &parent)
{ … }

void ShaderVariable::resetEffectiveLocation()
{ … }

bool ShaderVariable::isSameUniformAtLinkTime(const ShaderVariable &other) const
{ … }

bool ShaderVariable::isSameInterfaceBlockFieldAtLinkTime(const ShaderVariable &other) const
{ … }

bool ShaderVariable::isSameVaryingAtLinkTime(const ShaderVariable &other) const
{ … }

bool ShaderVariable::isSameVaryingAtLinkTime(const ShaderVariable &other, int shaderVersion) const
{ … }

bool ShaderVariable::isSameNameAtLinkTime(const ShaderVariable &other) const
{ … }

InterfaceBlock::InterfaceBlock()
    : … { … }

InterfaceBlock::~InterfaceBlock() { … }

InterfaceBlock::InterfaceBlock(const InterfaceBlock &other)
    : … { … }

InterfaceBlock &InterfaceBlock::operator=(const InterfaceBlock &other)
{ … }

std::string InterfaceBlock::fieldPrefix() const
{ … }

std::string InterfaceBlock::fieldMappedPrefix() const
{ … }

bool InterfaceBlock::isSameInterfaceBlockAtLinkTime(const InterfaceBlock &other) const
{ … }

bool InterfaceBlock::isBuiltIn() const
{ … }

void WorkGroupSize::fill(int fillValue)
{ … }

void WorkGroupSize::setLocalSize(int localSizeX, int localSizeY, int localSizeZ)
{ … }

// check that if one of them is less than 1, then all of them are.
// Or if one is positive, then all of them are positive.
bool WorkGroupSize::isLocalSizeValid() const
{ … }

bool WorkGroupSize::isAnyValueSet() const
{ … }

bool WorkGroupSize::isDeclared() const
{ … }

bool WorkGroupSize::isWorkGroupSizeMatching(const WorkGroupSize &right) const
{ … }

int &WorkGroupSize::operator[](size_t index)
{ … }

int WorkGroupSize::operator[](size_t index) const
{ … }

size_t WorkGroupSize::size() const
{ … }

}  // namespace sh