问OpenGL ES Android 2D视图似乎被放大到无穷大。

EN

package com.e

import android.content.Context
import android.opengl.GLES20.*
import android.opengl.GLSurfaceView.Renderer
import android.opengl.Matrix
import android.opengl.Matrix.*
import com.e.mysandboxapplication.R
import util.LoggerConfig
import util.ShaderHelper
import util.TextResourceReaderService
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.nio.FloatBuffer
import javax.microedition.khronos.egl.EGLConfig
import javax.microedition.khronos.opengles.GL10


class Open2DMapGLRenderer (
        private var context: Context
    ) : Renderer  {

    private val U_Matrix = "u_Matrix"
    private var projectionMatrix = FloatArray(16)
    private var viewMatrix = FloatArray(16)
    private val vPMatrix = FloatArray(16)
    private var vPMatrixHandle = 0
    private var uMatrixLocation = 0
    private val BYTES_PER_FLOAT = 4
    private lateinit var vertexData : FloatBuffer
    private var program = 0
    private val u_Color = "u_Color"
    private var uColorLocation = 0
    private var a_Position = "a_Position"
    private var aPositionLocation = 0
    private var POSITION_COMPONENT_COUNT = 2

    init{
        val vertices = PopulateVertices()
        vertexData = ByteBuffer.allocateDirect(vertices.count() * BYTES_PER_FLOAT)
            .order(ByteOrder.nativeOrder())
            .asFloatBuffer()
        vertexData.put(vertices)
    }

    private fun PopulateVertices(): FloatArray {
        val vertices = floatArrayOf(
            // Triangle 1
            -0.5f, -0.5f,
            0.5f, 0.5f,
            -0.5f, 0.5f,

            // Triangle 2
            -0.5f, -0.5f,
            0.5f, -0.5f,
            0.5f, 0.5f,

            // Line 1
            -0.5f, 0f,
            0.5f, 0f,

            // Points
            0.5f, 0.5f,
            -0.5f, -0.5f,
            0.0f, 0.0f
        )
        return vertices
    }

    override fun onDrawFrame(gl: GL10?) {
        glClear(GL_COLOR_BUFFER_BIT)
        setLookAtM(viewMatrix, 0, 0f, 0f, 1.0f, 0f, 0f, 0f, 0f, 1.0f, 0f)
        multiplyMM(vPMatrix, 0, projectionMatrix, 0, viewMatrix, 0)
        vPMatrixHandle = glGetUniformLocation(program, "uMVPMatrix")
        glUniformMatrix4fv(vPMatrixHandle, 1, false, vPMatrix, 0)
        DrawTriangles()
        DrawPoints()
        DrawLines()
    }

    private fun DrawPoints() {
        glUniform4f(uColorLocation, 1.0f, 1.0f, 1.0f, 1.0f)
        glDrawArrays(GL_POINTS, 8, 3)
    }

    private fun DrawLines() {
        glUniform4f(uColorLocation, 0f, 0f, 1.0f, 1.0f)
        glDrawArrays(GL_LINES, 6, 2)
    }

    private fun DrawTriangles() {
        glUniform4f(uColorLocation, 1.0f, 1.0f, 1.0f, 1.0f)
        glDrawArrays(GL_TRIANGLES, 0, 6)
    }

    override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
        var isPortrait = width > height
        glViewport(0, 0, width, height)
        var scale = 1.0f // added this for diagnostics. No apparent effect.
        var aspectRatio = if ( isPortrait ) { width / height.toFloat() } else { height / width.toFloat() }
        if (isPortrait) {
            // Portrait
            orthoM(projectionMatrix, 0, -aspectRatio * scale , aspectRatio * scale, -scale, scale, -2.0f, 2.0f)
        }else{
            // Landscape
            orthoM(projectionMatrix, 0 , -scale, scale, -aspectRatio * scale , aspectRatio * scale, -2.0f, 2.0f)
        }
    }

    override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
        glClearColor(0.75f,0.75f,0.75f,1.0f)
        val vertexShaderSource : String = TextResourceReaderService()
            .readTextFileFromResource(context, R.raw.simple_vertex_shader)
        val fragmentShaderSource : String = TextResourceReaderService()
            .readTextFileFromResource(context, R.raw.simple_fragment_shader)

        val vertexShader : Int = ShaderHelper().compileVertexShader(vertexShaderSource)
        val fragmentShader : Int = ShaderHelper().compileFragmentShader(fragmentShaderSource)

        program = ShaderHelper().linkProgram(vertexShader, fragmentShader)

        if(LoggerConfig.ON) {
            ShaderHelper().validateProgram(program)
        }

        glUseProgram(program)

        uColorLocation = glGetUniformLocation(program, u_Color)
        aPositionLocation = glGetAttribLocation(program, a_Position)
        vertexData.position(0)
        glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GL_FLOAT, false, 0, vertexData)
        glEnableVertexAttribArray(aPositionLocation)
        uMatrixLocation = glGetUniformLocation(program, U_Matrix)
    }
}

import android.opengl.GLES20.*
import android.util.Log

public class ShaderHelper{
    private val TAG : String = "ShaderHelper"

    public fun compileVertexShader (shaderCode : String): Int{
        return compileShader(GL_VERTEX_SHADER, shaderCode)
    }

    public fun compileFragmentShader (shaderCode : String): Int{
        return compileShader(GL_FRAGMENT_SHADER, shaderCode)
    }

    private fun compileShader(type: Int , shaderCode: String) : Int{
        val shaderObjectId : Int = glCreateShader(type)

        if(shaderObjectId == 0){
            if (LoggerConfig.ON){
                Log.w(TAG, "Could not create new Shader.")
            }
            return 0
        }
        glShaderSource(shaderObjectId, shaderCode)
        glCompileShader(shaderObjectId)

        val compileStatus : IntArray = IntArray(1)
        glGetShaderiv(shaderObjectId, GL_COMPILE_STATUS, compileStatus, 0 )

        if(LoggerConfig.ON){
            Log.v(TAG, "Results of compiling source: " + "\n" + shaderCode + "\n"
            + glGetShaderInfoLog(shaderObjectId))
        }
        if(compileStatus[0] == 0){
            glDeleteShader(shaderObjectId)
            Log.v(TAG, "Compilation of shader failed.")
            return 0
        }
        return shaderObjectId
    }

    public fun linkProgram (vertexShaderId : Int, fragmentShaderId : Int) : Int {
        val programObjectId : Int = glCreateProgram()

        if(programObjectId == 0) {
            if (LoggerConfig.ON) {
                Log.v(TAG, "Could not create GL Program.")
            }
            return 0
        }

        glAttachShader(programObjectId, vertexShaderId)
        glAttachShader(programObjectId, fragmentShaderId)
        glLinkProgram(programObjectId)

        val linkStatus : IntArray = IntArray(1)
        glGetProgramiv(programObjectId, GL_LINK_STATUS, linkStatus, 0)

        if (LoggerConfig.ON) {
            // Print the program info log to the Android log output.
            Log.v(TAG, "Results of linking program:\n"
                    + glGetProgramInfoLog(programObjectId));
        }

        if(linkStatus[0] == 0) {
            glDeleteProgram(programObjectId)
            if(LoggerConfig.ON){
                Log.v(TAG, "Linking of program failed.\n")
            }
            return 0
        }
        return programObjectId
    }

    public fun validateProgram(programObjectId : Int) : Boolean{
        glValidateProgram(programObjectId)
        val validateStatus = IntArray(1)
        glGetProgramiv(programObjectId, GL_VALIDATE_STATUS, validateStatus, 0);
        Log.v(TAG, "Results of validating program: " + validateStatus[0]
                + "\nLog:" + glGetProgramInfoLog(programObjectId));

        return validateStatus[0] != 0;  
    }
}

uniform mat4 uMVPMatrix;

attribute vec4 v_Position;

void main()
{
    gl_Position = uMVPMatrix * v_Position;
    gl_PointSize = 10.0;
}

precision mediump float;

uniform vec4 u_Color;

void main()
{
    gl_FragColor = u_Color;
}