core/com.lehaine.littlekt.graphics.shader.shaders/SimpleColorVertexShader

SimpleColorVertexShader

class SimpleColorVertexShader : VertexShaderModel

Author

Colton Daily

Constructors

fun SimpleColorVertexShader()

Functions

abs

fun abs(v: GLFloat): GLFloat

fun abs(v: Vec2): Vec2

fun abs(v: Vec3): Vec3

fun abs(v: Vec4): Vec4

acos

fun acos(v: GLFloat): GLFloat

fun acos(v: Vec2): Vec2

fun acos(v: Vec3): Vec3

fun acos(v: Vec4): Vec4

appendComponent

fun appendComponent(builder: GlslGeneratorComponent)

atan

fun atan(v: GLFloat): GLFloat

fun atan(v: Vec2): Vec2

fun atan(v: Vec3): Vec3

fun atan(v: Vec4): Vec4

attribute

fun <T : Variable> attribute(factory: (GlslGenerator) -> T, precision: Precision = Precision.DEFAULT, predicate: Boolean = true): AttributeDelegate<T>

Data that may change per vertex. Passed from the OpenGL context to the Vertex Shader.

attributeCtr

fun <T : Variable> attributeCtr(clazz: KClass<T>, precision: Precision = Precision.DEFAULT): AttributeConstructorDelegate<T>

Data that may change per vertex. Passed from the OpenGL context to the Vertex Shader.

bool

fun bool(bool: Bool): ConstructorDelegate<Bool>

fun bool(genValue: () -> Bool? = null): ConstructorDelegate<Bool>

fun bool(lit: String): ConstructorDelegate<Bool>

Break

fun Break()

castMat3

fun castMat3(m: Mat4): Mat3

ceil

fun ceil(v: GLFloat): GLFloat

fun ceil(v: Vec2): Vec2

fun ceil(v: Vec3): Vec3

fun ceil(v: Vec4): Vec4

clamp

fun clamp(v: GLFloat, min: GLFloat, max: GLFloat): GLFloat

fun clamp(v: GLFloat, min: GLFloat, max: Float): GLFloat

fun clamp(v: GLFloat, min: Float, max: Float): GLFloat

fun clamp(v: Vec2, min: GLFloat, max: GLFloat): Vec2

fun clamp(v: Vec2, min: Vec2, max: Vec2): Vec2

fun clamp(v: Vec2, min: Float, max: Float): Vec2

fun clamp(v: Vec3, min: GLFloat, max: GLFloat): Vec3

fun clamp(v: Vec3, min: Vec3, max: Vec3): Vec3

fun clamp(v: Vec3, min: Float, max: Float): Vec3

fun clamp(v: Vec4, min: GLFloat, max: GLFloat): Vec4

fun clamp(v: Vec4, min: Vec4, max: Vec4): Vec4

fun clamp(v: Vec4, min: Float, max: Float): Vec4

Continue

fun Continue()

cos

fun cos(v: GLFloat): GLFloat

fun cos(v: Vec2): Vec2

fun cos(v: Vec3): Vec3

fun cos(v: Vec4): Vec4

cross

fun cross(a: Vec3, b: Vec3): Vec3

degrees

fun degrees(v: GLFloat): GLFloat

fun degrees(v: Vec2): Vec2

fun degrees(v: Vec3): Vec3

fun degrees(v: Vec4): Vec4

discard

fun discard(): Boolean

distance

fun distance(a: GenType, b: GenType): GLFloat

div

operator fun Float.div(a: GLFloat): GLFloat

operator fun Float.div(a: GLInt): GLFloat

operator fun Float.div(a: Vec2): Vec2

operator fun Float.div(a: Vec3): Vec3

operator fun Float.div(a: Vec4): Vec4

operator fun Int.div(a: GLFloat): GLFloat

operator fun Int.div(a: GLInt): GLInt

operator fun Int.div(a: Vec2): Vec2

operator fun Int.div(a: Vec3): Vec3

operator fun Int.div(a: Vec4): Vec4

dot

fun dot(a: GenType, b: GenType): GLFloat

Else

inline fun Else(body: () -> Unit)

ElseIf

inline fun ElseIf(condition: Bool, body: () -> Unit)

ensureShaderVersionChanges

fun ensureShaderVersionChanges(context: Context, source: String): String

equals

open operator override fun equals(other: Any?): Boolean

exp

fun exp(v: GLFloat): GLFloat

fun exp(v: Vec2): Vec2

fun exp(v: Vec3): Vec3

fun exp(v: Vec4): Vec4

exp2

fun exp2(v: GLFloat): GLFloat

fun exp2(v: Vec2): Vec2

fun exp2(v: Vec3): Vec3

fun exp2(v: Vec4): Vec4

float

fun float(x: GLFloat): ConstructorDelegate<GLFloat>

fun float(x: Float): ConstructorDelegate<GLFloat>

fun float(genValue: () -> GLFloat? = null): ConstructorDelegate<GLFloat>

fun float(lit: String): ConstructorDelegate<GLFloat>

floor

fun floor(v: GLFloat): GLFloat

fun floor(v: Vec2): Vec2

fun floor(v: Vec3): Vec3

fun floor(v: Vec4): Vec4

For

inline fun For(start: GLInt, until: GLInt, step: Int = 1, body: (GLInt) -> Unit)

inline fun For(start: Int, until: Int, step: Int = 1, body: (GLInt) -> Unit)

fract

fun fract(v: GLFloat): GLFloat

fun fract(v: Vec2): Vec2

fun fract(v: Vec3): Vec3

fun fract(v: Vec4): Vec4

Func

fun <RT : GenType, F : Func<RT>> Func(funcFactory: (GlslGenerator) -> F, body: () -> RT): FunctionDelegate<RT, F>

fun <RT : GenType, F : Func<RT>, P1 : Variable> Func(funcFactory: (GlslGenerator) -> F, p1Factory: (GlslGenerator) -> P1, body: (p1: P1) -> RT): FunctionDelegate1<RT, F, P1>

fun <RT : GenType, F : Func<RT>, P1 : Variable, P2 : Variable> Func(funcFactory: (GlslGenerator) -> F, p1Factory: (GlslGenerator) -> P1, p2Factory: (GlslGenerator) -> P2, body: (p1: P1, p2: P2) -> RT): FunctionDelegate2<RT, F, P1, P2>

fun <RT : GenType, F : Func<RT>, P1 : Variable, P2 : Variable, P3 : Variable> Func(funcFactory: (GlslGenerator) -> F, p1Factory: (GlslGenerator) -> P1, p2Factory: (GlslGenerator) -> P2, p3Factory: (GlslGenerator) -> P3, body: (p1: P1, p2: P2, p3: P3) -> RT): FunctionDelegate3<RT, F, P1, P2, P3>

fun <RT : GenType, F : Func<RT>, P1 : Variable, P2 : Variable, P3 : Variable, P4 : Variable> Func(funcFactory: (GlslGenerator) -> F, p1Factory: (GlslGenerator) -> P1, p2Factory: (GlslGenerator) -> P2, p3Factory: (GlslGenerator) -> P3, p4Factory: (GlslGenerator) -> P4, body: (p1: P1, p2: P2, p3: P3, p4: P4) -> RT): FunctionDelegate4<RT, F, P1, P2, P3, P4>

generate

open override fun generate(context: Context): String

hashCode

open override fun hashCode(): Int

inline fun If(condition: Bool, body: () -> Unit)

int

fun int(v: GLFloat): GLInt

fun int(x: GLInt): ConstructorDelegate<GLInt>

fun int(genValue: () -> GLInt?): ConstructorDelegate<GLInt>

fun int(x: Int): ConstructorDelegate<GLInt>

inverse

fun inverse(v: Mat2): Mat2

fun inverse(v: Mat3): Mat3

fun inverse(v: Mat4): Mat4

inversesqrt

fun inversesqrt(v: GLFloat): GLFloat

fun inversesqrt(v: Vec2): Vec2

fun inversesqrt(v: Vec3): Vec3

fun inversesqrt(v: Vec4): Vec4

length

fun length(v: GenType): GLFloat

log

fun log(v: GLFloat): GLFloat

fun log(v: Vec2): Vec2

fun log(v: Vec3): Vec3

fun log(v: Vec4): Vec4

log2

fun log2(v: GLFloat): GLFloat

fun log2(v: Vec2): Vec2

fun log2(v: Vec3): Vec3

fun log2(v: Vec4): Vec4

mat2

fun mat2(genValue: () -> Mat2? = null): ConstructorDelegate<Mat2>

mat3

fun mat3(v: Mat4): Mat3

fun mat3(genValue: () -> Mat3? = null): ConstructorDelegate<Mat3>

mat4

fun mat4(genValue: () -> Mat4? = null): ConstructorDelegate<Mat4>

max

fun max(v: GLFloat, base: GLFloat): GLFloat

fun max(v: GLFloat, v2: Float): GLFloat

fun max(v: Vec2, base: GLFloat): Vec2

fun max(v: Vec2, base: GLInt): Vec2

fun max(v: Vec2, base: Vec2): Vec2

fun max(v: Vec2, base: Float): Vec2

fun max(v: Vec2, base: Int): Vec2

fun max(v: Vec3, base: GLFloat): Vec3

fun max(v: Vec3, base: GLInt): Vec3

fun max(v: Vec3, base: Vec3): Vec3

fun max(v: Vec3, base: Float): Vec3

fun max(v: Vec3, base: Int): Vec3

fun max(v: Vec4, base: GLFloat): Vec4

fun max(v: Vec4, base: GLInt): Vec4

fun max(v: Vec4, base: Vec4): Vec4

fun max(v: Vec4, base: Float): Vec4

fun max(v: Vec4, base: Int): Vec4

min

fun min(v: GLFloat, base: GLFloat): GLFloat

fun min(v: Vec2, base: GLFloat): Vec2

fun min(v: Vec2, base: GLInt): Vec2

fun min(v: Vec2, base: Vec2): Vec2

fun min(v: Vec2, base: Float): Vec2

fun min(v: Vec2, base: Int): Vec2

fun min(v: Vec3, base: GLFloat): Vec3

fun min(v: Vec3, base: GLInt): Vec3

fun min(v: Vec3, base: Vec3): Vec3

fun min(v: Vec3, base: Float): Vec3

fun min(v: Vec3, base: Int): Vec3

fun min(v: Vec4, base: GLFloat): Vec4

fun min(v: Vec4, base: GLInt): Vec4

fun min(v: Vec4, base: Vec4): Vec4

fun min(v: Vec4, base: Float): Vec4

fun min(v: Vec4, base: Int): Vec4

minus

operator fun Float.minus(a: GLFloat): GLFloat

operator fun Float.minus(a: GLInt): GLFloat

operator fun Float.minus(a: Vec2): Vec2

operator fun Float.minus(a: Vec3): Vec3

operator fun Float.minus(a: Vec4): Vec4

operator fun Int.minus(a: GLFloat): GLFloat

operator fun Int.minus(a: GLInt): GLInt

operator fun Int.minus(a: Vec2): Vec2

operator fun Int.minus(a: Vec3): Vec3

operator fun Int.minus(a: Vec4): Vec4

mix

fun mix(v: GLFloat, y: GLFloat, a: GLFloat): GLFloat

fun mix(v: Vec2, y: Vec2, a: GLFloat): Vec2

fun mix(v: Vec2, y: Vec2, a: Vec2): Vec2

fun mix(v: Vec3, y: Vec3, a: GLFloat): Vec3

fun mix(v: Vec3, y: Vec3, a: Vec3): Vec3

fun mix(v: Vec4, y: Vec4, a: GLFloat): Vec4

fun mix(v: Vec4, y: Vec4, a: Vec4): Vec4

mod

fun mod(v: GLFloat, base: GLFloat): GLFloat

fun mod(v: Vec2, base: GLFloat): Vec2

fun mod(v: Vec2, base: GLInt): Vec2

fun mod(v: Vec2, base: Vec2): Vec2

fun mod(v: Vec2, base: Float): Vec2

fun mod(v: Vec2, base: Int): Vec2

fun mod(v: Vec3, base: GLFloat): Vec3

fun mod(v: Vec3, base: GLInt): Vec3

fun mod(v: Vec3, base: Vec3): Vec3

fun mod(v: Vec3, base: Float): Vec3

fun mod(v: Vec3, base: Int): Vec3

fun mod(v: Vec4, base: GLFloat): Vec4

fun mod(v: Vec4, base: GLInt): Vec4

fun mod(v: Vec4, base: Vec4): Vec4

fun mod(v: Vec4, base: Float): Vec4

fun mod(v: Vec4, base: Int): Vec4

normalize

fun normalize(v: GLFloat): GLFloat

fun normalize(v: Vec3): Vec3

fun normalize(v: Vec4): Vec4

plus

operator fun Float.plus(a: GLFloat): GLFloat

operator fun Float.plus(a: GLInt): GLFloat

operator fun Float.plus(a: Vec2): Vec2

operator fun Float.plus(a: Vec3): Vec3

operator fun Float.plus(a: Vec4): Vec4

operator fun Int.plus(a: GLFloat): GLFloat

operator fun Int.plus(a: GLInt): GLInt

operator fun Int.plus(a: Vec2): Vec2

operator fun Int.plus(a: Vec3): Vec3

operator fun Int.plus(a: Vec4): Vec4

pow

fun pow(v: GLFloat, x: Float): GLFloat

radians

fun radians(v: GLFloat): GLFloat

fun radians(v: Vec2): Vec2

fun radians(v: Vec3): Vec3

fun radians(v: Vec4): Vec4

reflect

fun reflect(i: GenType, n: GenType): Vec3

refract

fun refract(i: GenType, n: GenType, eta: GLFloat): Vec3

round

fun round(vec4: Vec4): Vec4

samplersArray

fun <T : Variable> samplersArray(size: Int, precision: Precision = Precision.DEFAULT): UniformArrayDelegate<Sampler2DVarArray>

shadow2D

fun shadow2D(sampler: ShadowTexture2D, v: Vec2): Vec4

sign

fun sign(v: GLFloat): GLFloat

fun sign(v: Vec2): Vec2

fun sign(v: Vec3): Vec3

fun sign(v: Vec4): Vec4

sin

fun sin(v: GLFloat): GLFloat

fun sin(v: Vec2): Vec2

fun sin(v: Vec3): Vec3

fun sin(v: Vec4): Vec4

smoothstep

fun smoothstep(v: GLFloat, u: GLFloat, x: GLFloat): GLFloat

fun smoothstep(v: Vec2, u: Vec2, x: Vec2): Vec2

fun smoothstep(v: Vec3, u: Vec3, x: Vec3): Vec3

fun smoothstep(v: Vec4, u: Vec4, x: Vec4): Vec4

sqrt

fun sqrt(v: GLFloat): GLFloat

fun sqrt(v: Vec2): Vec2

fun sqrt(v: Vec3): Vec3

fun sqrt(v: Vec4): Vec4

step

fun step(v: GLFloat, x: GLFloat): GLFloat

fun step(v: Vec2, x: GLFloat): Vec2

fun step(v: Vec2, x: Vec2): Vec2

fun step(v: Vec3, x: GLFloat): Vec3

fun step(v: Vec3, x: Vec3): Vec3

fun step(v: Vec4, x: GLFloat): Vec4

fun step(v: Vec4, x: Vec4): Vec4

tan

fun tan(v: GLFloat): GLFloat

fun tan(v: Vec2): Vec2

fun tan(v: Vec3): Vec3

fun tan(v: Vec4): Vec4

ternary

fun ternary(condition: Bool, left: GLFloat, right: GLFloat): GLFloat

fun ternary(condition: Bool, left: GLInt, right: GLInt): GLInt

fun ternary(condition: Bool, left: Vec2, right: Vec2): Vec2

fun ternary(condition: Bool, left: Vec3, right: Vec3): Vec3

fun ternary(condition: Bool, left: Vec4, right: Vec4): Vec4

texture

fun texture(sampler: Sampler2DArray, v: Vec3): Vec4

texture2D

fun texture2D(sampler: Sampler2D, v: Vec2): Vec4

times

operator fun Float.times(a: GLFloat): GLFloat

operator fun Float.times(a: GLInt): GLFloat

operator fun Float.times(a: Vec2): Vec2

operator fun Float.times(a: Vec3): Vec3

operator fun Float.times(a: Vec4): Vec4

operator fun Int.times(a: GLFloat): GLFloat

operator fun Int.times(a: GLInt): GLInt

operator fun Int.times(a: Vec2): Vec2

operator fun Int.times(a: Vec3): Vec3

operator fun Int.times(a: Vec4): Vec4

transpose

fun transpose(v: Mat2): Mat2

fun transpose(v: Mat3): Mat3

fun transpose(v: Mat4): Mat4

uniform

fun <T : Variable> uniform(factory: (GlslGenerator) -> T, precision: Precision = Precision.DEFAULT): UniformDelegate<T>

uniformArray

fun <T : Variable> uniformArray(size: Int, init: (builder: GlslGenerator) -> T, precision: Precision = Precision.DEFAULT): UniformArrayDelegate<T>

uniformCtr

fun <T : Variable> uniformCtr(clazz: KClass<T>, precision: Precision = Precision.DEFAULT): UniformConstructorDelegate<T>

varying

fun <T : Variable> varying(factory: (GlslGenerator) -> T, precision: Precision = Precision.DEFAULT, predicate: Boolean = true): VaryingDelegate<T>

Data going OUT to the Fragment Shader.

varyingCtr

fun <T : Variable> varyingCtr(clazz: KClass<T>, precision: Precision = Precision.DEFAULT): VaryingConstructorDelegate<T>

Data going OUT to the Fragment Shader.

vec2

fun vec2(x: Vec2): ConstructorDelegate<Vec2>

fun vec2(genValue: () -> Vec2? = null): ConstructorDelegate<Vec2>

fun vec2(x: GLFloat, y: GLFloat): ConstructorDelegate<Vec2>

fun vec2(x: GLFloat, y: Float): ConstructorDelegate<Vec2>

fun vec2(x: Float, y: GLFloat): ConstructorDelegate<Vec2>

fun vec2(x: Float, y: Float): ConstructorDelegate<Vec2>

vec3

fun vec3(v: Vec3): ConstructorDelegate<Vec3>

fun vec3(v: Vec4): ConstructorDelegate<Vec3>

fun vec3(genValue: () -> Vec3? = null): ConstructorDelegate<Vec3>

fun vec3(x: GLFloat, v2: Vec2): ConstructorDelegate<Vec3>

fun vec3(v2: Vec2, z: GLFloat): ConstructorDelegate<Vec3>

fun vec3(v2: Vec2, z: Float): ConstructorDelegate<Vec3>

fun vec3(x: Float, v2: Vec2): ConstructorDelegate<Vec3>

fun vec3(x: GLFloat, y: GLFloat, z: GLFloat): ConstructorDelegate<Vec3>

fun vec3(x: GLFloat, y: GLFloat, z: Float): ConstructorDelegate<Vec3>

fun vec3(x: GLFloat, y: Float, z: GLFloat): ConstructorDelegate<Vec3>

fun vec3(x: GLFloat, y: Float, z: Float): ConstructorDelegate<Vec3>

fun vec3(x: Float, y: GLFloat, z: GLFloat): ConstructorDelegate<Vec3>

fun vec3(x: Float, y: GLFloat, z: Float): ConstructorDelegate<Vec3>

fun vec3(x: Float, y: Float, z: GLFloat): ConstructorDelegate<Vec3>

fun vec3(x: Float, y: Float, z: Float): ConstructorDelegate<Vec3>

vec4

fun vec4(genValue: () -> Vec4? = null): ConstructorDelegate<Vec4>

fun vec4(vec3: Vec3, w: GLFloat): ConstructorDelegate<Vec4>

fun vec4(vec3: Vec3, w: Float): ConstructorDelegate<Vec4>

fun vec4(x: GLFloat, y: GLFloat, zw: Vec2): ConstructorDelegate<Vec4>

fun vec4(vec2: Vec2, z: Float, w: Float): ConstructorDelegate<Vec4>

fun vec4(x: GLFloat, y: GLFloat, z: GLFloat, w: GLFloat): ConstructorDelegate<Vec4>

fun vec4(x: GLFloat, y: GLFloat, z: GLFloat, w: Float): ConstructorDelegate<Vec4>

fun vec4(x: GLFloat, y: GLFloat, z: Float, w: Float): ConstructorDelegate<Vec4>

fun vec4(x: Float, y: Float, z: Float, w: GLFloat): ConstructorDelegate<Vec4>

fun vec4(x: Float, y: Float, z: Float, w: Float): ConstructorDelegate<Vec4>

Void

fun Void(body: () -> Unit): FunctionVoidDelegate

fun <P1 : Variable> Void(p1Factory: (GlslGenerator) -> P1, body: (p1: P1) -> Unit): FunctionVoidDelegate1<P1>

fun <P1 : Variable, P2 : Variable> Void(p1Factory: (GlslGenerator) -> P1, p2Factory: (GlslGenerator) -> P2, body: (p1: P1, p2: P2) -> Unit): FunctionVoidDelegate2<P1, P2>

Properties

bool

val String.bool: Bool

float

val String.float: GLFloat

gl_Position

var gl_Position: Vec4

lit

val Float.lit: GLFloat

val Int.lit: GLInt

val Boolean.lit: Bool

parameters

open val parameters: MutableList<ShaderParameter>

source

open override var source: String