Transparenzproblem in LWJGL

Question

In Ordnung, also habe ich ein Problem mit Transparenz in LWJGL. Es scheint, dass der Shader nicht einmal den Alpha-Kanal benutzt. Wenn ich beispielsweise den Alpha-Kanal auf 0,1 setze, erscheint immer noch alles solide. Das Programm, das ich erstelle, erfordert jedoch nur, dass das Objekt fest oder vollständig frei ist. Normalerweise würde ich den Befehl discard im Fragment-Shader verwenden, ich rende jedoch auf mehrere Ziele, so dass das Fragment beider Zielobjekte, auf die ich rendere, verworfen wird. Ich folge auch den Tutorials von ThnMatrix.

Also meine Frage ist, warum funktioniert das Alpha nicht beim Rendern in meinem Shader? Ich habe bereits alle GL_BLEND Sachen probiert und immer noch kein Glück. Vielen Dank!

P.S. Ich habe einen anderen Shader, der dafür sorgt, dass die GUI und Transparenz/Transluzenz gut funktioniert. Der einzige Hauptunterschied, den ich zwischen den Shadern sehe, ist der Vertex-Shader.

Fragment Shader:

#version 330 core 

in vec2 pass_textureCoords; 
in vec3 surfaceNormal; 
in vec3 toLightVector[4]; 
in vec3 toCameraVector; 
in float visibility; 

layout (location = 0) out vec4 out_Color; 
layout (location = 1)out vec4 out_BrightColour; 


uniform sampler2D textureSampler; 
uniform vec3 lightColor[4]; 

uniform vec3 attenuation[4]; 

uniform float shineDamper; 
uniform float reflectivity; 

uniform float selected; 


//effects 
uniform float bloomFactor = 0; 



uniform vec3 skyColor; 

void main(void){ 


vec3 unitNormal = normalize(surfaceNormal); 
vec3 unitVectorToCamera = normalize(toCameraVector); 

vec3 totalDiffuse = vec3(0.0); 
vec3 totalSpecular = vec3(0.0); 

for(int i = 0; i < 4; i++){ 
float distance = length(toLightVector[i]); 
float attFactor = attenuation[i].x + (attenuation[i].y * distance) + (attenuation[i].z * distance * distance); 
vec3 unitLightVector = normalize(toLightVector[i]); 
float nDot1 = dot(unitNormal, unitLightVector); 
float brightness = max(nDot1, 0.0); 
vec3 lightDirection = -unitLightVector; 
vec3 reflectedLightDirection = reflect(lightDirection, unitNormal); 
float specularFactor = dot(reflectedLightDirection, unitVectorToCamera); 
specularFactor = max(specularFactor, 0.0); 
float dampedFactor = pow(specularFactor, shineDamper); 
totalDiffuse = totalDiffuse + (brightness * lightColor[i])/attFactor; 
totalSpecular = totalSpecular + (dampedFactor * lightColor[i] * reflectivity)/attFactor; 
} 
totalDiffuse = max(totalDiffuse, 0.2); 
vec4 textureColor = texture(textureSampler, pass_textureCoords); 






out_Color = vec4(totalDiffuse, 1.0) * textureColor + vec4(totalSpecular, 1.0); 
out_Color = mix(vec4(skyColor, 1.0), out_Color, visibility); 
if(selected > 0.5){ 
out_Color.r += 0.75; 

} 
if(out_Color.a<0.5){ 
discard; 

} 


//float brightness = (out_Color.r * 0.2126) + (out_Color.g * 0.7152) + (out_Color.b * 0.0722); 
out_BrightColour = vec4(0.0); 




} 

Answer 1

out_Color = vec4(totalDiffuse, 1.0) * textureColor + vec4(totalSpecular, 1.0); 

Diese Gleichung garantiert, dass die out_Color.a immer> = 1,0 sein.

Wenn textureColor.a 0.0 ist, vollständig transparent, dann wird 0 multipliziert mit 0 Null verlassen. Nun, was passiert mit 0, wenn wir 1 hinzufügen? Und das ist in dem Fall, wo textureColor.a seinen niedrigsten möglichen Wert war. Wenn es 1.0 wäre, würden wir einen out_Color.a von 2.0 erhalten (der auf 1.0 zurückgespannt wird).