// GLSL ES 3.00 着色器
#version 300 es
precision mediump float;   // 必须指定默认精度

in vec3 aPos;
in vec2 aTexCoord;
out vec2 vTexCoord;
uniform mat4 mvp;

void main() {
    gl_Position = mvp * vec4(aPos, 1.0);
    vTexCoord = aTexCoord;
}

// 片段着色器（必须声明精度）
#version 300 es
precision mediump float;  // mediump = 中精度, highp = 高精度, lowp = 低精度

in vec2 vTexCoord;
out vec4 FragColor;
uniform sampler2D tex;

void main() {
    FragColor = texture(tex, vTexCoord);
}

// WebGL 2.0 初始化
const canvas = document.getElementById('canvas');
const gl = canvas.getContext('webgl2');

if (!gl) {
    alert('WebGL 2.0 not supported');
    throw new Error('WebGL 2 not supported');
}

// 着色器源码
const vertexShaderSource = `#version 300 es
precision mediump float;
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec2 aTexCoord;
out vec2 vTexCoord;
uniform mat4 mvp;
void main() {
    gl_Position = mvp * vec4(aPos, 1.0);
    vTexCoord = aTexCoord;
}`;

const fragmentShaderSource = `#version 300 es
precision mediump float;
in vec2 vTexCoord;
out vec4 FragColor;
uniform sampler2D tex;
void main() {
    FragColor = texture(tex, vTexCoord);
}`;

// 编译着色器
function compileShader(gl, type, source) {
    const shader = gl.createShader(type);
    gl.shaderSource(shader, source);
    gl.compileShader(shader);
    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
        console.error('Shader error:', gl.getShaderInfoLog(shader));
        gl.deleteShader(shader);
        return null;
    }
    return shader;
}

const vs = compileShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);

const program = gl.createProgram();
gl.attachShader(program, vs);
gl.attachShader(program, fs);
gl.linkProgram(program);

if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
    console.error('Link error:', gl.getProgramInfoLog(program));
}

// 创建 VAO
const vao = gl.createVertexArray();
gl.bindVertexArray(vao);

// 顶点数据
const vertices = new Float32Array([
    // 位置           // UV
    -0.5, -0.5, 0.0,  0.0, 0.0,
     0.5, -0.5, 0.0,  1.0, 0.0,
     0.5,  0.5, 0.0,  1.0, 1.0,
    -0.5,  0.5, 0.0,  0.0, 1.0,
]);

const vbo = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);

gl.enableVertexAttribArray(0);
gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 20, 0);
gl.enableVertexAttribArray(1);
gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 20, 12);

// 索引数据
const indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
const ebo = gl.createBuffer();
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);

// 加载纹理
function loadTexture(url) {
    const texture = gl.createTexture();
    gl.bindTexture(gl.TEXTURE_2D, texture);
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE,
                  new Uint8Array([128, 128, 128, 255]));  // 占位

    const image = new Image();
    image.onload = function() {
        gl.bindTexture(gl.TEXTURE_2D, texture);
        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
        gl.generateMipmap(gl.TEXTURE_2D);
    };
    image.src = url;
    return texture;
}

// 渲染循环
function render() {
    gl.viewport(0, 0, canvas.width, canvas.height);
    gl.clearColor(0.1, 0.1, 0.2, 1.0);
    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
    gl.enable(gl.DEPTH_TEST);

    gl.useProgram(program);
    gl.bindVertexArray(vao);
    gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);

    requestAnimationFrame(render);
}
render();

// 桌面版
#ifdef GL_ES
    precision mediump float;
#else
    #version 460 core
#endif

// 功能检测
#if defined(GL_ES_VERSION_3_0) || __VERSION__ >= 300
    // ES 3.0+ / GL 3.3+ 功能
#else
    // ES 2.0 回退
#endif

// 渲染后端抽象
class RenderBackend {
public:
    virtual void init() = 0;
    virtual void createBuffer(BufferType type, size_t size, void* data) = 0;
    virtual void drawIndexed(int count) = 0;
    virtual void setShader(const char* vertSrc, const char* fragSrc) = 0;
};

class OpenGLBackend : public RenderBackend { /* ... */ };
class OpenGLESBackend : public RenderBackend { /* ... */ };
class WebGLBackend : public RenderBackend { /* JavaScript bindings */ };

// Android OpenGL ES 基本配置
public class MyGLSurfaceView extends GLSurfaceView {
    public MyGLSurfaceView(Context context) {
        super(context);
        setEGLContextClientVersion(3);  // OpenGL ES 3.0
        setRenderer(new MyRenderer());
        setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
    }
}

public class MyRenderer implements GLSurfaceView.Renderer {
    @Override
    public void onSurfaceCreated(GL10 unused, EGLConfig config) {
        GLES30.glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
        // 初始化资源
    }

    @Override
    public void onSurfaceChanged(GL10 unused, int width, int height) {
        GLES30.glViewport(0, 0, width, height);
    }

    @Override
    public void onDrawFrame(GL10 unused) {
        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT | GLES30.GL_DEPTH_BUFFER_BIT);
        // 渲染
    }
}

// 使用 BitmapFactory 加载纹理
public static int loadTexture(Context context, int resourceId) {
    int[] textureIds = new int[1];
    GLES30.glGenTextures(1, textureIds, 0);

    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inScaled = false;  // 不缩放
    Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(), resourceId, options);

    GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureIds[0]);
    GLUtils.texImage2D(GLES30.GL_TEXTURE_2D, 0, bitmap, 0);
    GLES30.glGenerateMipmap(GLES30.GL_TEXTURE_2D);

    bitmap.recycle();
    return textureIds[0];
}