在Y軸上打開GL轉換Java或C＃

嗨我是OpenGL的新手，我有一個創建到我的SurfaceView的三角形，它會輪流顯示在我的屏幕上。我已經能夠添加旋轉來使我的三角形旋轉，但這不是我所需要的。我一直在研究OpenGL，並且已經閱讀了Transformation，然後進入了Translation，我認爲這對於向我的Triangle添加垂直運動是正確的，但是根據我目前的理解，我一直無法實現這一點。在Y軸上打開GL轉換Java或C＃

實施例：

三角是在屏幕的頂部產生和Y軸朝向屏幕的底部向下移動。

這個翻譯是在一個角度，但它顯示了我的意思，我只想在y軸移動。

我有一個如下方式呈現：

public class MyGLRenderer implements GLSurfaceView.Renderer { 
    //Project Matrix 
    private float mMatrix[] = new float[16]; 
    private Triangle mTriangle; 

    private final float[] mMVPMatrix = new float[16]; 
    private final float[] mModelMatrix = new float[16]; 
    private float[] mTempMatrix = new float[16]; 
    private final float[] mProjectionMatrix = new float[16]; 
    private final float[] mViewMatrix = new float[16]; 
    private final float[] mRotationMatrix = new float[16]; 

    // Called once to set up the view's opengl es environment 
    public void onSurfaceCreated(GL10 unused, EGLConfig config){ 

    //Set the background frame color 
    GLES30.glClearColor(208.0f,208.0f,208.0f,1.0f); 

    mTriangle= new Triangle(); 
} 

// Called for each redraw of the view 
public void onDrawFrame(GL10 gl){ 
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT); 

    //Redraw background color 
    GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT); 

    // Apply transformation, start with translation 
    Matrix.setIdentityM(mModelMatrix, 0); // initialize to identity matrix 
    Matrix.translateM(mModelMatrix, 0, -0.5f, 0, 0); // translation to the left 
    // Create a rotation transformation for the triangle 
    long time = SystemClock.uptimeMillis() % 4000L; 
    float mAngle = 0.090f * ((int) time); 
    Matrix.setRotateM(mRotationMatrix, 0, mAngle, 0, 0, -1.0f); 

    Matrix.orthoM(mMatrix, 0, -1, 1, -1, 1, -1, 1); 

    // Combine Rotation and Translation matrices 
    mTempMatrix = mModelMatrix.clone(); 
    Matrix.multiplyMM(mModelMatrix, 0, mTempMatrix, 0, mRotationMatrix, 0); 

    // Combine the model matrix with the projection and camera view 
    mTempMatrix = mMVPMatrix.clone(); 
    Matrix.multiplyMM(mMVPMatrix, 0, mTempMatrix, 0, mModelMatrix, 0); 

    mTriangle.draw(mMatrix); 

} 

// Called if the geometry of the view changes (example is when the screen orientation changes from landscape to portrait 
public void onSurfaceChanged(GL10 unused, int width, int height){ 
    // Called if the geometry of the viewport changes 
    GLES30.glViewport(0, 0, width, height); 
} 

public static int loadShader(int type, String shaderCode){ 

    // create a vertex shader type (GLES30.GL_VERTEX_SHADER) 
    // or a fragment shader type (GLES30.GL_FRAGMENT_SHADER) 
    int shader = GLES30.glCreateShader(type); 

    // add the source code to the shader and compile it 
    GLES30.glShaderSource(shader, shaderCode); 
    GLES30.glCompileShader(shader); 

    return shader; 
}

}

我有一個三角形如下：

public class Triangle { 

    private final String vertexShaderCode = 
    // This matrix member variable provides a hook to manipulate 
    // the coordinates of the objects that use this vertex shader 
    "uniform mat4 uMVPMatrix;" + 
    "attribute vec4 vPosition;" + 
    "void main() {" + 
    // the matrix must be included as a modifier of gl_Position 
    // Note that the uMVPMatrix factor *must be first* in order 
    // for the matrix multiplication product to be correct. 
    " gl_Position = uMVPMatrix * vPosition;" + 
    "}"; 

    private final String fragmentShaderCode = 
     "precision mediump float;" + 
     "uniform vec4 vColor;" + 
     "void main() {" + 
     " gl_FragColor = vColor;" + 
     "}"; 

    private final FloatBuffer vertexBuffer; 
    private final int mProgram; 
    private int mPositionHandle; 
    private int mColorHandle; 
    private int mMVPMatrixHandle; 

    // number of coordinates per vertex in this array 
    static final int COORDS_PER_VERTEX = 3; 
    static float triangleCoords[] = { 
    // in counterclockwise order: 
    0.0f, 0.622008459f, 0.0f, // top 
    -0.5f, -0.311004243f, 0.0f, // bottom left 
    0.5f, -0.311004243f, 0.0f // bottom right 
}; 

private final int vertexCount = triangleCoords.length/COORDS_PER_VERTEX; 
private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex 
float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 0.0f }; 

/** 
* Sets up the drawing object data for use in an OpenGL ES context. 
*/ 
public Triangle() { 
    // initialize vertex byte buffer for shape coordinates 
    ByteBuffer bb = ByteBuffer.allocateDirect(
    // (number of coordinate values * 4 bytes per float) 
    triangleCoords.length * 4); 
    // use the device hardware's native byte order 
    bb.order(ByteOrder.nativeOrder()); 

    // create a floating point buffer from the ByteBuffer 
    vertexBuffer = bb.asFloatBuffer(); 
    // add the coordinates to the FloatBuffer 
    vertexBuffer.put(triangleCoords); 
    // set the buffer to read the first coordinate 
    vertexBuffer.position(0); 

    // prepare shaders and OpenGL program 
    int vertexShader = MyGLRenderer.loadShader(
     GLES20.GL_VERTEX_SHADER, vertexShaderCode); 
    int fragmentShader = MyGLRenderer.loadShader(
     GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); 

    mProgram = GLES20.glCreateProgram();    // create empty OpenGL Program 
    GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader to program 
    GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program 
    GLES20.glLinkProgram(mProgram);     // create OpenGL program executables 

} 

/** 
* Encapsulates the OpenGL ES instructions for drawing this shape. 
* 
* @param mvpMatrix - The Model View Project matrix in which to draw 
* this shape. 
*/ 
public void draw(float[] mvpMatrix) { 
    // Add program to OpenGL environment 
    GLES20.glUseProgram(mProgram); 

    // get handle to vertex shader's vPosition member 
    mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition"); 

    // Enable a handle to the triangle vertices 
    GLES20.glEnableVertexAttribArray(mPositionHandle); 

    // Prepare the triangle coordinate data 
    GLES20.glVertexAttribPointer(
     mPositionHandle, COORDS_PER_VERTEX, 
     GLES20.GL_FLOAT, false, 
     vertexStride, vertexBuffer); 

    // get handle to fragment shader's vColor member 
    mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor"); 

    // Set color for drawing the triangle 
    GLES20.glUniform4fv(mColorHandle, 1, color, 0); 

    // get handle to shape's transformation matrix 
    mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix"); 

    // Apply the projection and view transformation 
    GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0); 

    // Draw the triangle 
    GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount); 

    // Disable vertex array 
    GLES20.glDisableVertexAttribArray(mPositionHandle); 
}

}

我從表面上看如下：

public class MyGLSurfaceView extends GLSurfaceView { 

    private final MyGLRenderer mRenderer; 

    public MyGLSurfaceView(Context context, AttributeSet attrs){ 
    super(context, attrs); 

    //Create an OpenGl 3.0 context 
    setEGLContextClientVersion(3); 

    mRenderer = new MyGLRenderer(); 

    //Set the Renderer for drawing on the GLSurfaceView 
    setRenderer(mRenderer); 
}

}

我找了一個光禿禿的骨頭例如/答案/ URL，可以實現在y軸上移動繪製三角形（我假設使用翻譯）。

我已閱讀並嘗試實施以下鏈接（以上方式超出我目前的理解）。

除了其他一些然而這些似乎我已經找到了最好的來源。

有關如何完成此任何答案非常感謝。提前致謝。

來源

2016-03-05 L1ghtk3ira

是的，這將是一個翻譯。這很簡單，你需要做的就是在'Triangle'的'draw（）'方法中修改'mvpMatrix'。使用任何你正在使用的函數庫（我不確定，但是例如，'Matrix.translateM（mModelMatrix，trianglePos.y，0,0,0）;'）來轉換Y軸上的矩陣，）並將新修改的矩陣賦予'glUniformMatrix4fv（）'。當然，要讓它移動，你必須增加三角形的每一幀的y位置。 – fordcars

而且，如果你還沒有，你需要跟蹤三角形的位置！ – fordcars

您可以通過給出的代碼提供的示例來回答問題嗎？ – L1ghtk3ira

是的，這將是一個翻譯。這很簡單，你需要做的就是修改mvpMatrix的draw()方法Triangle。

但是，跟蹤三角形的位置以使其移動很重要。你會私有成員添加到類類似這樣的：

private Point mPosition;

請記住，在代碼中的Point是一個簡單的點/矢量類我假設你有，因爲我敢肯定這是在Android？退房this class。

然後，你需要增加每一幀三角形的y位置。你可以在draw()中這樣做，但我會添加另一種移動方法。

mPosition.y += 0.01;

注：我看到你有一個MVP矩陣作爲參數傳遞給draw。現在，由於這是2D和正交的，因此它不是那麼重要，但考慮將您的旋轉從onDrawFrame()函數移動到Triangle.draw()，因爲M代表通常爲每個模型/三角形的模型。通常，您只能將VP（查看和投影）傳遞給Triangle.draw()方法。檢查this了。

最後，您將在三角形的位置上翻譯Triangle.draw()方法中的mvp矩陣。所以，在將矩陣傳遞給着色器之前（在GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);之前），翻譯它：

Matrix.translateM(mvpMatrix, mPosition.x, mPosition.y); 
// Or whatever translate method you have, I am not sure

來源

2016-03-06 19:27:58 fordcars

在Y軸上打開GL轉換Java或C＃

回答

相關問題