korge/korlibs.graphics.shader

Package-level declarations

Types

open class Arg(val name: String, val type: VarType, val arrayCount: Int = 1, val precision: Precision = Precision.DEFAULT) : Variable

Attribute

open class Attribute(val name: String, val type: VarType, val normalized: Boolean, val offset: Int? = null, val active: Boolean = true, val precision: Precision = Precision.DEFAULT, val divisor: Int = 0, val fixedLocation: Int) : VariableWithOffset

FragmentShader

typealias FragmentShader = Shader

FuncDecl

data class FuncDecl(val name: String, val rettype: VarType, val args: List<Pair<String, VarType>>, val stm: Program.Stm) : Program.FuncRef, Program.FuncRef0, Program.FuncRef1, Program.FuncRef2, Program.FuncRef3, Program.FuncRef4, Program.FuncRef5, Program.FuncRefN

Operand

open class Operand(val type: VarType)

OperandWithArray

open class OperandWithArray(val type: VarType, val arrayCount: Int) : Operand

Output

object Output : Varying

Precision

enum Precision : Enum<Precision>

Program

data class Program(val vertex: VertexShader, val fragment: FragmentShader, val name: String = "program-") : Closeable

ProgramLayout

open class ProgramLayout<TVariable : VariableWithOffset>(items: List<TVariable>, layoutSize: Int?, val fixedLocation: Int = -1) : Iterable<TVariable>

Sampler

open class Sampler(val name: String, val index: Int, val stype: SamplerVarType) : Variable

SamplerVarType

enum SamplerVarType : Enum<SamplerVarType>

Shader

data class Shader(val type: ShaderType, val stm: Program.Stm, val functions: List<FuncDecl>, val name: String? = null)

ShaderType

enum ShaderType : Enum<ShaderType>

Temp

open class Temp(id: Int, val type: VarType, val arrayCount: Int, val precision: Precision = Precision.DEFAULT) : Variable

TypedUniform

class TypedUniform<T>(val name: String, val voffset: Int, var vindex: Int, val block: UniformBlock, val type: VarType, val arrayCount: Int) : VariableWithOffset

Uniform

open class Uniform(val name: String, val type: VarType, val arrayCount: Int, val precision: Precision = Precision.DEFAULT, val offset: Int? = null, val typedUniform: TypedUniform<*>) : VariableWithOffset

UniformBlock

open class UniformBlock(val fixedLocation: Int)

UniformBlockBase

class UniformBlockBase(val fixedLocation: Int = -1)

UniformBlockBuffer

class UniformBlockBuffer<T : UniformBlock>(val block: T)

UniformBlocksBuffersRef

class UniformBlocksBuffersRef(val blocks: Array<UniformBlockBuffer<*>?>, val buffers: Array<AGBuffer?>, val valueIndices: IntArray)

UniformInProgram

data class UniformInProgram(val uniform: Uniform, val index: Int)

UniformsRef

class UniformsRef(val block: UniformBlock, var buffer: Buffer, var index: Int)

Variable

sealed class Variable : OperandWithArray

VariableWithOffset

sealed class VariableWithOffset : Variable

VarKind

enum VarKind : Enum<VarKind>

VarType

enum VarType : Enum<VarType>

VarTypeAccessor

interface VarTypeAccessor

Varying

open class Varying(val name: String, val type: VarType, val arrayCount: Int, val precision: Precision = Precision.DEFAULT) : Variable

VertexLayout

typealias VertexLayout = ProgramLayout<Attribute>

VertexShader

typealias VertexShader = Shader

Properties

attributePositions

val ProgramLayout<Attribute>.attributePositions: IntArrayList

attributes

val ProgramLayout<Attribute>.attributes: List<Attribute>

uniformPositions

val ProgramLayout<Uniform>.uniformPositions: IntArrayList

uniforms

val ProgramLayout<Uniform>.uniforms: List<Uniform>

Functions

appending

inline fun Shader.appending(block: Program.Builder.() -> Unit): FragmentShader

appendingFragment

inline fun Program.appendingFragment(extraName: String, block: Program.Builder.() -> Unit): Program

appendingVertex

inline fun Program.appendingVertex(extraName: String, block: Program.Builder.() -> Unit): Program

Attribute

fun Attribute(type: VarType, normalized: Boolean, precision: Precision = Precision.DEFAULT, fixedLocation: Int): Attribute.Provider

FragmentShader

inline fun FragmentShader(callback: ProgramBuilderDefault.() -> Unit): FragmentShader

fun FragmentShader(info: Pair<Program.Stm, List<FuncDecl>>): Shader

fun ~~FragmentShader~~(stm: Program.Stm, glsl: String): Shader

fun FragmentShader(stm: Program.Stm, funcs: List<FuncDecl> = listOf()): Shader

fun FragmentShader(rawStrings: Map<String, String>, stm: Program.Stm? = null): Shader

replacingFragment

inline fun Program.replacingFragment(extraName: String, block: ProgramBuilderDefault.() -> Unit): Program

replacingVertex

inline fun Program.replacingVertex(extraName: String, block: ProgramBuilderDefault.() -> Unit): Program

Sampler

fun Sampler(index: Int, stype: SamplerVarType): Sampler.Provider

Varying

fun Varying(type: VarType, arrayCount: Int = 1, precision: Precision = Precision.DEFAULT): Varying.Provider

VertexShader

inline fun VertexShader(callback: ProgramBuilderDefault.() -> Unit): VertexShader

fun VertexShader(info: Pair<Program.Stm, List<FuncDecl>>): Shader

fun ~~VertexShader~~(stm: Program.Stm, glsl: String): Shader

fun VertexShader(stm: Program.Stm, funcs: List<FuncDecl> = listOf()): Shader

fun VertexShader(rawStrings: Map<String, String>, stm: Program.Stm? = null): Shader