SkSL::Layout Struct Reference

#include <SkSLLayout.h>

Public Member Functions
	Layout (LayoutFlags flags, int location, int offset, int binding, int index, int set, int builtin, int inputAttachmentIndex)
constexpr	Layout ()=default
std::string	description () const
std::string	paddedDescription () const
bool	checkPermittedLayout (const Context &context, Position pos, LayoutFlags permittedLayoutFlags) const
bool	operator== (const Layout &other) const
bool	operator!= (const Layout &other) const

Static Public Member Functions
static Layout	builtin (int builtin)

Public Attributes
LayoutFlags	fFlags = LayoutFlag::kNone
int	fLocation = -1
int	fOffset = -1
int	fBinding = -1
int	fTexture = -1
int	fSampler = -1
int	fIndex = -1
int	fSet = -1
int	fBuiltin = -1
int	fInputAttachmentIndex = -1
int	fLocalSizeX = -1
int	fLocalSizeY = -1
int	fLocalSizeZ = -1

Detailed Description

Represents a layout block appearing before a variable declaration, as in:

layout (location = 0) int x;

Definition at line 75 of file SkSLLayout.h.

Constructor & Destructor Documentation

Layout() [1/2]

SkSL::Layout::Layout ( LayoutFlags  flags, int  location, int  offset, int  binding, int  index, int  set, int  builtin, int  inputAttachmentIndex  )

inline

Definition at line 76 of file SkSLLayout.h.

            : fFlags(flags)
            , fLocation(location)
            , fOffset(offset)
            , fBinding(binding)
            , fIndex(index)
            , fSet(set)
            , fBuiltin(builtin)
            , fInputAttachmentIndex(inputAttachmentIndex) {}

Layout() [2/2]

constexpr SkSL::Layout::Layout ( )

constexprdefault

Member Function Documentation

builtin()

static Layout SkSL::Layout::builtin ( int  builtin )

inlinestatic

Definition at line 89 of file SkSLLayout.h.

                                       {
        Layout result;
        result.fBuiltin = builtin;
        return result;
    }

checkPermittedLayout()

bool SkSL::Layout::checkPermittedLayout	(	const Context &	context,
		Position	pos,
		LayoutFlags	permittedLayoutFlags
	)		const

Verifies that only permitted layout flags are included. Reports errors and returns false in the event of a violation.

Definition at line 105 of file SkSLLayout.cpp.

                                                                          {
    static constexpr struct { LayoutFlag flag; const char* name; } kLayoutFlags[] = {
        { LayoutFlag::kOriginUpperLeft,          "origin_upper_left"},
        { LayoutFlag::kPushConstant,             "push_constant"},
        { LayoutFlag::kBlendSupportAllEquations, "blend_support_all_equations"},
        { LayoutFlag::kColor,                    "color"},
        { LayoutFlag::kLocation,                 "location"},
        { LayoutFlag::kOffset,                   "offset"},
        { LayoutFlag::kBinding,                  "binding"},
        { LayoutFlag::kTexture,                  "texture"},
        { LayoutFlag::kSampler,                  "sampler"},
        { LayoutFlag::kIndex,                    "index"},
        { LayoutFlag::kSet,                      "set"},
        { LayoutFlag::kBuiltin,                  "builtin"},
        { LayoutFlag::kInputAttachmentIndex,     "input_attachment_index"},
        { LayoutFlag::kVulkan,                   "vulkan"},
        { LayoutFlag::kMetal,                    "metal"},
        { LayoutFlag::kWebGPU,                   "webgpu"},
        { LayoutFlag::kDirect3D,                 "direct3d"},
        { LayoutFlag::kRGBA8,                    "rgba8"},
        { LayoutFlag::kRGBA32F,                  "rgba32f"},
        { LayoutFlag::kR32F,                     "r32f"},
        { LayoutFlag::kLocalSizeX,               "local_size_x"},
        { LayoutFlag::kLocalSizeY,               "local_size_y"},
        { LayoutFlag::kLocalSizeZ,               "local_size_z"},
    };
 
    bool success = true;
    LayoutFlags layoutFlags = fFlags;
 
    LayoutFlags backendFlags = layoutFlags & LayoutFlag::kAllBackends;
    if (SkPopCount(backendFlags.value()) > 1) {
        context.fErrors->error(pos, "only one backend qualifier can be used");
        success = false;
    }
 
    LayoutFlags pixelFormatFlags = layoutFlags & LayoutFlag::kAllPixelFormats;
    if (SkPopCount(pixelFormatFlags.value()) > 1) {
        context.fErrors->error(pos, "only one pixel format qualifier can be used");
        success = false;
    }
 
    if ((layoutFlags & (LayoutFlag::kTexture | LayoutFlag::kSampler)) &&
        layoutFlags & LayoutFlag::kBinding) {
        context.fErrors->error(pos, "'binding' modifier cannot coexist with 'texture'/'sampler'");
        success = false;
    }
    // The `texture` and `sampler` flags are only allowed when targeting Metal, WebGPU or Direct3D.
    if (!(layoutFlags & (LayoutFlag::kMetal | LayoutFlag::kWebGPU | LayoutFlag::kDirect3D))) {
        permittedLayoutFlags &= ~LayoutFlag::kTexture;
        permittedLayoutFlags &= ~LayoutFlag::kSampler;
    }
    // The `push_constant` flag is only allowed when targeting Vulkan or WebGPU.
    if (!(layoutFlags & (LayoutFlag::kVulkan | LayoutFlag::kWebGPU))) {
        permittedLayoutFlags &= ~LayoutFlag::kPushConstant;
    }
    // The `set` flag is not allowed when explicitly targeting Metal.
    if (layoutFlags & LayoutFlag::kMetal) {
        permittedLayoutFlags &= ~LayoutFlag::kSet;
    }
 
    for (const auto& lf : kLayoutFlags) {
        if (layoutFlags & lf.flag) {
            if (!(permittedLayoutFlags & lf.flag)) {
                context.fErrors->error(pos, "layout qualifier '" + std::string(lf.name) +
                                            "' is not permitted here");
                success = false;
            }
            layoutFlags &= ~lf.flag;
        }
    }
    SkASSERT(layoutFlags == LayoutFlag::kNone);
    return success;
}

description()

std::string SkSL::Layout::description

(

)

const

Definition at line 97 of file SkSLLayout.cpp.

                                    {
    std::string s = this->paddedDescription();
    if (!s.empty()) {
        s.pop_back();
    }
    return s;
}

operator!=()

bool SkSL::Layout::operator!= ( const Layout &  other ) const

inline

Definition at line 108 of file SkSLLayout.h.

                                               {
        return !(*this == other);
    }

operator==()

bool SkSL::Layout::operator==

(

const Layout &

other

)

const

Definition at line 182 of file SkSLLayout.cpp.

                                                 {
    return fFlags                == other.fFlags &&
           fLocation             == other.fLocation &&
           fOffset               == other.fOffset &&
           fBinding              == other.fBinding &&
           fTexture              == other.fTexture &&
           fSampler              == other.fSampler &&
           fIndex                == other.fIndex &&
           fSet                  == other.fSet &&
           fBuiltin              == other.fBuiltin &&
           fInputAttachmentIndex == other.fInputAttachmentIndex &&
           fLocalSizeX           == other.fLocalSizeX &&
           fLocalSizeY           == other.fLocalSizeY &&
           fLocalSizeZ           == other.fLocalSizeZ;
}

paddedDescription()

std::string SkSL::Layout::paddedDescription

(

)

const

Definition at line 19 of file SkSLLayout.cpp.

                                          {
    std::string result;
    auto separator = SkSL::String::Separator();
    if (fFlags & LayoutFlag::kVulkan) {
        result += separator() + "vulkan";
    }
    if (fFlags & LayoutFlag::kMetal) {
        result += separator() + "metal";
    }
    if (fFlags & LayoutFlag::kWebGPU) {
        result += separator() + "webgpu";
    }
    if (fFlags & LayoutFlag::kDirect3D) {
        result += separator() + "direct3d";
    }
    if (fFlags & LayoutFlag::kRGBA8) {
        result += separator() + "rgba8";
    }
    if (fFlags & LayoutFlag::kRGBA32F) {
        result += separator() + "rgba32f";
    }
    if (fFlags & LayoutFlag::kR32F) {
        result += separator() + "r32f";
    }
    if (fLocation >= 0) {
        result += separator() + "location = " + std::to_string(fLocation);
    }
    if (fOffset >= 0) {
        result += separator() + "offset = " + std::to_string(fOffset);
    }
    if (fBinding >= 0) {
        result += separator() + "binding = " + std::to_string(fBinding);
    }
    if (fTexture >= 0) {
        result += separator() + "texture = " + std::to_string(fTexture);
    }
    if (fSampler >= 0) {
        result += separator() + "sampler = " + std::to_string(fSampler);
    }
    if (fIndex >= 0) {
        result += separator() + "index = " + std::to_string(fIndex);
    }
    if (fSet >= 0) {
        result += separator() + "set = " + std::to_string(fSet);
    }
    if (fBuiltin >= 0) {
        result += separator() + "builtin = " + std::to_string(fBuiltin);
    }
    if (fInputAttachmentIndex >= 0) {
        result += separator() + "input_attachment_index = " + std::to_string(fInputAttachmentIndex);
    }
    if (fFlags & LayoutFlag::kOriginUpperLeft) {
        result += separator() + "origin_upper_left";
    }
    if (fFlags & LayoutFlag::kBlendSupportAllEquations) {
        result += separator() + "blend_support_all_equations";
    }
    if (fFlags & LayoutFlag::kPushConstant) {
        result += separator() + "push_constant";
    }
    if (fFlags & LayoutFlag::kColor) {
        result += separator() + "color";
    }
    if (fLocalSizeX >= 0) {
        result += separator() + "local_size_x = " + std::to_string(fLocalSizeX);
    }
    if (fLocalSizeY >= 0) {
        result += separator() + "local_size_y = " + std::to_string(fLocalSizeY);
    }
    if (fLocalSizeZ >= 0) {
        result += separator() + "local_size_z = " + std::to_string(fLocalSizeZ);
    }
    if (result.size() > 0) {
        result = "layout (" + result + ") ";
    }
    return result;
}

Member Data Documentation

fBinding

int SkSL::Layout::fBinding = -1

Definition at line 115 of file SkSLLayout.h.

fBuiltin

int SkSL::Layout::fBuiltin = -1

Definition at line 122 of file SkSLLayout.h.

fFlags

LayoutFlags SkSL::Layout::fFlags = LayoutFlag::kNone

Definition at line 112 of file SkSLLayout.h.

fIndex

int SkSL::Layout::fIndex = -1

Definition at line 118 of file SkSLLayout.h.

fInputAttachmentIndex

int SkSL::Layout::fInputAttachmentIndex = -1

Definition at line 125 of file SkSLLayout.h.

fLocalSizeX

int SkSL::Layout::fLocalSizeX = -1

Definition at line 128 of file SkSLLayout.h.

fLocalSizeY

int SkSL::Layout::fLocalSizeY = -1

Definition at line 129 of file SkSLLayout.h.

fLocalSizeZ

int SkSL::Layout::fLocalSizeZ = -1

Definition at line 130 of file SkSLLayout.h.

fLocation

int SkSL::Layout::fLocation = -1

Definition at line 113 of file SkSLLayout.h.

fOffset

int SkSL::Layout::fOffset = -1

Definition at line 114 of file SkSLLayout.h.

fSampler

int SkSL::Layout::fSampler = -1

Definition at line 117 of file SkSLLayout.h.

fSet

int SkSL::Layout::fSet = -1

Definition at line 119 of file SkSLLayout.h.

fTexture

int SkSL::Layout::fTexture = -1

Definition at line 116 of file SkSLLayout.h.

---

The documentation for this struct was generated from the following files:

• third_party/skia/src/sksl/ir/SkSLLayout.h
• third_party/skia/src/sksl/ir/SkSLLayout.cpp