discard Kage function

[SolarLune]

Hello~!

In working with Tetra3D, I've found I get visual glitches on certain (Intel?) GPUs if I don't return a vec4() color in my Fragment shader (an example can be seen in this issue here). Just to clarify, this is only even possible by using an if statement to return a vec4 in Fragment(), but not returning anything outside of that if statement, as can be seen in the below example:

package main

func encodeDepth(depth float) vec4 {
	r := floor(depth * 255) / 255
	g := floor(fract(depth * 255) * 255) / 255
	b := fract(depth * 255*255)
	return vec4(r, g, b, 1);
}

func decodeDepth(rgba vec4) float {
	return rgba.r + (rgba.g / 255) + (rgba.b / 65025)
}

func Fragment(position vec4, texCoord vec2, color vec4) vec4 {

	depthValue := imageSrc0At(position.xy / imageSrcTextureSize())

	if depthValue.a == 0 || decodeDepth(depthValue) > color.r {
		return encodeDepth(color.r)
	}

        // No return statement here; this is where the issue comes in

}

The reason I'm doing this is because I don't want to write a fragment unless the comparison returns true. The easiest way to not write a fragment in a GLSL shader is to use discard to discard the fragment, thereby not altering the texture the shader is writing to - whatever was originally below the fragment being altered is left alone, essentially.

Would it be feasible to add a discard statement / function to Kage? I believe I could make my own solution more efficient and work around this issue fairly easily, but I wanted ask because discard can be useful when programming shaders.

EDIT: I've resolved it, so this isn't a pressing issue. A discard statement could still be useful if it's supported by the shader backends that Kage supports, though~

[hajimehoshi]

Sure, this sounds to make sense. Let me think.

[SolarLune]

Excellent! As it turns out, another shader I'm working on needs discard after all, so this goes from low priority to a normal "would be nice to have" for me. Specifically, I'm rendering triangles that overlap, and I need to discard the result from later triangles if they fail to pass a test that would obscure previous triangles. I can't just return vec4(0, 0, 0, 0) because that would overwrite and wipe the previous triangles' rendered pixels.

[tomlister]

Can I assign myself this? I'd like to familiarise myself with the parser.

[hajimehoshi]

#1969

Sure. Note that you will have to implement this for both GL and Metal.

[tomlister]

kage:

discard

gl:

discard;

metal:

discard_fragment();

[tomlister]

or is a function preferred?

[hajimehoshi]

I can't use builtinfuncs.
This is because opengl uses discard; which is not a function and metal uses the function discard_fragment()

discard can be a buildin function for Kage and its IR, and you can convert this to a statement or a function, right?

I recommend reading internal/shaderir and how it works :)

[tomlister]

if e.Name == "discard" {
	return nil, nil, []shaderir.Stmt{
		{
			Type: shaderir.Discard,
		},
	}, true
}

[hajimehoshi]

Basically correct. And you can see how they are converted at internal/shaderir/glsl and internal/shaderir/metal.

[tomlister]

Perfect :) Checking the parse* return types just unlocked something in my head.

[tomlister]

		if len(ss) != 0 {
			stmts = append(stmts, ss...)
		}

		if len(es) == 0 {
			return nil, nil, stmts, true
		}

Also have to check if ss > 0 and allow a lack of returned es, to avoid running into multiple-value context is not available at a callee

[tomlister]

Kage Code:

package shader
var Time float
var Cursor vec2
var ScreenSize vec2


func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
	col := vec4(1, 0, 0, 1)

	if int(position.x)%2 == int(0) {
		discard()
	}

	return col
}

Emitted Code:

#if defined(GL_ES)
precision highp float;
#else
#define lowp
#define mediump
#define highp
#endif

int modInt(int x, int y) {
        return x - y*(x/y);
}

uniform vec2 U0;
uniform vec2 U1[4];
uniform vec2 U2;
uniform vec2 U3;
uniform vec2 U4[3];
uniform vec2 U5;
uniform vec2 U6;
uniform float U7;
uniform vec2 U8;
uniform vec2 U9;
uniform sampler2D T0;
uniform sampler2D T1;
uniform sampler2D T2;
uniform sampler2D T3;
varying vec2 V0;
varying vec4 V1;

void main(void) {
        vec4 l0 = vec4(0);
        l0 = vec4(1.0, 0.0, 0.0, 1.0);
        if ((modInt((int((gl_FragCoord).x)), (2))) == (int(0.0))) {
                discard;
        }
        gl_FragColor = l0;
        return;
}