korge/korlibs.korge.render/SDFShaders

SDFShaders

object SDFShaders : Program.Builder

Properties

open val Operand.a: Operand

open val Operand.b: Operand

Bool1

open val Bool1: VarType

box

val box: Program.FuncRef2

Byte4

open val Byte4: VarType

circle

val circle: Program.FuncRef2

Float1

open val Float1: VarType

Float2

open val Float2: VarType

Float3

open val Float3: VarType

Float4

open val Float4: VarType

fragmentCoords

val Program.ExpressionBuilder.fragmentCoords: Operand

fragmentCoords01

val Program.ExpressionBuilder.fragmentCoords01: Operand

open val Operand.g: Operand

Int1

open val Int1: VarType

lit

open val Boolean.lit: Program.BoolLiteral

open val Double.~~lit~~: Program.FloatLiteral

open val Float.lit: Program.FloatLiteral

open val Int.lit: Program.IntLiteral

Mat2

open val Mat2: VarType

Mat3

open val Mat3: VarType

Mat4

open val Mat4: VarType

opAA

val opAA: Program.FuncRef1

From an SDF function, this creates a smooth antialiased version working with pixel distances.

opAARev

val opAARev: Program.FuncRef1

opBorder

val opBorder: Program.FuncRef2

From an SDF function, this converts a filled SDF into a stroke (border of the shape)

opBorderInner

val opBorderInner: Program.FuncRef2

opCombinePremultipliedColors

val opCombinePremultipliedColors: Program.FuncRef2

Mixes colors, considering they are premultiplied. The first parameter is the existing color, and the second one the color trying to put on top.

opInterpolate

val opInterpolate: Program.FuncRef3

opIntersect

val opIntersect: Program.FuncRef2

opRound

val opRound: Program.FuncRef2

opSmoothIntersection

val opSmoothIntersection: Program.FuncRef3

opSmoothSubtraction

val opSmoothSubtraction: Program.FuncRef3

opSmoothUnion

val opSmoothUnion: Program.FuncRef3

opSubtract

val opSubtract: Program.FuncRef2

opUnion

val opUnion: Program.FuncRef2

out

open val out: Output

open val Operand.r: Operand

roundedBox

val roundedBox: Program.FuncRef3

Sampler1D

open val Sampler1D: VarType

Sampler2D

open val Sampler2D: VarType

Sampler3D

open val Sampler3D: VarType

SamplerCube

open val SamplerCube: VarType

SByte1

open val SByte1: VarType

SByte2

open val SByte2: VarType

SByte3

open val SByte3: VarType

SByte4

open val SByte4: VarType

Short1

open val Short1: VarType

Short2

open val Short2: VarType

Short3

open val Short3: VarType

Short4

open val Short4: VarType

SInt1

open val SInt1: VarType

SInt2

open val SInt2: VarType

SInt3

open val SInt3: VarType

SInt4

open val SInt4: VarType

SShort1

open val SShort1: VarType

SShort2

open val SShort2: VarType

SShort3

open val SShort3: VarType

SShort4

open val SShort4: VarType

TVOID

open val TVOID: VarType

UByte1

open val UByte1: VarType

UByte2

open val UByte2: VarType

UByte3

open val UByte3: VarType

UByte4

open val UByte4: VarType

UShort1

open val UShort1: VarType

UShort2

open val UShort2: VarType

UShort3

open val UShort3: VarType

UShort4

open val UShort4: VarType

v_Tex01

val Program.ExpressionBuilder.v_Tex01: Operand

open val Operand.w: Operand

open val Operand.x: Operand

open val Operand.y: Operand

open val Operand.z: Operand

Functions

_build

fun _build(): Program.Stm

_buildFuncs

fun _buildFuncs(): Pair<Program.Stm, List<FuncDecl>>

_funcs

fun _funcs(): List<FuncDecl>

abs

open fun abs(v: Operand): Operand

acos

open fun acos(arg: Operand): Operand

and

open infix fun Operand.and(that: Operand): Operand

asin

open fun asin(arg: Operand): Operand

assign

fun Operand.~~assign~~(from: Operand)

atan

open fun atan(y_over_x: Operand): Operand

open fun atan(y: Operand, x: Operand): Operand

BREAK

fun BREAK()

ceil

open fun ceil(v: Operand): Operand

clamp

open fun clamp(v: Operand, min: Operand, max: Operand): Operand

clamp01

open fun clamp01(v: Operand): Operand

CONTINUE

fun CONTINUE()

cos

open fun cos(arg: Operand): Operand

createChildBuilder

fun createChildBuilder(): Program.Builder

createChildFuncBuilder

fun createChildFuncBuilder(): Program.Builder.FuncBuilder

createTemp

fun createTemp(type: VarType): Temp

fun createTemp(type: VarType, arrayCount: Int): Temp

cross

open fun cross(a: Operand, b: Operand): Operand

degrees

open fun degrees(arg: Operand): Operand

dFdx

open fun dFdx(a: Operand): Operand

dFdy

open fun dFdy(a: Operand): Operand

DISCARD

fun DISCARD()

distance

open fun distance(a: Operand, b: Operand): Operand

div

open operator fun Operand.div(that: Operand): Operand

open operator fun Operand.div(that: Float): Operand

open operator fun Float.div(that: Operand): Operand

dot

open fun dot(a: Operand, b: Operand): Operand

ELSE

infix fun Program.Stm.If.ELSE(callback: Program.Builder.() -> Unit)

ELSE_IF

fun Program.Stm.If.~~ELSE_IF~~(cond: Operand, callback: Program.Builder.() -> Unit): Program.Stm.If

open infix fun Operand.eq(that: Operand): Operand

open infix fun Operand.eq(that: Float): Operand

exp

open fun exp(v: Operand): Operand

exp2

open fun exp2(v: Operand): Operand

faceforward

open fun faceforward(a: Operand, b: Operand, c: Operand): Operand

float

open fun float(v: Operand): Operand

floor

open fun floor(v: Operand): Operand

FOR_0_UNTIL

inline fun FOR_0_UNTIL(len: Operand, callback: Program.Builder.(Operand) -> Unit): Program.Stm.ForSimple

FOR_0_UNTIL_FIXED

inline fun FOR_0_UNTIL_FIXED(len: Int, callback: Program.Builder.(Operand) -> Unit): Program.Stm.ForSimple

FOR_0_UNTIL_FIXED_BREAK

inline fun FOR_0_UNTIL_FIXED_BREAK(len: Operand, maxLen: Int = 1024, callback: Program.Builder.(Operand) -> Unit): Program.Stm.ForSimple

fract

open fun fract(v: Operand): Operand

The fractional part of v. This is calculated as v - floor(v).

FUNC

fun FUNC(name: String, rettype: VarType, block: Program.Builder.FuncBuilder.() -> Unit): Program.FuncRefN

fun FUNC(dummy: Unit = Unit, returns: VarType, block: Program.Builder.FuncBuilder.() -> Unit): Program.Builder.FuncProvider<Program.FuncRef0>

fun FUNC(p0: VarType, dummy: Unit = Unit, returns: VarType, block: Program.Builder.FuncBuilder.(p0: Arg) -> Unit): Program.Builder.FuncProvider<Program.FuncRef1>

fun FUNC(p0: VarType, p1: VarType, dummy: Unit = Unit, returns: VarType, block: Program.Builder.FuncBuilder.(p0: Arg, p1: Arg) -> Unit): Program.Builder.FuncProvider<Program.FuncRef2>

fun FUNC(p0: VarType, p1: VarType, p2: VarType, dummy: Unit = Unit, returns: VarType, block: Program.Builder.FuncBuilder.(p0: Arg, p1: Arg, p2: Arg) -> Unit): Program.Builder.FuncProvider<Program.FuncRef3>

fun FUNC(p0: VarType, p1: VarType, p2: VarType, p3: VarType, dummy: Unit = Unit, returns: VarType, block: Program.Builder.FuncBuilder.(p0: Arg, p1: Arg, p2: Arg, p3: Arg) -> Unit): Program.Builder.FuncProvider<Program.FuncRef4>

fun FUNC(p0: VarType, p1: VarType, p2: VarType, p3: VarType, p4: VarType, dummy: Unit = Unit, returns: VarType, block: Program.Builder.FuncBuilder.(p0: Arg, p1: Arg, p2: Arg, p3: Arg, p4: Arg) -> Unit): Program.Builder.FuncProvider<Program.FuncRef5>

func

open fun func(name: String, vararg args: Operand): Operand

FUNCN

fun FUNCN(returns: VarType, block: Program.Builder.FuncBuilder.() -> Unit): Program.Builder.FuncProvider<Program.FuncRefN>

fwidth

open fun fwidth(a: Operand): Operand

open infix fun Operand.ge(that: Operand): Operand

open infix fun Operand.ge(that: Float): Operand

get

open operator fun Operand.get(index: Int): Operand

open operator fun Operand.get(swizzle: String): Operand

open infix fun Operand.gt(that: Operand): Operand

open infix fun Operand.gt(that: Float): Operand

inline fun IF(cond: Operand, callback: Program.Builder.() -> Unit): Program.Stm.If

IF_ELSE_BINARY_LOOKUP

fun IF_ELSE_BINARY_LOOKUP(ref: Operand, min: Int, max: Int, block: Program.Builder.(Int) -> Unit)

IF_ELSE_LIST

fun IF_ELSE_LIST(ref: Operand, min: Int, max: Int, block: Program.Builder.(Int) -> Unit)

inRange

open fun Operand.inRange(low: Operand, high: Operand): Operand

int

open fun int(v: Operand): Operand

inversesqrt

open fun inversesqrt(v: Operand): Operand

invoke

operator fun Program.FuncRef0.invoke(): Program.CustomFunc

operator fun Program.FuncRef1.invoke(p0: Operand): Program.CustomFunc

operator fun Program.FuncRefN.invoke(vararg operands: Operand): Program.CustomFunc

operator fun Program.FuncRef2.invoke(p0: Operand, p1: Operand): Program.CustomFunc

operator fun Program.FuncRef3.invoke(p0: Operand, p1: Operand, p2: Operand): Program.CustomFunc

operator fun Program.FuncRef4.invoke(p0: Operand, p1: Operand, p2: Operand, p3: Operand): Program.CustomFunc

operator fun Program.FuncRef5.invoke(p0: Operand, p1: Operand, p2: Operand, p3: Operand, p4: Operand): Program.CustomFunc

open infix fun Operand.le(that: Operand): Operand

open infix fun Operand.le(that: Float): Operand

length

open fun length(a: Operand): Operand

lit

open fun lit(type: VarType, vararg ops: Operand): Operand

log

open fun log(v: Operand): Operand

log2

open fun log2(v: Operand): Operand

open infix fun Operand.lt(that: Operand): Operand

open infix fun Operand.lt(that: Float): Operand

mat2

open fun mat2(vararg ops: Operand): Operand

mat3

open fun mat3(vararg ops: Operand): Operand

mat4

open fun mat4(vararg ops: Operand): Operand

max

open fun max(a: Operand, b: Operand): Operand

min

open fun min(a: Operand, b: Operand): Operand

minus

open operator fun Operand.minus(that: Operand): Operand

open operator fun Operand.minus(that: Float): Operand

open operator fun Float.minus(that: Operand): Operand

mix

open fun mix(a: Operand, b: Operand, step: Operand): Operand

mod

open fun mod(a: Operand, b: Operand): Operand

open infix fun Operand.ne(that: Operand): Operand

open infix fun Operand.ne(that: Float): Operand

normalize

open fun normalize(a: Operand): Operand

not

open fun Operand.not(): Operand

open infix fun Operand.or(that: Operand): Operand

plus

open operator fun Operand.plus(that: Operand): Operand

open operator fun Operand.plus(that: Float): Operand

open operator fun Float.plus(that: Operand): Operand

pow

open fun pow(b: Operand, e: Operand): Operand

PUT

fun PUT(shader: Shader)

radians

open fun radians(arg: Operand): Operand

reflect

open fun reflect(a: Operand, b: Operand): Operand

refract

open fun refract(a: Operand, b: Operand, c: Operand): Operand

rem

open operator fun Operand.rem(that: Operand): Operand

open operator fun Operand.rem(that: Float): Operand

open operator fun Float.rem(that: Operand): Operand

RETURN

fun RETURN(operand: Operand? = null)

SET

fun SET(target: Operand, expr: Operand)

set

infix fun Operand.~~set~~(from: Operand)

setTo

infix fun Operand.~~setTo~~(from: Operand)

sign

open fun sign(v: Operand): Operand

sin

open fun sin(arg: Operand): Operand

smoothstep

open fun smoothstep(a: Operand, b: Operand, c: Operand): Operand

sqrt

open fun sqrt(v: Operand): Operand

step

open fun step(a: Operand, b: Operand): Operand

tan

open fun tan(arg: Operand): Operand

TEMP

fun TEMP(type: VarType): Temp

TERNARY

open fun TERNARY(cond: Operand, otrue: Operand, ofalse: Operand): Operand

tex

fun Program.ExpressionBuilder.tex(coords: Operand): Operand

texture

open fun texture(sampler: Operand, P: Operand): Operand

texture2D

open fun texture2D(sampler: Operand, coord: Operand): Operand

texture2DZeroOutside

fun Program.ExpressionBuilder.texture2DZeroOutside(sampler: Operand, coords: Operand, check: Boolean = true): Operand

times

open operator fun Operand.times(that: Operand): Operand

open operator fun Operand.times(that: Float): Operand

open operator fun Float.times(that: Operand): Operand

unaryMinus

open operator fun Operand.unaryMinus(): Operand

vec1

open fun vec1(vararg ops: Operand): Operand

open fun vec1(vararg ops: Float): Operand

vec2

open fun vec2(vararg ops: Operand): Operand

open fun vec2(vararg ops: Float): Operand

vec3

open fun vec3(vararg ops: Operand): Operand

open fun vec3(vararg ops: Float): Operand

vec4

open fun vec4(vararg ops: Operand): Operand

open fun vec4(vararg ops: Float): Operand

WITH

fun WITH(shader: Shader): Program.Builder