OpenGL ES 렌 더 링 파이프라인 개요(1)

렌 더 링 라인 은 보통 칩 GPU 내부 에서 도형 신 호 를 처리 하 는 병렬 처리 장치 로 구성 되 는데 이런 병렬 처리 장치 들 은 독립 적 이 고 다른 측면 에서 볼 때 렌 더 링 라인 도 실제 적 으로 일련의 그리 기 과정 이다.이 일련의 과정의 입력 은 그림 개체 에 대한 설명 정보 이 고 출력 할 것 은 표시 할 이미지 프레임 데 이 터 를 출력 하 는 것 이다.
OpenGL ES 라인 은 주로 다음 과 같다.
정점 데이터 읽 기->정점 착색 기->조립 도원->래 스 터 화 도원->편 원 착색 기->프레임 버퍼 쓰기->화면 에 표시
4.567917.정점 데 이 터 를 읽 는 것 은 그 려 진 도형 의 정점 데 이 터 를 렌 더 링 라인 에 전달 하 는 것 을 말한다
  • 정점 착색 기 는 최종 적 으로 모든 정점 의 최종 위 치 를 생 성하 고 정점 의 각종 변 화 를 실행 합 니 다.정점 마다 한 번 씩 실행 하고 최종 위 치 를 확정 한 후에 OpenGL 은 이러한 정점 집합 을 주어진 매개 변수 유형 에 따라 점,선 또는 삼각형 으로 조립 할 수 있 습 니 다
  • 4.567917.조립 도원 단 계 는 두 부분 을 포함한다.도원 의 조립 과 도원 처리 이다.도원 조립 은 정점 데이터 가 설 정 된 그리 기 방식 파라미터 에 따라 완전한 도원 으로 결합 하 는 것 을 말한다.예 를 들 어 점 그리 기 방식 에서 모든 도원 은 한 점 만 포함 하고 선분 그리 기 방식 에서 모든 도원 은 두 점 을 포함한다.도원 처 리 는 주로 가위질 을 해서 도원 이 시경 체 내부 에 있 는 부분 을 다음 단계 로 전달 하고 시경 체 외부의 부분 을 가위질 한다.시경 체 의 개념 은 투영 과 관계 가 있다4.567917.래 스 터 화 그림 원 은 주로 하나의 그림 원 을 분리 하여 표시 할 수 있 는 2 차원 유닛 부분 으로 만 드 는 것 을 말 하 는데 이런 작은 단원 을 영화 원 이 라 고 부른다.하나의 조각 원 은 화면의 하나 또는 여러 픽 셀 에 대응 합 니 다.조각 원 은 위치,색상,무늬 좌표 등 정 보 를 포함 합 니 다.이런 값 은 그림 원 의 정점 정보 에 의 해 삽입 값 으로 계산 되 었 습 니 다4.567917.조각 원 착색 기 는 모든 조각 원 에 최종 색 을 만 들 고 모든 조각 원 에 대해 한 번 씩 실 행 됩 니 다.각 메타 의 색상 이 확인 되면 OpenGL 은 프레임 버퍼 에 기록 합 니 다.
    OpenGL ES 2.0 의 주요 두 부분 은 위의 프로 그래 밍 가능 한 정점 착색 기와 세 션 착색 기 입 니 다.OpenGL ES 를 배 우 는 것 은 주로 렌 더 링 라인 을 이해 하고 CPU 의 렌 더 링 과정 을 이해 하 는 것 입 니 다.주요 프로 그래 밍 작업 은 정점 착색 기와 필름 착색 기의 작성 에 있 습 니 다.
    육각형 그리 기
    효 과 는 그림 과 같다.

    육각형 류
    
    public class SixShape {
     private FloatBuffer mVertexBuffer;
     private FloatBuffer mColorBuffer;
     private int mProgram;
     private int mPositionHandle;
     private int mColorHandle;
     private int muMVPMatrixHandle;
    
     public SixShape(float r) {
      initVetexData(r);
     }
    
     public void initVetexData(float r) {
      //        
      float[] vertexArray = new float[8*3];
      //        
      float[] colorArray=new float[8*4];
      int j = 0, k = 0;
      vertexArray[j++] = 0;
      vertexArray[j++] = 0;
      vertexArray[j++] = 0;
    
      colorArray[k++] = 1;
      colorArray[k++] = 1;
      colorArray[k++] = 1;
      colorArray[k++] = 0;
      for (int angle = 0; angle <= 360; angle += 60) {
       vertexArray[j++] = (float) (r*Math.cos(Math.toRadians(angle)));
       vertexArray[j++] = (float) (r*Math.sin(Math.toRadians(angle)));
       vertexArray[j++] = 0;
    
       colorArray[k++] = 1;
       colorArray[k++] = 0;
       colorArray[k++] = 0;
       colorArray[k++] = 0;
      }
      ByteBuffer buffer = ByteBuffer.allocateDirect(vertexArray.length * 4);
      buffer.order(ByteOrder.nativeOrder());
      mVertexBuffer = buffer.asFloatBuffer();
      mVertexBuffer.put(vertexArray);
      mVertexBuffer.position(0);
    
      ByteBuffer cbb=ByteBuffer.allocateDirect(colorArray.length*4);
      cbb.order(ByteOrder.nativeOrder());
      mColorBuffer=cbb.asFloatBuffer();
      mColorBuffer.put(colorArray);
      mColorBuffer.position(0);
    
      int vertexShader = loaderShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
      int fragmentShader = loaderShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);
    
      mProgram = GLES20.glCreateProgram();
      GLES20.glAttachShader(mProgram, vertexShader);
      GLES20.glAttachShader(mProgram, fragmentShader);
      GLES20.glLinkProgram(mProgram);
    
      mPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
      mColorHandle = GLES20.glGetAttribLocation(mProgram, "aColor");
      muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
     }
    
     public void draw(float[] mvpMatrix) {
      GLES20.glUseProgram(mProgram);
      //           ,     
      GLES20.glVertexAttribPointer(mPositionHandle, 3, GLES20.GL_FLOAT, false, 3 * 4, mVertexBuffer);
      //           ,     
      GLES20.glVertexAttribPointer(mColorHandle, 4, GLES20.GL_FLOAT, false,4*4, mColorBuffer);
      //           
      GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mvpMatrix, 0);
      GLES20.glEnableVertexAttribArray(mPositionHandle);
      GLES20.glEnableVertexAttribArray(mColorHandle);
      //     
      GLES20.glDrawArrays(GLES20.GL_TRIANGLE_FAN, 0, 8);
     }
    
     private int loaderShader(int type, String shaderCode) {
      int shader = GLES20.glCreateShader(type);
      GLES20.glShaderSource(shader, shaderCode);
      GLES20.glCompileShader(shader);
      return shader;
     }
    
     private String vertexShaderCode = "uniform mat4 uMVPMatrix;"
       + "attribute vec3 aPosition;"
       + "attribute vec4 aColor;"
       + "varying vec4 aaColor;"
       + "void main(){"
       + "gl_Position = uMVPMatrix * vec4(aPosition,1);"
       + "aaColor = aColor;"
       + "}";
    
     private String fragmentShaderCode = "precision mediump float;"
       + "varying vec4 aaColor;"
       + "void main(){"
       + "gl_FragColor = aaColor;"
       + "}";
    
    }
    육각형 보기
    
    public class SixView extends GLSurfaceView{
    
     public SixView(Context context) {
      super(context);
      setEGLContextClientVersion(2);
      setRenderer(new MyRender());
     }
    
     class MyRender implements GLSurfaceView.Renderer {
      private SixShape circle;
    
      @Override
      public void onSurfaceCreated(GL10 gl, EGLConfig config) {
       GLES20.glClearColor(0.5f, 0.5f, 0.5f, 1);
       circle = new SixShape(0.5f);
       GLES20.glEnable(GLES20.GL_DEPTH_TEST);
      }
    
      //     
      private final float[] mProjectionMatrix = new float[16];
      //     
      private final float[] mViewMatrix = new float[16];
      //     
      private final float[] mMMatrix = new float[16];
      private final float[] mViewProjectionMatrix = new float[16];
      private final float[] mMVPMatrix = new float[16];
    
      @Override
      public void onSurfaceChanged(GL10 gl, int width, int height) {
       GLES20.glViewport(0, 0, width, height);
       float ratio= (float) width / height;
       //       
       Matrix.orthoM(mProjectionMatrix, 0, -ratio, ratio, -1, 1, 0, 5);
       //       
       Matrix.setLookAtM(mViewMatrix, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0);
      }
    
      @Override
      public void onDrawFrame(GL10 gl) {
       GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
       Matrix.multiplyMM(mViewProjectionMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);
       //       
       Matrix.setIdentityM(mMMatrix, 0);
       Matrix.translateM(mMMatrix,0,0,0,1);
       Matrix.rotateM(mMMatrix, 0, 30, 0, 0, 1);
       Matrix.multiplyMM(mMVPMatrix, 0, mViewProjectionMatrix, 0, mMMatrix, 0);
       circle.draw(mMVPMatrix);
      }
     }
    
    }
    이제 Activity 에서 이 View 를 사용 할 수 있 습 니 다.위의 예 는 간단 하지만 OpenGL ES 프로 그래 밍 을 사용 하 는 주요 절 차 를 포함 합 니 다.정점 데 이 터 를 만 들 고 정점 착색 기 를 작성 하 며 조각 착색 기 를 작성 하여 정점/조각 착색 기 에 데 이 터 를 전달 하 는 것 을 포함 합 니 다.여기 서 가장 중요 한 것 은 착색 기 언어 입 니 다.그 밖 에 투영,평이,회전 등 조작 도 포함한다.그 다음 에 모든 디 테 일과 위의 예 에 언급 되 지 않 은 빛,무늬 등 OpenGL 에 대한 지식 을 자세히 배 울 것 입 니 다.
    이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.

    좋은 웹페이지 즐겨찾기