투영 및 카메라 보기 적용
컬렉션을 사용해 정리하기
내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요.
OpenGL ES 환경에서 투영 및 카메라 보기를 사용하면 그린 객체를
눈으로 실제 물체를 보는 방식과 더 흡사하게 됩니다. 이 시뮬레이션은
실제 보기는 그린 객체의 좌표를 다음과 같이 수학적 변환하여 수행됩니다.
- 투영 - 이 변환은 그린 객체의 좌표를 기반으로
표시되는
GLSurfaceView
의 너비와 높이입니다. 제외
OpenGL ES에서 그린 객체는
창 일반적으로 투영 변환은 변환의 비율이
OpenGL 뷰는 렌더기의 onSurfaceChanged()
메서드에서 설정되거나 변경됩니다. OpenGL ES 투영과
좌표 매핑은
그리기 위한 좌표 매핑
객체를 사용하여 이 작업을 실행할 수 있습니다.
- 카메라 뷰 - 이 변환은 그린 객체의 좌표를 기준으로
가상 카메라 위치입니다. OpenGL ES는 실제 카메라를 정의하는 것이 아니라
객체의 표시를 변환하여 카메라를 시뮬레이션하는 유틸리티 메서드를 제공합니다.
객체를 반환합니다. 카메라 뷰 변환은
GLSurfaceView
또는 사용자 액션 또는
애플리케이션의 기능을
알아보겠습니다
이 단원에서는 투영과 카메라 뷰를 만들어 직접 그린 도형에 적용하는 방법을 설명합니다.
내 GLSurfaceView
프로젝션 정의
투영 변환의 데이터는 onSurfaceChanged()
에서 계산됩니다.
(GLSurfaceView.Renderer
클래스의 메서드) 다음 예시 코드는
GLSurfaceView
의 높이와 너비를 가져와서 이를 사용하여
Matrix.frustumM()
메서드를 사용한 투영 변환 Matrix
:
Kotlin
// vPMatrix is an abbreviation for "Model View Projection Matrix"
private val vPMatrix = FloatArray(16)
private val projectionMatrix = FloatArray(16)
private val viewMatrix = FloatArray(16)
override fun onSurfaceChanged(unused: GL10, width: Int, height: Int) {
GLES20.glViewport(0, 0, width, height)
val ratio: Float = width.toFloat() / height.toFloat()
// this projection matrix is applied to object coordinates
// in the onDrawFrame() method
Matrix.frustumM(projectionMatrix, 0, -ratio, ratio, -1f, 1f, 3f, 7f)
}
자바
// vPMatrix is an abbreviation for "Model View Projection Matrix"
private final float[] vPMatrix = new float[16];
private final float[] projectionMatrix = new float[16];
private final float[] viewMatrix = new float[16];
@Override
public void onSurfaceChanged(GL10 unused, int width, int height) {
GLES20.glViewport(0, 0, width, height);
float ratio = (float) width / height;
// this projection matrix is applied to object coordinates
// in the onDrawFrame() method
Matrix.frustumM(projectionMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
}
이 코드는 투영 행렬 mProjectionMatrix
을 채우고 이를 결합하면
다음 섹션에 나와 있는 onDrawFrame()
메서드에서 카메라 뷰 변환을 사용합니다.
참고: 변환에 투영 변환을 적용하기만 하면
그리기 객체는 일반적으로 빈 화면으로 표시됩니다. 일반적으로 카메라와
화면에 모든 내용이 표시되도록 할 수 있습니다.
카메라 보기 정의
카메라 뷰 변환을
렌더러에서 그리기 프로세스의 일부분만 처리할 수 있습니다. 다음 코드 예에서 카메라 뷰는
변환은 Matrix.setLookAtM()
메서드를 사용한 다음 이전에 계산된 투영 행렬과 결합합니다. 결합된
그러면 변환 행렬이 그려진 도형에 전달됩니다.
Kotlin
override fun onDrawFrame(unused: GL10) {
...
// Set the camera position (View matrix)
Matrix.setLookAtM(viewMatrix, 0, 0f, 0f, 3f, 0f, 0f, 0f, 0f, 1.0f, 0.0f)
// Calculate the projection and view transformation
Matrix.multiplyMM(vPMatrix, 0, projectionMatrix, 0, viewMatrix, 0)
// Draw shape
triangle.draw(vPMatrix)
자바
@Override
public void onDrawFrame(GL10 unused) {
...
// Set the camera position (View matrix)
Matrix.setLookAtM(viewMatrix, 0, 0, 0, 3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
// Calculate the projection and view transformation
Matrix.multiplyMM(vPMatrix, 0, projectionMatrix, 0, viewMatrix, 0);
// Draw shape
triangle.draw(vPMatrix);
}
위의 예와 같이 결합된 투영과 카메라 보기 변환 매트릭스를 사용하려면
미리보기 섹션에서 먼저 이전에 정의한 꼭짓점 셰이더에 행렬 변수를 추가합니다.
(Triangle
클래스에서:
Kotlin
class Triangle {
private val 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;" +
"}"
// Use to access and set the view transformation
private var vPMatrixHandle: Int = 0
...
}
자바
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;" +
"}";
// Use to access and set the view transformation
private int vPMatrixHandle;
...
}
다음으로 그래픽 객체의 draw()
메서드를 수정하여 결합된
형상에 적용합니다.
Kotlin
fun draw(mvpMatrix: FloatArray) { // pass in the calculated transformation matrix
...
// get handle to shape's transformation matrix
vPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix")
// Pass the projection and view transformation to the shader
GLES20.glUniformMatrix4fv(vPMatrixHandle, 1, false, mvpMatrix, 0)
// Draw the triangle
GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount)
// Disable vertex array
GLES20.glDisableVertexAttribArray(positionHandle)
}
자바
public void draw(float[] mvpMatrix) { // pass in the calculated transformation matrix
...
// get handle to shape's transformation matrix
vPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
// Pass the projection and view transformation to the shader
GLES20.glUniformMatrix4fv(vPMatrixHandle, 1, false, mvpMatrix, 0);
// Draw the triangle
GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);
// Disable vertex array
GLES20.glDisableVertexAttribArray(positionHandle);
}
투영과 카메라 뷰 변환을 올바르게 계산하고 적용했으면
그래픽 객체는 올바른 비율로 그려지며 다음과 같이 표시됩니다.
그림 1. 투영 및 카메라 보기를 적용하여 그린 삼각형.
이제 올바른 비율로 형상을 표시하는 애플리케이션을 만들었으므로
도형에 모션을 추가하세요.
이 페이지에 나와 있는 콘텐츠와 코드 샘플에는 콘텐츠 라이선스에서 설명하는 라이선스가 적용됩니다. 자바 및 OpenJDK는 Oracle 및 Oracle 계열사의 상표 또는 등록 상표입니다.
최종 업데이트: 2025-07-27(UTC)
[[["이해하기 쉬움","easyToUnderstand","thumb-up"],["문제가 해결됨","solvedMyProblem","thumb-up"],["기타","otherUp","thumb-up"]],[["필요한 정보가 없음","missingTheInformationINeed","thumb-down"],["너무 복잡함/단계 수가 너무 많음","tooComplicatedTooManySteps","thumb-down"],["오래됨","outOfDate","thumb-down"],["번역 문제","translationIssue","thumb-down"],["샘플/코드 문제","samplesCodeIssue","thumb-down"],["기타","otherDown","thumb-down"]],["최종 업데이트: 2025-07-27(UTC)"],[],[],null,["# Apply projection and camera views\n\nIn the OpenGL ES environment, projection and camera views allow you to display drawn objects in a\nway that more closely resembles how you see physical objects with your eyes. This simulation of\nphysical viewing is done with mathematical transformations of drawn object coordinates:\n\n- *Projection* - This transformation adjusts the coordinates of drawn objects based on the width and height of the [GLSurfaceView](/reference/android/opengl/GLSurfaceView) where they are displayed. Without this calculation, objects drawn by OpenGL ES are skewed by the unequal proportions of the view window. A projection transformation typically only has to be calculated when the proportions of the OpenGL view are established or changed in the [onSurfaceChanged()](/reference/android/opengl/GLSurfaceView.Renderer#onSurfaceChanged(javax.microedition.khronos.opengles.GL10, int, int)) method of your renderer. For more information about OpenGL ES projections and coordinate mapping, see [Mapping coordinates for drawn\n objects](/develop/ui/views/graphics/opengl/about-opengl#coordinate-mapping).\n- *Camera View* - This transformation adjusts the coordinates of drawn objects based on a virtual camera position. It's important to note that OpenGL ES does not define an actual camera object, but instead provides utility methods that simulate a camera by transforming the display of drawn objects. A camera view transformation might be calculated only once when you establish your [GLSurfaceView](/reference/android/opengl/GLSurfaceView), or might change dynamically based on user actions or your application's function.\n\nThis lesson describes how to create a projection and camera view and apply it to shapes drawn in\nyour [GLSurfaceView](/reference/android/opengl/GLSurfaceView).\n\nDefine a projection\n-------------------\n\nThe data for a projection transformation is calculated in the [onSurfaceChanged()](/reference/android/opengl/GLSurfaceView.Renderer#onSurfaceChanged(javax.microedition.khronos.opengles.GL10, int, int))\nmethod of your [GLSurfaceView.Renderer](/reference/android/opengl/GLSurfaceView.Renderer) class. The following example code\ntakes the height and width of the [GLSurfaceView](/reference/android/opengl/GLSurfaceView) and uses it to populate a\nprojection transformation [Matrix](/reference/android/opengl/Matrix) using the [Matrix.frustumM()](/reference/android/opengl/Matrix#frustumM(float[], int, float, float, float, float, float, float)) method: \n\n### Kotlin\n\n```kotlin\n// vPMatrix is an abbreviation for \"Model View Projection Matrix\"\nprivate val vPMatrix = FloatArray(16)\nprivate val projectionMatrix = FloatArray(16)\nprivate val viewMatrix = FloatArray(16)\n\noverride fun onSurfaceChanged(unused: GL10, width: Int, height: Int) {\n GLES20.glViewport(0, 0, width, height)\n\n val ratio: Float = width.toFloat() / height.toFloat()\n\n // this projection matrix is applied to object coordinates\n // in the onDrawFrame() method\n Matrix.frustumM(projectionMatrix, 0, -ratio, ratio, -1f, 1f, 3f, 7f)\n}\n```\n\n### Java\n\n```java\n// vPMatrix is an abbreviation for \"Model View Projection Matrix\"\nprivate final float[] vPMatrix = new float[16];\nprivate final float[] projectionMatrix = new float[16];\nprivate final float[] viewMatrix = new float[16];\n\n@Override\npublic void onSurfaceChanged(GL10 unused, int width, int height) {\n GLES20.glViewport(0, 0, width, height);\n\n float ratio = (float) width / height;\n\n // this projection matrix is applied to object coordinates\n // in the onDrawFrame() method\n Matrix.frustumM(projectionMatrix, 0, -ratio, ratio, -1, 1, 3, 7);\n}\n```\n\nThis code populates a projection matrix, `mProjectionMatrix` which you can then combine\nwith a camera view transformation in the [onDrawFrame()](/reference/android/opengl/GLSurfaceView.Renderer#onDrawFrame(javax.microedition.khronos.opengles.GL10)) method, which is shown in the next section.\n\n**Note:** Just applying a projection transformation to your\ndrawing objects typically results in a very empty display. In general, you must also apply a camera\nview transformation in order for anything to show up on screen.\n\nDefine a camera view\n--------------------\n\nComplete the process of transforming your drawn objects by adding a camera view transformation as\npart of the drawing process in your renderer. In the following example code, the camera view\ntransformation is calculated using the [Matrix.setLookAtM()](/reference/android/opengl/Matrix#setLookAtM(float[], int, float, float, float, float, float, float, float, float, float))\nmethod and then combined with the previously calculated projection matrix. The combined\ntransformation matrices are then passed to the drawn shape. \n\n### Kotlin\n\n```kotlin\noverride fun onDrawFrame(unused: GL10) {\n ...\n // Set the camera position (View matrix)\n Matrix.setLookAtM(viewMatrix, 0, 0f, 0f, 3f, 0f, 0f, 0f, 0f, 1.0f, 0.0f)\n\n // Calculate the projection and view transformation\n Matrix.multiplyMM(vPMatrix, 0, projectionMatrix, 0, viewMatrix, 0)\n\n // Draw shape\n triangle.draw(vPMatrix)\n```\n\n### Java\n\n```java\n@Override\npublic void onDrawFrame(GL10 unused) {\n ...\n // Set the camera position (View matrix)\n Matrix.setLookAtM(viewMatrix, 0, 0, 0, 3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);\n\n // Calculate the projection and view transformation\n Matrix.multiplyMM(vPMatrix, 0, projectionMatrix, 0, viewMatrix, 0);\n\n // Draw shape\n triangle.draw(vPMatrix);\n}\n```\n\nApply projection and camera transformations\n-------------------------------------------\n\nIn order to use the combined projection and camera view transformation matrix shown in the\npreviews sections, first add a matrix variable to the *vertex shader* previously defined\nin the `Triangle` class: \n\n### Kotlin\n\n```kotlin\nclass Triangle {\n\n private val vertexShaderCode =\n // This matrix member variable provides a hook to manipulate\n // the coordinates of the objects that use this vertex shader\n \"uniform mat4 uMVPMatrix;\" +\n \"attribute vec4 vPosition;\" +\n \"void main() {\" +\n // the matrix must be included as a modifier of gl_Position\n // Note that the uMVPMatrix factor *must be first* in order\n // for the matrix multiplication product to be correct.\n \" gl_Position = uMVPMatrix * vPosition;\" +\n \"}\"\n\n // Use to access and set the view transformation\n private var vPMatrixHandle: Int = 0\n\n ...\n}\n```\n\n### Java\n\n```java\npublic class Triangle {\n\n private final String vertexShaderCode =\n // This matrix member variable provides a hook to manipulate\n // the coordinates of the objects that use this vertex shader\n \"uniform mat4 uMVPMatrix;\" +\n \"attribute vec4 vPosition;\" +\n \"void main() {\" +\n // the matrix must be included as a modifier of gl_Position\n // Note that the uMVPMatrix factor *must be first* in order\n // for the matrix multiplication product to be correct.\n \" gl_Position = uMVPMatrix * vPosition;\" +\n \"}\";\n\n // Use to access and set the view transformation\n private int vPMatrixHandle;\n\n ...\n}\n```\n\nNext, modify the `draw()` method of your graphic objects to accept the combined\ntransformation matrix and apply it to the shape: \n\n### Kotlin\n\n```kotlin\nfun draw(mvpMatrix: FloatArray) { // pass in the calculated transformation matrix\n ...\n\n // get handle to shape's transformation matrix\n vPMatrixHandle = GLES20.glGetUniformLocation(mProgram, \"uMVPMatrix\")\n\n // Pass the projection and view transformation to the shader\n GLES20.glUniformMatrix4fv(vPMatrixHandle, 1, false, mvpMatrix, 0)\n\n // Draw the triangle\n GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount)\n\n // Disable vertex array\n GLES20.glDisableVertexAttribArray(positionHandle)\n}\n```\n\n### Java\n\n```java\npublic void draw(float[] mvpMatrix) { // pass in the calculated transformation matrix\n ...\n\n // get handle to shape's transformation matrix\n vPMatrixHandle = GLES20.glGetUniformLocation(mProgram, \"uMVPMatrix\");\n\n // Pass the projection and view transformation to the shader\n GLES20.glUniformMatrix4fv(vPMatrixHandle, 1, false, mvpMatrix, 0);\n\n // Draw the triangle\n GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);\n\n // Disable vertex array\n GLES20.glDisableVertexAttribArray(positionHandle);\n}\n```\n\nOnce you have correctly calculated and applied the projection and camera view transformations,\nyour graphic objects are drawn in correct proportions and should look like this:\n\n\n**Figure 1.** Triangle drawn with a projection and camera view applied.\n\nNow that you have an application that displays your shapes in correct proportions, it's time to\nadd motion to your shapes."]]