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

ModelFragmentShader

open class ModelFragmentShader(albedo: Albedo, staticColor: Color = Color.GRAY) : FragmentShaderModel

Constructors

ModelFragmentShader

fun ModelFragmentShader(albedo: Albedo, staticColor: Color = Color.GRAY)

Functions

fun abs(v: GLFloat): GLFloat

fun abs(v: Vec2): Vec2

fun abs(v: Vec3): Vec3

fun abs(v: Vec4): Vec4

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)

fun atan(v: GLFloat): GLFloat

fun atan(v: Vec2): Vec2

fun atan(v: Vec3): Vec3

fun atan(v: Vec4): Vec4

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

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

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

fun Break()

fun castMat3(m: Mat4): Mat3

fun ceil(v: GLFloat): GLFloat

fun ceil(v: Vec2): Vec2

fun ceil(v: Vec3): Vec3

fun ceil(v: Vec4): Vec4

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

fun cos(v: GLFloat): GLFloat

fun cos(v: Vec2): Vec2

fun cos(v: Vec3): Vec3

fun cos(v: Vec4): Vec4

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

fun degrees(v: GLFloat): GLFloat

fun degrees(v: Vec2): Vec2

fun degrees(v: Vec3): Vec3

fun degrees(v: Vec4): Vec4

fun dFdx(v: GLFloat): GLFloat

fun dFdy(v: GLFloat): GLFloat

fun discard(): Boolean

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

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

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

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

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

ensureShaderVersionChanges

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

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

fun exp(v: GLFloat): GLFloat

fun exp(v: Vec2): Vec2

fun exp(v: Vec3): Vec3

fun exp(v: Vec4): Vec4

fun exp2(v: GLFloat): GLFloat

fun exp2(v: Vec2): Vec2

fun exp2(v: Vec3): Vec3

fun exp2(v: Vec4): Vec4

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>

fun floor(v: GLFloat): GLFloat

fun floor(v: Vec2): Vec2

fun floor(v: Vec3): Vec3

fun floor(v: Vec4): Vec4

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)

fun fract(v: GLFloat): GLFloat

fun fract(v: Vec2): Vec2

fun fract(v: Vec3): Vec3

fun fract(v: Vec4): Vec4

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>

open override fun generate(context: Context): String

open override fun hashCode(): Int

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

fun int(v: GLFloat): GLInt

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

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

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

fun inverse(v: Mat2): Mat2

fun inverse(v: Mat3): Mat3

fun inverse(v: Mat4): Mat4

fun inversesqrt(v: GLFloat): GLFloat

fun inversesqrt(v: Vec2): Vec2

fun inversesqrt(v: Vec3): Vec3

fun inversesqrt(v: Vec4): Vec4

fun length(v: GenType): GLFloat

fun log(v: GLFloat): GLFloat

fun log(v: Vec2): Vec2

fun log(v: Vec3): Vec3

fun log(v: Vec4): Vec4

fun log2(v: GLFloat): GLFloat

fun log2(v: Vec2): Vec2

fun log2(v: Vec3): Vec3

fun log2(v: Vec4): Vec4

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

fun mat3(v: Mat4): Mat3

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

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

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

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

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

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

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

fun normalize(v: GLFloat): GLFloat

fun normalize(v: Vec3): Vec3

fun normalize(v: Vec4): Vec4

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

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

fun radians(v: GLFloat): GLFloat

fun radians(v: Vec2): Vec2

fun radians(v: Vec3): Vec3

fun radians(v: Vec4): Vec4

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

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

fun round(vec4: Vec4): Vec4

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

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

fun sign(v: GLFloat): GLFloat

fun sign(v: Vec2): Vec2

fun sign(v: Vec3): Vec3

fun sign(v: Vec4): Vec4

fun sin(v: GLFloat): GLFloat

fun sin(v: Vec2): Vec2

fun sin(v: Vec3): Vec3

fun sin(v: Vec4): Vec4

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

fun sqrt(v: GLFloat): GLFloat

fun sqrt(v: Vec2): Vec2

fun sqrt(v: Vec3): Vec3

fun sqrt(v: Vec4): Vec4

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

fun tan(v: GLFloat): GLFloat

fun tan(v: Vec2): Vec2

fun tan(v: Vec3): Vec3

fun tan(v: Vec4): Vec4

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

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

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

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

fun transpose(v: Mat2): Mat2

fun transpose(v: Mat3): Mat3

fun transpose(v: Mat4): Mat4

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

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

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

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

Data coming IN from the Vertex Shader.

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

Data coming IN from the Vertex Shader.

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>

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>

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>

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

val String.bool: Bool

val String.float: GLFloat

var gl_FragColor: Vec4

var gl_FragCoord: Vec4

val gl_FrontFacing: Bool

val Float.lit: GLFloat

val Int.lit: GLInt

val Boolean.lit: Bool

open val parameters: MutableList<ShaderParameter>

open override var source: String

uAmbientStrength

val uAmbientStrength: ShaderParameter.UniformFloat

val uLightColor: ShaderParameter.UniformVec4

val uLightPosition: ShaderParameter.UniformVec3

uSpecularStrength

val uSpecularStrength: ShaderParameter.UniformFloat

val uTexture: ShaderParameter.UniformSample2D

val uViewPosition: ShaderParameter.UniformVec3