LLGL::ParseContext Class Reference

Context class for descriptor parsing. More...

#include <Parse.h>

Public Types
using	StringType = SmallVector<char, 0>
using	TokenArrayType = SmallVector<StringView, 0>

Public Member Functions
	ParseContext ()=default
	ParseContext (const ParseContext &)=default
ParseContext &	operator= (const ParseContext &)=default
	ParseContext (ParseContext &&)=default
ParseContext &	operator= (ParseContext &&)=default
	ParseContext (const StringView &source)
	Constructs the context with a string view.
	ParseContext (UTF8String &&source)
	Constructs the context with a UTF-8 string.
PipelineLayoutDescriptor	AsPipelineLayoutDesc () const
	Generates a pipeline layout descriptor from this parse context.
SamplerDescriptor	AsSamplerDesc () const
	Generates a sampler descriptor from this parse context.
DepthDescriptor	AsDepthDesc () const
	Generates a depth descriptor from this parse context.
StencilFaceDescriptor	AsStencilFaceDesc () const
	Generates a stencil-face descriptor from this parse context.
StencilDescriptor	AsStencilDesc () const
	Generates a stencil descriptor from this parse context.
TextureSwizzleRGBA	AsTextureSwizzleRGBA () const
	Generates a texture swizzle descriptor from this parse context.
VertexAttribute	AsVertexAttribute () const
	Generates a basic vertex attribute descriptor from this parse context. This only includes format and identifier.
DynamicVector< VertexAttribute >	AsVertexAttributeVector () const
	Generates a vector of basic vertex attributes from this parse context.
	operator PipelineLayoutDescriptor () const
	Implicit conversion to PipelineLayoutDescriptor.
	operator SamplerDescriptor () const
	Implicit conversion to SamplerDescriptor.
	operator DepthDescriptor () const
	Implicit conversion to DepthDescriptor.
	operator StencilFaceDescriptor () const
	Implicit conversion to StencilFaceDescriptor.
	operator StencilDescriptor () const
	Implicit conversion to StencilDescriptor.
	operator TextureSwizzleRGBA () const
	Implicit conversion to TextureSwizzleRGBA.
	operator VertexAttribute () const
	Implicit conversion to VertexAttribute.
	operator DynamicVector< VertexAttribute > () const
	Implicit conversion to DynamicVector<VertexAttribute>.

Detailed Description

Context class for descriptor parsing.

Remarks

Numeric values are parsed as follows:

DIGIT       := '0'-'9'
HEX_DIGIT   := '0'-'9' | 'a'-'f' | 'A'-'F'
BOOL_TRUE   := 'true' | 'yes' | 'on' | '1'
BOOL_FALSE  := 'false' | 'no' | 'off' | '0'
BOOL        := BOOL_TRUE | BOOL_FALSE
INT         := DIGIT+ | '0x' HEX_DIGIT+
FLOAT       := INT | INT '.' INT

See also

Parse

Member Typedef Documentation

StringType

using LLGL::ParseContext::StringType = SmallVector<char, 0>

TokenArrayType

using LLGL::ParseContext::TokenArrayType = SmallVector<StringView, 0>

Constructor & Destructor Documentation

ParseContext() [1/5]

LLGL::ParseContext::ParseContext ( )

default

ParseContext() [2/5]

LLGL::ParseContext::ParseContext ( const ParseContext & )

default

ParseContext() [3/5]

LLGL::ParseContext::ParseContext ( ParseContext && )

default

ParseContext() [4/5]

LLGL::ParseContext::ParseContext ( const StringView & source )

explicit

Constructs the context with a string view.

Remarks

This will only keep a weak reference to the source string and that string must be kept alive for the lifetime of this context.

ParseContext() [5/5]

LLGL::ParseContext::ParseContext ( UTF8String && source )

explicit

Constructs the context with a UTF-8 string.

Remarks

This will take the ownership of the source string.

Member Function Documentation

AsDepthDesc()

DepthDescriptor LLGL::ParseContext::AsDepthDesc

(

)

const

Generates a depth descriptor from this parse context.

Remarks

The syntax for this conversion is as follows:

• compare maps to DepthDescriptor::compareOp; see ParseContext::AsSamplerDesc for accepted value.
• test maps to DepthDescriptor::testEnabled and accepts a boolean value.
• write maps to DepthDescriptor::writeEnabled and accepts a boolean value.

Here is a usage example:

LLGL::DepthDescriptor myDepthDesc = LLGL::Parse("compare=ls,test=on,write=on");

AsPipelineLayoutDesc()

PipelineLayoutDescriptor LLGL::ParseContext::AsPipelineLayoutDesc

(

)

const

Generates a pipeline layout descriptor from this parse context.

Remarks

The syntax for this conversion is as follows:

• All binding points wrapped inside "heap{"..."}" will be put into PipelineLayoutDescriptor::heapBindings. Otherwise, they are put into PipelineLayoutDescriptor::bindings.
• Each pair of binding point type (i.e. BindingDescriptor::type) and binding flags (i.e. BindingDescriptor::bindFlags) is specified by one of the following identifiers:
  • cbuffer for constant buffers (i.e. ResourceType::Buffer and BindFlags::ConstantBuffer).
  • buffer for sampled buffers (i.e. ResourceType::Buffer and BindFlags::Sampled).
  • rwbuffer for read/write storage buffers (i.e. ResourceType::Buffer and BindFlags::Storage).
  • tbuffer for sampled texel buffers (i.e. ResourceType::Buffer, BindFlags::Sampled, and BindFlags::TexelBuffer).
  • rwtbuffer for read/write storage texel buffers (i.e. ResourceType::Buffer, BindFlags::Storage, and BindFlags::TexelBuffer).
  • texture for textures (i.e. ResourceType::Texture and BindFlags::Sampled).
  • rwtexture for read/write textures (i.e. ResourceType::Texture and BindFlags::Storage).
  • sampler for sampler states (i.e. ResourceType::Sampler).
• Optionally, the resource name is specified as an arbitrary identifier followed by the at-sign (e.g. "texture(myColorMap@1)").
• The slot of each binding point (i.e. BindingDescriptor::slot) is specified as an integral number within brackets (e.g. "texture(1)").
• The array size of each binding point (i.e. BindingDescriptor::arraySize) can be optionally specified right after the slot within squared brackets (e.g. "texture(1[2])" or "texture(tex@1[2])") or after the resource name (e.g. texture(tex[2]@1)), but not both.
• Optionally, multiple slots can be specified within the brackets if separated by commas (e.g. "texture(1[2],3,arr1[2]@4,arr2@6[3])").
• Each binding point is separated by a comma, the last comma being optional (e.g. "texture(1),sampler(2)," or "texture(1),sampler(2)").
• The stage flags (i.e. BindingDescriptor::stageFlags) can be specified after each binding point with a preceding colon using the following identifiers:
  • vert for the vertex shader stage (i.e. StageFlags::VertexStage).
  • tesc for the tessellation-control shader stage (i.e. StageFlags::TessControlStage).
  • tese for the tessellation-evaluation shader stage (i.e. StageFlags::TessEvaluationStage).
  • geom for the geometry shader stage (i.e. StageFlags::GeometryStage).
  • frag for the fragment shader stage (i.e. StageFlags::FragmentStage).
  • comp for the compute shader stage (i.e. StageFlags::ComputeStage).
• If no stage flag is specified, all shader stages will be used.
• The following syntax can be used for uniform descriptors (see LLGL::UniformType for accepted type names):

  arraySize   := '[' INT ']'
  uniform     := uniformName | uniformName arraySize
  uniformName := IDENT | IDENT '.' uniformName
  uniformList := uniform | uniform ',' uniformList
  uniformDesc := TYPE '(' uniformList ')'

• The following syntax can be used for barrier flags (see PipelineLayoutDescriptor::barrierFlags):

  barriers := 'barriers' '{' flags '}'
  flags    := FLAG | FLAG ',' | FLAG ',' flags
  FLAG     := 'rw' | 'rwbuffer' | 'rwtexture'

• Whitespaces are ignored (e.g. blanks ' ', tabulators '\t', new-line characters '\n' and '\r' etc.), see C++ STL function std::isspace.

Here is a usage example:

// Standard way of declaring a pipeline layout:
LLGL::PipelineLayoutDescriptor myLayoutDescStd;
 
myLayoutDescStd.heapBindings = {
    LLGL::BindingDescriptor{ "Scene",    LLGL::ResourceType::Buffer,  LLGL::BindFlags::ConstantBuffer, LLGL::StageFlags::FragmentStage | LLGL::StageFlags::VertexStage, 0u,     },
    LLGL::BindingDescriptor{             LLGL::ResourceType::Texture, LLGL::BindFlags::Sampled,        LLGL::StageFlags::FragmentStage,                                 1u      },
    LLGL::BindingDescriptor{ "TexArray", LLGL::ResourceType::Texture, LLGL::BindFlags::Sampled,        LLGL::StageFlags::FragmentStage,                                 2u, 4u, },
};
myLayoutDescStd.bindings = {
    LLGL::BindingDescriptor{ "smpl"      LLGL::ResourceType::Sampler, 0,                               LLGL::StageFlags::FragmentStage,                                 3u      },
};
myLayoutDescStd.uniforms = {
    LLGL::UniformDescriptor{ "WorldMatrix", LLGL::UniformType::Float4x4 }
};
myLayoutDescStd.combinedTextureSamplers = {
    LLGL::CombinedTextureSamplerDescriptor{ "TexArray_smpl", "TexArray", "smpl" }
};
 
auto myLayout = myRenderer->CreatePipelineLayout(myLayoutDescStd);

The same pipeline layout can be created with the following usage of this utility function:

// Abbreviated way of declaring a pipeline layout using the utility function:
LLGL::PipelineLayoutDescriptor myLayoutDescUtil = LLGL::Parse(
    "heap{ cbuffer(Scene@0):frag:vert },"       // Constant buffer "Scene"
    "heap{ texture(1, TexArray@2[4]):frag },"   // Texture "TexArray"
    "sampler(smpl@3):frag,"                     // Sampler "smpl"
    "float4x4(WorldMatrix),"                    // Uniform "WorldMatrix"
    "sampler<TexArray,smpl>(TexArray_smpl),"    // Combined texture-sampler "TexArray_smpl"
);
auto myLayout = myRenderer->CreatePipelineLayout(myLayoutDescUtil);

AsSamplerDesc()

SamplerDescriptor LLGL::ParseContext::AsSamplerDesc

(

)

const

Generates a sampler descriptor from this parse context.

Remarks

The syntax for this conversion is as follows:

• Each sampler attribute must be assigned with a value using the '=' assignment operator (e.g. filter=linear).
• Each sampler attribute is separated by a comma, the last comma being optional (e.g. "filter=linear,address=repeat," or "filter=linear,address=repeat").
• The accepted sampler attributes are as follows:
  • address maps to SamplerAddressMode and the accepted values are:
    • repeat (SamplerAddressMode::Repeat).
    • mirror (SamplerAddressMode::Mirror).
    • clamp (SamplerAddressMode::Clamp).
    • border (SamplerAddressMode::Border).
    • mirrorOnce (SamplerAddressMode::MirrorOnce).
  • filter maps to minification, magnification, and MIP-map filters and the accepted values are:
    • none (Only for filter.mip to disable mipMapEnabled).
    • nearest (SamplerFilter::Nearest).
    • linear (SamplerFilter::Linear).
  • lod.bias maps to SamplerDescriptor::mipMapLODBias and the value must be an integral or fractional number.
  • lod.min maps to SamplerDescriptor::minLOD and the value must be an integral or fractional number.
  • lod.max maps to SamplerDescriptor::maxLOD and the value must be an integral or fractional number.
  • anisotropy maps to SamplerDescriptor::maxAnisotropy and the value must be an integral number.
  • compare maps to SamplerDescriptor::compareOp (also enables SamplerDescriptor::compareEnabled) and the accepted values are:
    • never (CompareOp::NeverPass).
    • lt (CompareOp::Less). ls is also accepted but deprecated.
    • eq (CompareOp::Equal).
    • le (CompareOp::LessEqual).
    • gt (CompareOp::Greater). gr is also accepted but deprecated.
    • ne (CompareOp::NotEqual).
    • ge (CompareOp::GreaterEqual).
    • always (CompareOp::AlwaysPass).
  • border maps to SamplerDescriptor::borderColor and the accepted values are:
    • transparent (Border color of { 0, 0, 0, 0 }).
    • black (Border color of { 0, 0, 0, 1 }).
    • white (Border color of { 1, 1, 1, 1 }).
• The sampler attribute address also accepts optional subscripts which can be one or more of the following subscripts:
  • u or x maps to SamplerDescriptor::addressModeU.
  • v or y maps to SamplerDescriptor::addressModeV.
  • w or z maps to SamplerDescriptor::addressModeW.
• The sampler attribute filter also accepts optional subscripts which can be either one of the following identifiers:
  • min maps to SamplerDescriptor::minFilter.
  • mag maps to SamplerDescriptor::magFilter.
  • mip maps to SamplerDescriptor::mipMapFilter.

Here is a usage example:

// Standard way of declaring a sampler descriptor:
LLGL::SamplerDescriptor mySamplerDescStd;
 
mySamplerDescStd.addressModeU = LLGL::SamplerDescriptor::Clamp;
mySamplerDescStd.addressModeV = LLGL::SamplerDescriptor::Clamp;
mySamplerDescStd.minFilter = LLGL::SamplerFilter::Nearest;
mySamplerDescStd.magFilter = LLGL::SamplerFilter::Nearest;
mySamplerDescStd.mipMapLODBias = 2.5f;
 
auto mySampler = myRenderer->CreateSampler(mySamplerDescStd);

The same sampler can be created with the following usage of this utility function:

LLGL::SamplerDescriptor mySamplerDescUtil = LLGL::Parse(
    "address.uv=clamp,filter.min=nearest,filter.mag=nearest,lod.bias=2.5"
);
auto mySampler = myRenderer->CreateSampler(mySamplerDescUtil);

AsStencilDesc()

StencilDescriptor LLGL::ParseContext::AsStencilDesc

(

)

const

Generates a stencil descriptor from this parse context.

AsStencilFaceDesc()

StencilFaceDescriptor LLGL::ParseContext::AsStencilFaceDesc

(

)

const

Generates a stencil-face descriptor from this parse context.

Remarks

The syntax for this conversion is as follows:

• sfail maps to StencilFaceDescriptor::stencilFailOp and the accepted values are:
  • keep (StencilOp::Keep).
  • zero (StencilOp::Zero).
  • set (StencilOp::Replace).
  • inc (StencilOp::IncClamp).
  • dec (StencilOp::DecClamp).
  • inv (StencilOp::Invert).
  • incw (StencilOp::IncWrap).
  • decw (StencilOp::DecWrap).
• dfail maps to StencilFaceDescriptor::depthFailOp and the accepted values are the same as for sfail.
• dpass maps to StencilFaceDescriptor::depthPassOp and the accepted values are the same as for sfail.
• compare maps to StencilFaceDescriptor::compareOp; see ParseContext::AsSamplerDesc for accepted value.
• read maps to StencilFaceDescriptor::readMask and accepts an integer value.
• write maps to StencilFaceDescriptor::writeMask and accepts an integer value.
• ref maps to StencilFaceDescriptor::reference and accepts an integer value.

AsTextureSwizzleRGBA()

TextureSwizzleRGBA LLGL::ParseContext::AsTextureSwizzleRGBA

(

)

const

Generates a texture swizzle descriptor from this parse context.

Remarks

This conversion always requires 4 characters from the parse string and the characters are interpreted as follows:

• '1' translates to TextureSwizzle::One
• '0' translates to TextureSwizzle::One
• 'r' or 'R' translates to TextureSwizzle::Red
• 'g' or 'G' translates to TextureSwizzle::Green
• 'b' or 'B' translates to TextureSwizzle::Blue
• 'a' or 'A' translates to TextureSwizzle::Alpha

AsVertexAttribute()

VertexAttribute LLGL::ParseContext::AsVertexAttribute

(

)

const

Generates a basic vertex attribute descriptor from this parse context. This only includes format and identifier.

Remarks

The syntax for this conversion is as follows:

• Attribute type translates to Format, e.g. 'rgb32float' translates to RGB32Float.
• Followed by the name in parenthesis, e.g. '(position)'.

Format identifiers can be abbreviated as follows:

• 'float' can be abbreviated with 'f', e.g. 'rgb32float' as 'rgb32f'.
• 'sint' can be abbreviated with 'i', e.g. 'rgba16sint' as 'rgba16i'.
• 'uint' can be abbreviated with 'u', e.g. 'rgba16uint' as 'rgba16u'.

A full vertex attribute might look like this "rgb32f(position)".

AsVertexAttributeVector()

DynamicVector< VertexAttribute > LLGL::ParseContext::AsVertexAttributeVector

(

)

const

Generates a vector of basic vertex attributes from this parse context.

Remarks

This parses a comma separated list of vertex attributes, the last comma being optional.

A full vertex attribute list might look like this "rgb32f(position),rgba8unorm(color),".

See also

AsVertexAttribute

operator DepthDescriptor()

LLGL::ParseContext::operator DepthDescriptor ( ) const

inline

Implicit conversion to DepthDescriptor.

See also

AsDepthDesc

operator DynamicVector< VertexAttribute >()

LLGL::ParseContext::operator DynamicVector< VertexAttribute > ( ) const

inline

Implicit conversion to DynamicVector<VertexAttribute>.

See also

AsVertexAttributeVector

operator PipelineLayoutDescriptor()

LLGL::ParseContext::operator PipelineLayoutDescriptor ( ) const

inline

Implicit conversion to PipelineLayoutDescriptor.

See also

AsPipelineLayoutDesc

operator SamplerDescriptor()

LLGL::ParseContext::operator SamplerDescriptor ( ) const

inline

Implicit conversion to SamplerDescriptor.

See also

AsSamplerDesc

operator StencilDescriptor()

LLGL::ParseContext::operator StencilDescriptor ( ) const

inline

Implicit conversion to StencilDescriptor.

See also

AsStencilDesc

operator StencilFaceDescriptor()

LLGL::ParseContext::operator StencilFaceDescriptor ( ) const

inline

Implicit conversion to StencilFaceDescriptor.

See also

AsStencilFaceDesc

operator TextureSwizzleRGBA()

LLGL::ParseContext::operator TextureSwizzleRGBA ( ) const

inline

Implicit conversion to TextureSwizzleRGBA.

See also

AsTextureSwizzleRGBA

operator VertexAttribute()

LLGL::ParseContext::operator VertexAttribute ( ) const

inline

Implicit conversion to VertexAttribute.

See also

AsVertexAttribute

operator=() [1/2]

ParseContext & LLGL::ParseContext::operator= ( const ParseContext & )

default

operator=() [2/2]

ParseContext & LLGL::ParseContext::operator= ( ParseContext && )

default

---

The documentation for this class was generated from the following file:

• Parse.h