对使用OpenGL/GLSL的纹理映射和着色器程序之间关系的简单好奇

Question

我正在开发一个自制的小型3D引擎，更准确地说是渲染优化。在此之前，我开发了一种排序算法，其目标是将最多具有相同材质属性和相同着色器程序的几何体（网格）收集成批。通过这种方式，我将状态更改（glBindXXX）和draw调用（glDrawXXX）最小化。因此，如果我有一个由10个长方体组成的场景，所有长方体共享相同的纹理，需要使用相同的着色器程序进行渲染（例如，包括ADS照明），那么这些网格的所有顶点都将合并到一个唯一的VBO中，纹理将只绑定一次，只需要一个简单的绘制调用。

Scene description:

- 10 meshes (boxes) mapped with 'texture_1'

Pseudo-code (render):

shaderProgram_1->Bind()
{
     glActiveTexture(texture_1)
     DrawCall(render 10 meshes with 'texture_1')
}

但是现在我想确定一件事：让我们假设我们的场景总是由相同的10个框组成，但这次其中5个框将被映射为不同的纹理（不是多纹理，只是简单的纹理映射）。

Scene description:

- 5 boxes with 'texture_1'
- 5 boxes with 'texture_2'

Pseudo-code (render):

shaderProgram_1->Bind()
{
     glActiveTexture(texture_1)
     DrawCall(render 5 meshes with 'texture_1')
}
shaderProgram_2->Bind()
{
     glActiveTexture(texture_2)
     DrawCall(render 5 meshes with 'texture_2')
}

我的片段着色器有一个独特的sampler2D声明（我的着色器程序的目标是使用简单的纹理映射和ADS照明渲染几何体）：

uniform sampler2D ColorSampler;

我想确定的是，不可能用唯一的绘制调用来绘制这个场景（就像我之前的示例（需要一批）一样）。这是可能的，因为我对整个几何体使用了相同的纹理。我想这次我需要两个批次，因此需要两个绘制调用，当然，对于每个批次的渲染，我会在每次绘制调用之前绑定“纹理_1”和“纹理_2”（一个用于前5个框，另一个用于其他5个框）。

总之，如果所有网格都使用简单纹理（简单纹理映射）进行映射：

• 5带有红色纹理（纹理为红色）

是否可以通过简单的绘制调用渲染场景？我不这么认为，因为我的伪代码如下所示：

Pseudo-code:

shaderProgram->Bind()
{
     glActiveTexture(texture_blue)
     glActiveTexture(texture_red)
     DrawCall(render 10 meshes)
}

当我的片段着色器必须使用唯一的采样器2D均匀变量（简单的纹理映射）计算像素颜色时，我认为不可能区分2个纹理。

这是我的片段着色器：

#version 440

#define MAX_LIGHT_COUNT 1

/*
** Output color value.
*/
layout (location = 0) out vec4 FragColor;

/*
** Inputs.
*/
in vec3 Position;
in vec2 TexCoords;
in vec3 Normal;

/*
** Material uniforms.
*/
uniform MaterialBlock
{
    vec3 Ka, Kd, Ks;
    float Shininess;

}   MaterialInfos;

uniform sampler2D ColorSampler;

struct Light
{
    vec4 Position;
    vec3 La, Ld, Ls;
    float Kc, Kl, Kq;
};

uniform struct Light LightInfos[MAX_LIGHT_COUNT];

uniform unsigned int LightCount;

/*
** Light attenuation factor.
*/
float getLightAttenuationFactor(vec3 lightDir, Light light)
{
    float lightAtt = 0.0f;
    float dist = 0.0f;

    dist = length(lightDir);
    lightAtt = 1.0f / (light.Kc + (light.Kl * dist) + (light.Kq * pow(dist, 2)));
    return (lightAtt);
}

/*
** Basic phong shading.
*/
vec3 Basic_Phong_Shading(vec3 normalDir, vec3 lightDir, vec3 viewDir, int idx)
{
    vec3 Specular = vec3(0.0f);

    float lambertTerm = max(dot(lightDir, normalDir), 0.0f);

    vec3 Ambient = LightInfos[idx].La * MaterialInfos.Ka;
    vec3 Diffuse = LightInfos[idx].Ld * MaterialInfos.Kd * lambertTerm;

    if (lambertTerm > 0.0f)
    {
        vec3 reflectDir = reflect(-lightDir, normalDir);
        Specular = LightInfos[idx].Ls * MaterialInfos.Ks * pow(max(dot(reflectDir, viewDir), 0.0f), MaterialInfos.Shininess);
    }
    return (Ambient + Diffuse + Specular);
}

/*
** Fragment shader entry point.
*/
void main(void)
{
    vec3 LightIntensity = vec3(0.0f);

    vec4 texDiffuseColor = texture2D(ColorSampler, TexCoords);
    vec3 normalDir = (gl_FrontFacing ? -Normal : Normal);

    for (int idx = 0; idx < LightCount; idx++)
    {
        vec3 lightDir = vec3(LightInfos[idx].Position) - Position.xyz;
        vec3 viewDir = -Position.xyz;

        float lightAttenuationFactor = getLightAttenuationFactor(lightDir, LightInfos[idx]);

        LightIntensity += Basic_Phong_Shading(
            -normalize(normalDir), normalize(lightDir), normalize(viewDir), idx
        ) * lightAttenuationFactor;
    }
    FragColor = vec4(LightIntensity, 1.0f) * texDiffuseColor;
}

你同意我的观点吗？

Answer 1

如果你：（i）认为这是一个多文本问题，每个片段的函数只在两个传入片段之间进行选择（理想情况下使用系数为0.0或1.0的mix，而不是真正的分支）；或者（ii）将两个纹理合成为一个纹理（取决于你是否能够有效地包装和夹紧纹理坐标——注意那些相关的读取——以及最大纹理大小限制）。

这是一个悬而未决的问题，是否这些东西会提高性能。如果可以的话，一定要选择（ii）。