Java 顶点着色器可以用于翻页效果吗？

我以前做过开放式GL，但已经很久了。从我现在读到的内容来看，似乎更强调管理自己的矩阵堆栈，并将矩阵直接推入顶点着色器以定位对象

这一切都很好，但我只是想知道你打算用着色器走多远。我不知道它们是否只用于简单的事情，或者我可以使用它们来实现翻页效果。肯定会有很多数学需要计算。感觉这是一个很好的地方，但我没有经验知道这是否有问题

我将输入一个映射到手指位置的点到着色器，然后着色器将根据手指位置偏移组成页面的网格中的每个顶点

我将在一个使用OpenGl ES 2.0的Android应用程序中尝试这一点

所以

问题

这似乎是一种合理的方法吗？如果不是的话，考虑到我所需要的效果和现代OpenGL API，最好的方法是什么

到目前为止我所研究的内容

我已经阅读了许多博客和教程，包括，但着色器总是用于照明或基本定位。我认为翻页效果的计算可能需要比我见过的着色器中更多的数学运算，但我不知道着色器中有多少数学运算会太多

我知道我应该试一试，但我还有一点时间，直到这个项目开始，我只是真的研究在那一刻

更新

---

作为一个更新，我最近发现着色器有一个指令限制，因此一个要求是我能够在指令限制内获得所有翻页数学。

我已经在OpenGL ES 2.0顶点着色器中实现了页面卷曲效果，我将与您共享此代码。它使用纹理坐标来控制页面的旋转角度。这样，旋转不受场景中三角形网格位置的影响，只受弯曲页面上顶点向下的距离影响。这很有效，但我最终放弃了这种方法，采用了一种更简单的实现方式，在该实现中，卷曲是通过在页面上平面渲染几个三角形来伪造的，并使用纹理来伪造一些阴影效果。两种方法都做了，我怀疑可能所有的页面卷曲效果都是用假方法做的，因为它的实现和调试要简单得多

uniform mat4 transform_matrix;
uniform highp float radius;
uniform mediump vec2 axis;
uniform mediump vec2 axis_origin;
uniform highp float tex_size;

attribute vec2 texCoord;

varying vec2 texCoordVarying;
varying float shadeVarying;

mat4 rotationxy(float angle, vec2 axis);
mat4 translationThenRotationZ(float x, float y, float z, float angle);

void main()
{
    vec3 axisOrigin = vec3(axis_origin, radius);
    vec2 offsetTexCoord = texCoord - axis_origin;
    float angle = dot(offsetTexCoord, vec2(axis.y, -axis.x)) / radius;

    vec4 coord;
    vec4 myNormal = vec4(0.0, 0.0, 1.0, 1.0);

    if (angle <= 0.0) {                        // Flat section before curl
        coord = vec4(texCoord, 0.0, 1.0);
    } else {
        vec2 proj = dot(offsetTexCoord , axis) * (axis);
        const float PI = 3.14159265358979323846264;

        if (angle >= PI) {                    // Flat section after curl
            float axisAngle = asin(axis.x);
            proj += axis_origin;
            mat4 tr = translationThenRotationZ(proj.x, proj.y, 0.0, axisAngle);
            coord = vec4((PI - angle) * radius, 0.0, (radius + radius), 1.0);
            coord = tr * coord;

            myNormal.z = -1.0;
        } else {                            // Curl
            mat4 r = rotationxy(angle, axis);

            myNormal = r * myNormal;

            coord = vec4(proj, -axisOrigin.z, 1.0);
            r[3][0] = axisOrigin.x;
            r[3][1] = axisOrigin.y;
            r[3][2] = axisOrigin.z;
            coord = r * coord;
        }
    }
    gl_Position = transform_matrix * coord;

    shadeVarying = 0.25 + abs(myNormal.z) * 0.75;
    texCoordVarying = texCoord / tex_size;
}

mat4 rotationxy(float angle, vec2 axis)
{
    float x = axis.x;
    float y = axis.y;

    float xSqd = x * x;
    float ySqd = y * y;

    float xy = x * y;

    float cosAngle = cos(angle);
    float sinAngle = sin(angle);

    float xsinAngle = x * sinAngle;
    float ysinAngle = y * sinAngle;

    float oneMinusCos = 1.0 - cosAngle;

    float xyOneMinusCos = xy * oneMinusCos;

    mat4 target;
    target[0][0] = xSqd + (1.0 - xSqd)*cosAngle;
    target[0][1] = xyOneMinusCos;
    target[0][2] = ysinAngle;
    target[0][3] = 0.0;

    target[1][0] = xyOneMinusCos;
    target[1][1] = ySqd + (1.0 - ySqd)*cosAngle;
    target[1][2] = - xsinAngle;
    target[1][3] = 0.0;

    target[2][0] = - ysinAngle;
    target[2][1] = xsinAngle;
    target[2][2] = cosAngle;
    target[2][3] = 0.0;

    target[3][0] = 0.0;
    target[3][1] = 0.0;
    target[3][2] = 0.0;
    target[3][3] = 1.0;

    return target;
}

mat4 translationThenRotationZ(float x, float y, float z, float angle)
{
    float cosAngle = cos(angle);
    float sinAngle = sin(angle);

    mat4 target;
    target[0][0] = cosAngle;
    target[0][1] = -sinAngle;
    target[0][2] = 0.0;
    target[0][3] = 0.0;

    target[1][0] = sinAngle;
    target[1][1] = cosAngle;
    target[1][2] = 0.0;
    target[1][3] = 0.0;

    target[2][0] = 0.0;
    target[2][1] = 0.0;
    target[2][2] = 1.0;
    target[2][3] = 0.0;

    target[3][0] = x;
    target[3][1] = y;
    target[3][2] = z;
    target[3][3] = 1.0;

    return target;
}

一致mat4变换矩阵；
均匀高p浮动半径；
均匀介质矢量2轴；
均匀介质矢量2轴_原点；
均匀的高浮点数；
属性向量2 texCoord；
可变的vec2-texcoordvariating；
可变浮动阴影；
mat4旋转XY（浮动角度，vec2轴）；
mat4平移然后旋转z（浮动x、浮动y、浮动z、浮动角度）；
void main（）
{
vec3轴原点=vec3（轴原点，半径）；
vec2 OFFSETEXCOORD=texCoord-轴_原点；
浮动角度=点（偏移x坐标，矢量2（y轴，-x轴））/半径；
vec4坐标；
vec4 myNormal=vec4（0.0,0.0,1.0,1.0）；
如果（角度=π）{//卷曲后的平截面
浮动轴角度=asin（轴x）；
proj+=轴_原点；
mat4 tr=平移然后旋转Z（项目x，项目y，0.0，轴角）；
坐标=vec4（（π-角度）*半径，0.0，（半径+半径），1.0）；
coord=tr*coord；
myNormal.z=-1.0；
}else{//Curl
mat4 r=旋转XY（角度、轴）；
myNormal=r*myNormal；
坐标=vec4（proj，-axisOrigin.z，1.0）；
r[3][0]=axisOrigin.x；
r[3][1]=axisOrigin.y；
r[3][2]=axisOrigin.z；
coord=r*coord；
}
}
gl_位置=变换矩阵*坐标；
shadeVarying=0.25+abs（myNormal.z）*0.75；
TexCoordVariable=texCoord/tex_尺寸；
}
mat4旋转XY（浮动角度，vec2轴）
{
浮动x=轴x；
浮动y=轴y；
浮点数xSqd=x*x；
浮动ySqd=y*y；
浮动xy=x*y；
浮动cosAngle=cos（角度）；
浮动正弦角度=正弦（角度）；
浮动x正弦角度=x*正弦角度；
浮动y轴角度=y*正弦角度；
float oneMinusCos=1.0-余角；
浮动XYONEMINSCOS=xy*ONEMINSCOS；
mat4靶；
目标[0][0]=xSqd+（1.0-xSqd）*余角；
目标[0][1]=xyOneMinusCos；
目标[0][2]=ysinAngle；
目标[0][3]=0.0；
目标[1][0]=xyOneMinusCos；
目标[1][1]=ySqd+（1.0-ySqd）*余弦角；
目标[1][2]=-xsinAngle；
目标[1][3]=0.0；
目标[2][0]=-ysinAngle；
目标[2][1]=Xsinagle；
目标[2][2]=余角；
目标[2][3]=0.0；
目标[3][0]=0.0；
目标[3][1]=0.0；
目标[3][2]=0.0；
目标[3][3]=1.0；
回报目标；
}
mat4平移然后旋转z（浮动x、浮动y、浮动z、浮动角度）
{
浮动cosAngle=cos（角度）；
浮动正弦角度=正弦（角度）；
mat4靶；
目标[0][0]=余角；
目标[0][1]=-sinAngle；
目标[0][2]=0.0；
目标[0][3]=0.0；
目标[1][0]=正弦角；
目标[1][1]=余角；
目标[1][2]=0.0；
目标[1][3]=0.0；
目标[2][0]=0.0；
目标[2][1]=0.0；
目标[2][2]=1.0；
目标[2][3]=0.0；
目标[3][0]=x；
目标[3][1]=y；
目标[3][2]=z；
目标[3][3]=1.0；
回报目标；
}

我已经在OpenGL ES 2.0顶点着色器中实现了页面卷曲效果，我将与您分享这段代码。它使用纹理坐标来控制页面的旋转角度。这样，旋转不受场景中三角形网格位置的影响，只受弯曲页面上顶点向下的距离影响。这工作得很好，但我最终放弃了这种方法，使用了一种更简单的实现，其中cu