Fatal编程技术网
  • java/
  • Java LibGDX修改的DefaultShader未正确渲染

Java LibGDX修改的DefaultShader未正确渲染

java opengl libgdx glsl

Java LibGDX修改的DefaultShader未正确渲染,java,opengl,libgdx,glsl,Java,Opengl,Libgdx,Glsl,我最近深入研究了GLSL着色器（在LibGDX中），并遇到了一些问题 最初，我编写了自己的着色器，实现了着色器接口，该接口在绘图方面部分起作用，并通过顶点置换实现了我想要的功能 我决定只扩展DefaultShader，因为我不想更改图形，而且置换量非常小 但是，当我尝试在ModelBatch中使用此着色器时，#canRender（Renderable r）返回false，当我强制它渲染时，它会将所有内容都绘制为黑色。 我使用的顶点和片段着色器几乎与默认着色器相同-我只是在顶点着色器中添加了几行顶

我最近深入研究了GLSL着色器（在LibGDX中），并遇到了一些问题

最初，我编写了自己的着色器，实现了着色器接口，该接口在绘图方面部分起作用，并通过顶点置换实现了我想要的功能

我决定只扩展DefaultShader，因为我不想更改图形，而且置换量非常小

但是，当我尝试在ModelBatch中使用此着色器时，
#canRender（Renderable r）
返回false，当我强制它渲染时，它会将所有内容都绘制为黑色。

我使用的顶点和片段着色器几乎与默认着色器相同-我只是在顶点着色器中添加了几行顶点置换。片段着色器与默认着色器相同

我假设这些着色器是ModelBatch在渲染我的模型时默认使用的着色器，但我不确定它是否默认使用不同的着色器，或者我添加的着色器是否以某种方式破坏了着色器。

有一件事我认为可能是在着色器的创建过程中：我无法确定要传递给DefaultShader构造函数的可渲染性-我试图在源代码中的某个地方找到对此的调用，但没有任何运气。

这是实际的渲染调用（如果我没有将着色器传递给渲染调用，这将正确绘制，但显然没有提供我想要的功能）：

这是我的着色器类，正如您所看到的，它几乎不做任何额外的事情：

public class WarpShader extends DefaultShader {

private Vector3 playerPosition = new Vector3();

public WarpShader(Renderable renderable) {
    super(renderable, new Config(Gdx.files.internal("data/shaders/test.vertex.glsl").readString()
            , Gdx.files.internal("data/shaders/test.frag.glsl").readString()));
}

@Override
public void init() {
    super.init();
}

@Override
public int compareTo(Shader other) {
    return super.compareTo(other);
}

@Override
public boolean canRender(Renderable instance) {

    return super.canRender(instance);
}

@Override
public void begin(Camera camera, RenderContext context) {   
    super.begin(camera, context);
}

@Override
public void render(Renderable renderable) {
    program.setUniform3fv("u_playerPos", new float[]{playerPosition.x,  playerPosition.y,  playerPosition.z}, 0, 3);
    super.render(renderable);
}

public void updatePlayerPosition(Vector3 pos){
    playerPosition=pos;
}

@Override
public void end() {
    super.end();
}

@Override
public void dispose() {
    super.dispose();
}
}

这是我的顶点着色器（可能不需要阅读此内容，实际上没有添加太多）：

#如果已定义（diffuseTextureFlag）| |已定义（SpecularTextureRefLag）
#定义textureFlag
#恩迪夫
#如果已定义（SpecularTextRefLag）| |已定义（specularColorFlag）
#定义镜面反射滞后
#恩迪夫
#如果已定义（镜面反射滞后）| |已定义（雾旗）
#定义cameraPositionFlag
#恩迪夫
属性向量3 a_位置；
统一mat4 u_项目视图转换；
统一vec3 u_playerPos；//加上这个
#如果已定义（colorFlag）
可变的vec4 v_颜色；
属性向量4 a_颜色；
#endif//colorFlag
#ifdef normalFlag
属性向量3 a_normal；
一致mat3u_正规矩阵；
可变vec3 v_正常；
#endif//normalFlag
#ifdef纹理滞后
属性vec2 a_texCoord0；
#endif//textureFlag
#ifdef漫反射纹理滞后
均匀vec4u_扩散uv变换；
可变vec2 v_扩散UV；
#恩迪夫
#ifdef镜面反射标记
均匀vec4 u_镜面变换；
可变矢量2 v_镜面反射；
#恩迪夫
#ifdef BoneWeight0标志
#定义boneWeightsFlag
属性vec2 a_boneWeight0；
#endif//boneWeight0Flag
#ifdef boneWeight1Flag
#ifndef boneWeightsFlag
#定义boneWeightsFlag
#恩迪夫
属性vec2 a_boneWeight1；
#endif//boneWeight1Flag
#ifdef boneWeight2Flag
#ifndef boneWeightsFlag
#定义boneWeightsFlag
#恩迪夫
属性vec2 a_boneWeight2；
#endif//boneWeight2Flag
#ifdef BoneWeight3标志
#ifndef boneWeightsFlag
#定义boneWeightsFlag
#恩迪夫
属性vec2 a_boneWeight3；
#endif//boneWeight3Flag
#ifdef boneWeight4Flag
#ifndef boneWeightsFlag
#定义boneWeightsFlag
#恩迪夫
属性vec2 a_boneWeight4；
#endif//boneWeight4Flag
#ifdef BoneWeight5标志
#ifndef boneWeightsFlag
#定义boneWeightsFlag
#恩迪夫
属性vec2 a_boneWeight5；
#endif//boneWeight5Flag
#ifdef BoneWeight6标志
#ifndef boneWeightsFlag
#定义boneWeightsFlag
#恩迪夫
属性vec2 a_boneWeight6；
#endif//boneweight6标志
#ifdef BoneWeight7标志
#ifndef boneWeightsFlag
#定义boneWeightsFlag
#恩迪夫
属性vec2 a_boneWeight7；
#endif//boneweight7标志
#如果已定义（numBones）和已定义（boneWeightsFlag）
#如果（数量>0）
#定义蒙皮标志
#恩迪夫
#恩迪夫
统一mat4 u_worldTrans；
#如果已定义（numBones）
#如果numBones>0
均匀的mat4 u_骨[麻木骨]；
#endif//numBones
#恩迪夫
#ifdef shininessFlag
均匀的浮光；
#否则
常量浮点数亮度=20.0；
#endif//shininessFlag
#ifdef blendedFlag
均匀浮动u_不透明度；
可变浮动v_不透明度；
#ifdef alphaTestFlag
均匀浮动u_试验；
可变浮动v_试验；
#endif//alphaTestFlag
#endif//blendedFlag
#ifdef lightingFlag
可变vec3 v_光漫反射；
#ifdef ambientLightFlag
均匀vec3 u_环境光；
#endif//ambientLightFlag
#ifdef ambientCubemapFlag
均匀vec3u_环境立方映射[6]；
#endif//ambientCubemapFlag
#ifdef球形阿尔莫尼茨弗拉格
均匀vec3 u_球面热力学[9]；
#endif//sphericalHarmonicsFlag
#ifdef镜面反射
可变vec3 v_光反射；
#endif//specularFlag
#ifdef cameraPositionFlag
均匀vec4 u_摄像机位置；
#endif//cameraPositionFlag
#ifdef雾旗
可变浮动v_雾；
#endif//fogFlag
#如果已定义（numDirectionalLights）&&（numDirectionalLights>0）
结构定向光
{
vec3颜色；
vec3方向；
};
均匀方向光u_方向光[numDirectionalLights]；
#endif//numDirectionalLights
#如果已定义（numPointLights）&&（numPointLights>0）
结构点光源
{
vec3颜色；
vec3位置；
};
统一点光源u_点光源[numPointLights]；
#endif//numPointLights
#如果已定义（ambientLightFlag）| |已定义（ambientCubemapFlag）| |已定义（SphereCalharmonicsFlag）
#定义环境标志
#endif//ambientFlag
#ifdef阴影映射标志
统一mat4 u_shadowMapProjViewTrans；
可变vec3 v_shadowMapUv；
#定义separateAmbientFlag
#endif//shadowMapFlag
#如果已定义（ambientFlag）&&defined（separateAmbientFlag）
可变vec3 v_环境光；
#endif//separateAmbientFlag
#endif//lightingFlag
void main（）{
#ifdef漫反射纹理滞后
v_diffuseUV=u_diffuseUVTransform.xy+a_texCoord0*u_diffuseUVTransform.zw；
#endif//diffuseTextureFlag
#ifdef镜面反射标记
v_specularUV=u_specularUVTransform.xy+a_texCoord0*u_specularUVTransform.zw；
#endif//specularTextureFlag
#如果已定义（colorFlag）
v_颜色=a_颜色；
#endif//colorFlag
#ifdef blendedFlag
v_不透明度=u_不透明度；
#ifdef alphaTestFlag
v_字母测试=u_字母测试；
#endif//alphaTestFlag
#endif//blend

public class WarpShader extends DefaultShader {

private Vector3 playerPosition = new Vector3();

public WarpShader(Renderable renderable) {
    super(renderable, new Config(Gdx.files.internal("data/shaders/test.vertex.glsl").readString()
            , Gdx.files.internal("data/shaders/test.frag.glsl").readString()));
}

@Override
public void init() {
    super.init();
}

@Override
public int compareTo(Shader other) {
    return super.compareTo(other);
}

@Override
public boolean canRender(Renderable instance) {

    return super.canRender(instance);
}

@Override
public void begin(Camera camera, RenderContext context) {   
    super.begin(camera, context);
}

@Override
public void render(Renderable renderable) {
    program.setUniform3fv("u_playerPos", new float[]{playerPosition.x,  playerPosition.y,  playerPosition.z}, 0, 3);
    super.render(renderable);
}

public void updatePlayerPosition(Vector3 pos){
    playerPosition=pos;
}

@Override
public void end() {
    super.end();
}

@Override
public void dispose() {
    super.dispose();
}



#if defined(diffuseTextureFlag) || defined(specularTextureFlag)
#define textureFlag
#endif

#if defined(specularTextureFlag) || defined(specularColorFlag)
#define specularFlag
#endif

#if defined(specularFlag) || defined(fogFlag)
#define cameraPositionFlag
#endif

attribute vec3 a_position;
uniform mat4 u_projViewTrans;

uniform vec3 u_playerPos;  // ADDED THIS

#if defined(colorFlag)
varying vec4 v_color;
attribute vec4 a_color;
#endif // colorFlag

#ifdef normalFlag
attribute vec3 a_normal;
uniform mat3 u_normalMatrix;
varying vec3 v_normal;
#endif // normalFlag

#ifdef textureFlag
attribute vec2 a_texCoord0;
#endif // textureFlag

#ifdef diffuseTextureFlag
uniform vec4 u_diffuseUVTransform;
varying vec2 v_diffuseUV;
#endif

#ifdef specularTextureFlag
uniform vec4 u_specularUVTransform;
varying vec2 v_specularUV;
#endif

#ifdef boneWeight0Flag
#define boneWeightsFlag
attribute vec2 a_boneWeight0;
#endif //boneWeight0Flag

#ifdef boneWeight1Flag
#ifndef boneWeightsFlag
#define boneWeightsFlag
#endif
attribute vec2 a_boneWeight1;
#endif //boneWeight1Flag

#ifdef boneWeight2Flag
#ifndef boneWeightsFlag
#define boneWeightsFlag
#endif
attribute vec2 a_boneWeight2;
#endif //boneWeight2Flag

#ifdef boneWeight3Flag
#ifndef boneWeightsFlag
#define boneWeightsFlag
#endif
attribute vec2 a_boneWeight3;
#endif //boneWeight3Flag

#ifdef boneWeight4Flag
#ifndef boneWeightsFlag
#define boneWeightsFlag
#endif
attribute vec2 a_boneWeight4;
#endif //boneWeight4Flag

#ifdef boneWeight5Flag
#ifndef boneWeightsFlag
#define boneWeightsFlag
#endif
attribute vec2 a_boneWeight5;
#endif //boneWeight5Flag

#ifdef boneWeight6Flag
#ifndef boneWeightsFlag
#define boneWeightsFlag
#endif
attribute vec2 a_boneWeight6;
#endif //boneWeight6Flag

#ifdef boneWeight7Flag
#ifndef boneWeightsFlag
#define boneWeightsFlag
#endif
attribute vec2 a_boneWeight7;
#endif //boneWeight7Flag

#if defined(numBones) && defined(boneWeightsFlag)
#if (numBones > 0) 
#define skinningFlag
#endif
#endif

uniform mat4 u_worldTrans;

#if defined(numBones)
#if numBones > 0
uniform mat4 u_bones[numBones];
#endif //numBones
#endif

#ifdef shininessFlag
uniform float u_shininess;
#else
const float u_shininess = 20.0;
#endif // shininessFlag

#ifdef blendedFlag
uniform float u_opacity;
varying float v_opacity;

#ifdef alphaTestFlag
uniform float u_alphaTest;
varying float v_alphaTest;
#endif //alphaTestFlag
#endif // blendedFlag

#ifdef lightingFlag
varying vec3 v_lightDiffuse;

#ifdef ambientLightFlag
uniform vec3 u_ambientLight;
#endif // ambientLightFlag

#ifdef ambientCubemapFlag
uniform vec3 u_ambientCubemap[6];
#endif // ambientCubemapFlag 

#ifdef sphericalHarmonicsFlag
uniform vec3 u_sphericalHarmonics[9];
#endif //sphericalHarmonicsFlag

#ifdef specularFlag
varying vec3 v_lightSpecular;
#endif // specularFlag

#ifdef cameraPositionFlag
uniform vec4 u_cameraPosition;
#endif // cameraPositionFlag

#ifdef fogFlag
varying float v_fog;
#endif // fogFlag


#if defined(numDirectionalLights) && (numDirectionalLights > 0)
struct DirectionalLight
{
    vec3 color;
    vec3 direction;
};
uniform DirectionalLight u_dirLights[numDirectionalLights];
#endif // numDirectionalLights

#if defined(numPointLights) && (numPointLights > 0)
struct PointLight
{
    vec3 color;
    vec3 position;
};
uniform PointLight u_pointLights[numPointLights];
#endif // numPointLights

#if defined(ambientLightFlag) || defined(ambientCubemapFlag) || defined(sphericalHarmonicsFlag)
#define ambientFlag
#endif //ambientFlag

#ifdef shadowMapFlag
uniform mat4 u_shadowMapProjViewTrans;
varying vec3 v_shadowMapUv;
#define separateAmbientFlag
#endif //shadowMapFlag

#if defined(ambientFlag) && defined(separateAmbientFlag)
varying vec3 v_ambientLight;
#endif //separateAmbientFlag

#endif // lightingFlag

void main() {
    #ifdef diffuseTextureFlag
        v_diffuseUV = u_diffuseUVTransform.xy + a_texCoord0 * u_diffuseUVTransform.zw;
    #endif //diffuseTextureFlag

    #ifdef specularTextureFlag
        v_specularUV = u_specularUVTransform.xy + a_texCoord0 * u_specularUVTransform.zw;
    #endif //specularTextureFlag

    #if defined(colorFlag)
        v_color = a_color;
    #endif // colorFlag

    #ifdef blendedFlag
        v_opacity = u_opacity;
        #ifdef alphaTestFlag
            v_alphaTest = u_alphaTest;
        #endif //alphaTestFlag
    #endif // blendedFlag

    #ifdef skinningFlag
        mat4 skinning = mat4(0.0);
        #ifdef boneWeight0Flag
            skinning += (a_boneWeight0.y) * u_bones[int(a_boneWeight0.x)];
        #endif //boneWeight0Flag
        #ifdef boneWeight1Flag              
            skinning += (a_boneWeight1.y) * u_bones[int(a_boneWeight1.x)];
        #endif //boneWeight1Flag
        #ifdef boneWeight2Flag      
            skinning += (a_boneWeight2.y) * u_bones[int(a_boneWeight2.x)];
        #endif //boneWeight2Flag
        #ifdef boneWeight3Flag
            skinning += (a_boneWeight3.y) * u_bones[int(a_boneWeight3.x)];
        #endif //boneWeight3Flag
        #ifdef boneWeight4Flag
            skinning += (a_boneWeight4.y) * u_bones[int(a_boneWeight4.x)];
        #endif //boneWeight4Flag
        #ifdef boneWeight5Flag
            skinning += (a_boneWeight5.y) * u_bones[int(a_boneWeight5.x)];
        #endif //boneWeight5Flag
        #ifdef boneWeight6Flag
            skinning += (a_boneWeight6.y) * u_bones[int(a_boneWeight6.x)];
        #endif //boneWeight6Flag
        #ifdef boneWeight7Flag
            skinning += (a_boneWeight7.y) * u_bones[int(a_boneWeight7.x)];
        #endif //boneWeight7Flag
    #endif //skinningFlag

    #ifdef skinningFlag
        vec4 pos = u_worldTrans * skinning * vec4(a_position, 1.0);
        vec4 playerPos = u_worldTrans * skinning * vec4(u_playerPos, 1.0); // ADDED THIS
    #else
        vec4 pos = u_worldTrans * vec4(a_position, 1.0);
        vec4 playerPos = u_worldTrans * vec4(u_playerPos, 1.0); // ADDED THIS
    #endif

    gl_Position = u_projViewTrans * pos;

    //Apply horizon                             // ADDED THESE 3 LINES
    vec4 playerWorld = u_projViewTrans * playerPos;
    float xDelta = (gl_Position[1] - playerWorld[0]);
    gl_Position[1] += xDelta*xDelta*-0.002;

    #ifdef shadowMapFlag
        vec4 spos = u_shadowMapProjViewTrans * pos;
        v_shadowMapUv.xy = (spos.xy / spos.w) * 0.5 + 0.5;
        v_shadowMapUv.z = min(spos.z * 0.5 + 0.5, 0.998);
    #endif //shadowMapFlag

    #if defined(normalFlag)
        #if defined(skinningFlag)
            vec3 normal = normalize((u_worldTrans * skinning * vec4(a_normal, 0.0)).xyz);
        #else
            vec3 normal = normalize(u_normalMatrix * a_normal);
        #endif
        v_normal = normal;
    #endif // normalFlag

    #ifdef fogFlag
        vec3 flen = u_cameraPosition.xyz - pos.xyz;
        float fog = dot(flen, flen) * u_cameraPosition.w;
        v_fog = min(fog, 1.0);
    #endif

    #ifdef lightingFlag
        #if defined(ambientLightFlag)
            vec3 ambientLight = u_ambientLight;
        #elif defined(ambientFlag)
            vec3 ambientLight = vec3(0.0);
        #endif

        #ifdef ambientCubemapFlag       
            vec3 squaredNormal = normal * normal;
            vec3 isPositive  = step(0.0, normal);
            ambientLight += squaredNormal.x * mix(u_ambientCubemap[0], u_ambientCubemap[1], isPositive.x) +
                    squaredNormal.y * mix(u_ambientCubemap[2], u_ambientCubemap[3], isPositive.y) +
                    squaredNormal.z * mix(u_ambientCubemap[4], u_ambientCubemap[5], isPositive.z);
        #endif // ambientCubemapFlag

        #ifdef sphericalHarmonicsFlag
            ambientLight += u_sphericalHarmonics[0];
            ambientLight += u_sphericalHarmonics[1] * normal.x;
            ambientLight += u_sphericalHarmonics[2] * normal.y;
            ambientLight += u_sphericalHarmonics[3] * normal.z;
            ambientLight += u_sphericalHarmonics[4] * (normal.x * normal.z);
            ambientLight += u_sphericalHarmonics[5] * (normal.z * normal.y);
            ambientLight += u_sphericalHarmonics[6] * (normal.y * normal.x);
            ambientLight += u_sphericalHarmonics[7] * (3.0 * normal.z * normal.z - 1.0);
            ambientLight += u_sphericalHarmonics[8] * (normal.x * normal.x - normal.y * normal.y);          
        #endif // sphericalHarmonicsFlag

        #ifdef ambientFlag
            #ifdef separateAmbientFlag
                v_ambientLight = ambientLight;
                v_lightDiffuse = vec3(0.0);
            #else
                v_lightDiffuse = ambientLight;
            #endif //separateAmbientFlag
        #else
            v_lightDiffuse = vec3(0.0);
        #endif //ambientFlag


        #ifdef specularFlag
            v_lightSpecular = vec3(0.0);
            vec3 viewVec = normalize(u_cameraPosition.xyz - pos.xyz);
        #endif // specularFlag

        #if defined(numDirectionalLights) && (numDirectionalLights > 0) && defined(normalFlag)
            for (int i = 0; i < numDirectionalLights; i++) {
                vec3 lightDir = -u_dirLights[i].direction;
                float NdotL = clamp(dot(normal, lightDir), 0.0, 1.0);
                vec3 value = u_dirLights[i].color * NdotL;
                v_lightDiffuse += value;
                #ifdef specularFlag
                    float halfDotView = max(0.0, dot(normal, normalize(lightDir + viewVec)));
                    v_lightSpecular += value * pow(halfDotView, u_shininess);
                #endif // specularFlag
            }
        #endif // numDirectionalLights

        #if defined(numPointLights) && (numPointLights > 0) && defined(normalFlag)
            for (int i = 0; i < numPointLights; i++) {
                vec3 lightDir = u_pointLights[i].position - pos.xyz;
                float dist2 = dot(lightDir, lightDir);
                lightDir *= inversesqrt(dist2);
                float NdotL = clamp(dot(normal, lightDir), 0.0, 1.0);
                vec3 value = u_pointLights[i].color * (NdotL / (1.0 + dist2));
                v_lightDiffuse += value;
                #ifdef specularFlag
                    float halfDotView = max(0.0, dot(normal, normalize(lightDir + viewVec)));
                    v_lightSpecular += value * pow(halfDotView, u_shininess);
                #endif // specularFlag
            }
        #endif // numPointLights
    #endif // lightingFlag
}



modelBatch = new ModelBatch(new DefaultShaderProvider() {
    @Override
    protected Shader createShader (Renderable renderable) {
        return new WarpShader(renderable);
    }
});