Форум программистов, компьютерный форум CyberForum.ru

GLES 2 ошибка при отрисовке квадрата - Android

Войти
Регистрация
Восстановить пароль
 
contedevel
 Аватар для contedevel
57 / 55 / 8
Регистрация: 07.10.2012
Сообщений: 589
12.11.2014, 03:36     GLES 2 ошибка при отрисовке квадрата #1
Здравствуйте!
Никак не пойму, в чем ошибка... В openGL полный чайник и завис на первых же шагах.
Кликните здесь для просмотра всего текста
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
package com.*.*.render;
 
***
 
public class EasyRenderer implements GLSurfaceView.Renderer {
    public static final String TAG = EasyRenderer.class.getSimpleName();
    protected EasySettings settings;
    private FloatBuffer fb;
    private EasySquare square;
    private float[] viewMatrix = new float[16];
    private float[] projectionMatrix = new float[16];
    private float[] modelMatrix = new float[16];
    private float[] mvpMatrix = new float[16];
    private final int strideBytes = 7 * 4;
    private final int positionOffset = 0;
    private final int positionDataSize = 3;
    private final int colorOffset = 3;
    private final int colorDataSize = 4;
    private int mvpMatrixHandle;
    private int positionHandle;
    private int colorHandle;
 
    public EasyRenderer(EasySettings settings) {
        if(settings == null)
            throw new NullPointerException("EasySettings cannot be null!");
        this.settings = settings;
        square = new EasySquare(0, 0, 1.0f, 1.0f);
 
        fb = ByteBuffer
                .allocate(square.getCache().length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer();
 
        fb.put(square.getCache()).position(0);
 
    }
 
    @Override
    public void onSurfaceCreated(GL10 gl10, EGLConfig eglConfig) {
        GLES20.glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
 
        final float eyeX = 0.0f;
        final float eyeY = 0.0f;
        final float eyeZ = 1.5f;
 
        final float lookX = 0.0f;
        final float lookY = 0.0f;
        final float lookZ = -5.0f;
 
        final float upX = 0.0f;
        final float upY = 1.0f;
        final float upZ = 0.0f;
 
        Matrix.setLookAtM(viewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
 
        final String vertexShader =
                "uniform mat4 u_MVPMatrix;\n"
                        + "attribute vec4 a_Position;     \n"
                        + "attribute vec4 a_Color;        \n"   
                        + "varying vec4 v_Color;          \n"
                        + "void main()                    \n"
                        + "{                              \n"
                        + "   v_Color = a_Color;          \n"
                        + "   gl_Position = u_MVPMatrix   \n"
                        + "               * a_Position;   \n"
                        + "}                              \n";
 
        final String fragmentShader =
                "precision mediump float;\n"
                        + "varying vec4 v_Color;\n"
                        + "void main()\n"
                        + "{\n"
                        + "   gl_FragColor = v_Color;\n"
                        + "}\n";
 
        int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);
 
        if (vertexShaderHandle != 0)
        {
            GLES20.glShaderSource(vertexShaderHandle, vertexShader);
 
            GLES20.glCompileShader(vertexShaderHandle);
 
            final int[] compileStatus = new int[1];
            GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
 
            if (compileStatus[0] == 0)
            {
                GLES20.glDeleteShader(vertexShaderHandle);
                vertexShaderHandle = 0;
            }
        }
 
        if (vertexShaderHandle == 0)
        {
            throw new RuntimeException("Error creating vertex shader.");
        }
 
        int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER);
 
        if (fragmentShaderHandle != 0)
        {
            GLES20.glShaderSource(fragmentShaderHandle, fragmentShader);
 
            GLES20.glCompileShader(fragmentShaderHandle);
 
            final int[] compileStatus = new int[1];
            GLES20.glGetShaderiv(fragmentShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
 
            if (compileStatus[0] == 0)
            {
                GLES20.glDeleteShader(fragmentShaderHandle);
                fragmentShaderHandle = 0;
            }
        }
 
        if (fragmentShaderHandle == 0)
        {
            throw new RuntimeException("Error creating fragment shader.");
        }
 
        // Create a program object and store the handle to it.
        int programHandle = GLES20.glCreateProgram();
 
        if (programHandle != 0)
        {
            // Bind the vertex shader to the program.
            GLES20.glAttachShader(programHandle, vertexShaderHandle);
 
            // Bind the fragment shader to the program.
            GLES20.glAttachShader(programHandle, fragmentShaderHandle);
 
            // Bind attributes
            GLES20.glBindAttribLocation(programHandle, 0, "a_Position");
            GLES20.glBindAttribLocation(programHandle, 1, "a_Color");
 
            // Link the two shaders together into a program.
            GLES20.glLinkProgram(programHandle);
 
            // Get the link status.
            final int[] linkStatus = new int[1];
            GLES20.glGetProgramiv(programHandle, GLES20.GL_LINK_STATUS, linkStatus, 0);
 
            // If the link failed, delete the program.
            if (linkStatus[0] == 0)
            {
                GLES20.glDeleteProgram(programHandle);
                programHandle = 0;
            }
        }
 
        if (programHandle == 0)
        {
            throw new RuntimeException("Error creating program.");
        }
 
        mvpMatrixHandle = GLES20.glGetUniformLocation(programHandle, "u_MVPMatrix");
        positionHandle = GLES20.glGetAttribLocation(programHandle, "a_Position");
        colorHandle = GLES20.glGetAttribLocation(programHandle, "a_Color");
 
        GLES20.glUseProgram(programHandle);
    }
 
    @Override
    public void onSurfaceChanged(GL10 gl10, int width, int height) {
        // Set the OpenGL viewport to the same size as the surface.
        GLES20.glViewport(0, 0, width, height);
 
        final float ratio = (float) width / height;
        final float left = -ratio;
        final float right = ratio;
        final float bottom = -1.0f;
        final float top = 1.0f;
        final float near = 1.0f;
        final float far = 10.0f;
 
        Matrix.frustumM(projectionMatrix, 0, left, right, bottom, top, near, far);
    }
 
    @Override
    public void onDrawFrame(GL10 gl10) {
        GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
 
        Matrix.setIdentityM(modelMatrix, 0);
        Matrix.rotateM(modelMatrix, 0, 0, 0.0f, 0.0f, 1.0f);
        drawTriangle(fb);
    }
 
    private void drawTriangle(final FloatBuffer fb)
    {
        fb.position(positionOffset);
        GLES20.glVertexAttribPointer(positionHandle, positionDataSize, GLES20.GL_FLOAT, false,
                strideBytes, fb);
 
        GLES20.glEnableVertexAttribArray(positionHandle);
 
        fb.position(colorOffset);
        GLES20.glVertexAttribPointer(colorHandle, colorDataSize, GLES20.GL_FLOAT, false,
                strideBytes, fb);
 
        GLES20.glEnableVertexAttribArray(colorHandle);
 
        Matrix.multiplyMM(mvpMatrix, 0, viewMatrix, 0, modelMatrix, 0);
        Matrix.multiplyMM(mvpMatrix, 0, projectionMatrix, 0, mvpMatrix, 0);
 
        GLES20.glUniformMatrix4fv(mvpMatrixHandle, 1, false, mvpMatrix, 0);
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 4);
    }
}


Кликните здесь для просмотра всего текста
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com.*.*.objects;
 
***
 
public class EasySquare extends EasyRectangle implements RealObject, IMovement, IRotatable {
    public static final String TAG = EasySquare.class.getSimpleName();
    private float[] cache;
    private EasyColor color;
 
    public EasySquare(float x, float y, float width, float height) {
        super(x, y, width, height);
        init();
    }
 
    public EasySquare(EasyVector location, EasyVector size) {
        super(location, size);
        init();
    }
 
    private void init() {
        color = new EasyColor(0.0f, 0.0f, 0.0f);
        onUpdate();
    }
 
    @Override
    public void onDraw() {
    }
 
    @Override
    public void onUpdate() {
        float hw = width/2;
        float hh = height/2;
        float[] c = color.getColor();
        cache = new float[]
                // X       Y      Z     R     G     B     A
                {x - hw, y + hh, 0.0f, c[0], c[1], c[2], c[3],
                 x - hw, y - hh, 0.0f, c[0], c[1], c[2], c[3],
                 x + hw, y - hh, 0.0f, c[0], c[1], c[2], c[3],
                 x + hw, y + hh, 0.0f, c[0], c[1], c[2], c[3]};
    }
}


Ошибку кидает следующую:
Кликните здесь для просмотра всего текста
11-12 03:19:07.172 29250-29264/com.contedevel.boardwars E/AndroidRuntime﹕ FATAL EXCEPTION: GLThread 4904
java.lang.IllegalArgumentException: Must use a native order direct Buffer
at android.opengl.GLES20.glVertexAttribPointerBounds(Native Method)
at android.opengl.GLES20.glVertexAttribPointer(GLES20.java:1921)
at com.contedevel.easygame.render.EasyRenderer.drawTriangle(EasyRenderer.java:236)
at com.contedevel.easygame.render.EasyRenderer.onDrawFrame(EasyRenderer.java:229)


Кто знает объясните, пожалуйста, в чем может быть ошибка? (Код изначально для треугольника был, но с ним та же ошибка и в том же месте).
Заранее спасибо!
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
12.11.2014, 03:36     GLES 2 ошибка при отрисовке квадрата
Посмотрите здесь:

Ошибка при запуске Android
Ошибка при сворачивании Android
Android Ошибка при вычитании
Знакомство с OPEN GLES Android
Ошибка при TabHost Android
Android Ошибка при нажатии
Ошибка при при смене активити Android
Android Ошибка при запуске VM VB
Ошибка при запуске Android
Ошибка при построение Android
Ошибка при accept() Android
Android "Ошибка при синтаксическом анализе пакета" при скачивании файла

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
contedevel
 Аватар для contedevel
57 / 55 / 8
Регистрация: 07.10.2012
Сообщений: 589
12.11.2014, 23:01  [ТС]     GLES 2 ошибка при отрисовке квадрата #2
Все ещә не могу справиться с ошибкой... Упростил уже код так
Кликните здесь для просмотра всего текста
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
package com.*.*.render;
 
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;
 
import com.*.*.utils.EasySettings;
 
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
 
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
 
public class EasyRenderer implements GLSurfaceView.Renderer {
    public static final String TAG = EasyRenderer.class.getSimpleName();
    protected EasySettings settings;
    private FloatBuffer fb;
    private float[] viewMatrix = new float[16];
    private float[] projectionMatrix = new float[16];
    private float[] modelMatrix = new float[16];
    private float[] mvpMatrix = new float[16];
    private final int strideBytes = 7 * 4;
    private final int positionOffset = 0;
    private final int positionDataSize = 3;
    private final int colorOffset = 3;
    private final int colorDataSize = 4;
    private int mvpMatrixHandle;
    private int positionHandle;
    private int colorHandle;
 
    final float[] triangle = {
            // X, Y, Z,
            // R, G, B, A
            -0.5f, -0.25f, 0.0f,
            1.0f, 0.0f, 0.0f, 1.0f,
 
            0.5f, -0.25f, 0.0f,
            0.0f, 0.0f, 1.0f, 1.0f,
 
            0.0f, 0.559016994f, 0.0f,
            0.0f, 1.0f, 0.0f, 1.0f};
 
    public EasyRenderer(EasySettings settings) {
        if(settings == null)
            throw new NullPointerException("EasySettings cannot be null!");
        this.settings = settings;
 
        fb = ByteBuffer
                .allocate(triangle.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer();
 
        fb.put(triangle).position(0);
 
    }
 
    @Override
    public void onSurfaceCreated(GL10 gl10, EGLConfig eglConfig) {
        GLES20.glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
 
        // Position the eye behind the origin.
        final float eyeX = 0.0f;
        final float eyeY = 0.0f;
        final float eyeZ = 1.5f;
 
        // We are looking toward the distance
        final float lookX = 0.0f;
        final float lookY = 0.0f;
        final float lookZ = -5.0f;
 
        // Set our up vector. This is where our head would be pointing were we holding the camera.
        final float upX = 0.0f;
        final float upY = 1.0f;
        final float upZ = 0.0f;
 
        // Set the view matrix. This matrix can be said to represent the camera position.
        // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
        // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
        Matrix.setLookAtM(viewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
 
        final String vertexShader =
                EasyShader.loadShader(EasyShader.VERTEX_SHADER, settings.getContext());
 
        final String fragmentShader =
                EasyShader.loadShader(EasyShader.FRAGMENT_SHADER, settings.getContext());
 
        // Create a program object and store the handle to it.
        int programHandle = EasyShader.compileProgram(vertexShader, fragmentShader);
 
        // Set program handles. These will later be used to pass in values to the program.
        mvpMatrixHandle = GLES20.glGetUniformLocation(programHandle, "u_MVPMatrix");
        positionHandle = GLES20.glGetAttribLocation(programHandle, "a_Position");
        colorHandle = GLES20.glGetAttribLocation(programHandle, "a_Color");
 
        // Tell OpenGL to use this program when rendering.
        GLES20.glUseProgram(programHandle);
    }
 
    @Override
    public void onSurfaceChanged(GL10 gl10, int width, int height) {
        // Set the OpenGL viewport to the same size as the surface.
        GLES20.glViewport(0, 0, width, height);
 
        // Create a new perspective projection matrix. The height will stay the same
        // while the width will vary as per aspect ratio.
        final float ratio = (float) width / height;
        final float left = -ratio;
        final float right = ratio;
        final float bottom = -1.0f;
        final float top = 1.0f;
        final float near = 1.0f;
        final float far = 10.0f;
 
        Matrix.frustumM(projectionMatrix, 0, left, right, bottom, top, near, far);
    }
 
    @Override
    public void onDrawFrame(GL10 gl10) {
        GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
 
        // Draw the triangle facing straight on.
        Matrix.setIdentityM(modelMatrix, 0);
        Matrix.rotateM(modelMatrix, 0, 0, 0.0f, 0.0f, 1.0f);
        drawTriangle(fb);
    }
 
    private void drawTriangle(final FloatBuffer fb)
    {
        // Pass in the position information
        fb.position(positionOffset);
        GLES20.glVertexAttribPointer(positionHandle, positionDataSize, GLES20.GL_FLOAT, false,
                strideBytes, fb);
 
        GLES20.glEnableVertexAttribArray(positionHandle);
 
        // Pass in the color information
        fb.position(colorOffset);
        GLES20.glVertexAttribPointer(colorHandle, colorDataSize, GLES20.GL_FLOAT, false,
                strideBytes, fb);
 
        GLES20.glEnableVertexAttribArray(colorHandle);
 
        // This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix
        // (which currently contains model * view).
        Matrix.multiplyMM(mvpMatrix, 0, viewMatrix, 0, modelMatrix, 0);
 
        // This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix
        // (which now contains model * view * projection).
        Matrix.multiplyMM(mvpMatrix, 0, projectionMatrix, 0, mvpMatrix, 0);
 
        GLES20.glUniformMatrix4fv(mvpMatrixHandle, 1, false, mvpMatrix, 0);
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
    }
}


Все та же ошибка! Я не понимаю из-за чего?! Я же указал, что нужен нативный порядок?!
EVP
319 / 241 / 43
Регистрация: 14.12.2010
Сообщений: 461
13.11.2014, 18:30     GLES 2 ошибка при отрисовке квадрата #3
Из книги OpenGL® ES 2.0 Programming Guide:
Кликните здесь для просмотра всего текста
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
//
// Book:      OpenGL(R) ES 2.0 Programming Guide
// Authors:   Aaftab Munshi, Dan Ginsburg, Dave Shreiner
// ISBN-10:   0321502795
// ISBN-13:   9780321502797
// Publisher: Addison-Wesley Professional
// URLs:      [url]http://safari.informit.com/9780321563835[/url]
//            [url]http://www.opengles-book.com[/url]
//
 
// Hello_Triangle
//
//    This is a simple example that draws a single triangle with
//    a minimal vertex/fragment shader.  The purpose of this 
//    example is to demonstrate the basic concepts of 
//    OpenGL ES 2.0 rendering.
 
package com.opengles.hellotriangle;
 
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
 
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
 
import android.content.Context;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.util.Log;
 
public class HelloTriangleRenderer implements GLSurfaceView.Renderer
{
 
    ///
    // Constructor
    //
    public HelloTriangleRenderer(Context context)
    {
        mVertices = ByteBuffer.allocateDirect(mVerticesData.length * 4)
                .order(ByteOrder.nativeOrder()).asFloatBuffer();
        mVertices.put(mVerticesData).position(0);
    }
 
    ///
    // Create a shader object, load the shader source, and
    // compile the shader.
    //
    private int LoadShader(int type, String shaderSrc)
    {
        int shader;
        int[] compiled = new int[1];
 
        // Create the shader object
        shader = GLES20.glCreateShader(type);
 
        if (shader == 0)
            return 0;
 
        // Load the shader source
        GLES20.glShaderSource(shader, shaderSrc);
 
        // Compile the shader
        GLES20.glCompileShader(shader);
 
        // Check the compile status
        GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
 
        if (compiled[0] == 0)
        {
            Log.e(TAG, GLES20.glGetShaderInfoLog(shader));
            GLES20.glDeleteShader(shader);
            return 0;
        }
        return shader;
    }
 
    ///
    // Initialize the shader and program object
    //
    public void onSurfaceCreated(GL10 glUnused, EGLConfig config)
    {
        String vShaderStr = 
                  "attribute vec4 vPosition;    \n"
                + "void main()                  \n"
                + "{                            \n"
                + "   gl_Position = vPosition;  \n"
                + "}                            \n";
 
        String fShaderStr = 
                  "precision mediump float;                   \n"
                + "void main()                                  \n"
                + "{                                            \n"
                + "  gl_FragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 );\n"
                + "}                                            \n";
 
        int vertexShader;
        int fragmentShader;
        int programObject;
        int[] linked = new int[1];
 
        // Load the vertex/fragment shaders
        vertexShader = LoadShader(GLES20.GL_VERTEX_SHADER, vShaderStr);
        fragmentShader = LoadShader(GLES20.GL_FRAGMENT_SHADER, fShaderStr);
 
        // Create the program object
        programObject = GLES20.glCreateProgram();
 
        if (programObject == 0)
            return;
 
        GLES20.glAttachShader(programObject, vertexShader);
        GLES20.glAttachShader(programObject, fragmentShader);
 
        // Bind vPosition to attribute 0
        GLES20.glBindAttribLocation(programObject, 0, "vPosition");
 
        // Link the program
        GLES20.glLinkProgram(programObject);
 
        // Check the link status
        GLES20.glGetProgramiv(programObject, GLES20.GL_LINK_STATUS, linked, 0);
 
        if (linked[0] == 0)
        {
            Log.e(TAG, "Error linking program:");
            Log.e(TAG, GLES20.glGetProgramInfoLog(programObject));
            GLES20.glDeleteProgram(programObject);
            return;
        }
 
        // Store the program object
        mProgramObject = programObject;
 
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    }
 
    // /
    // Draw a triangle using the shader pair created in onSurfaceCreated()
    //
    public void onDrawFrame(GL10 glUnused)
    {
        // Set the viewport
        GLES20.glViewport(0, 0, mWidth, mHeight);
 
        // Clear the color buffer
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
 
        // Use the program object
        GLES20.glUseProgram(mProgramObject);
 
        // Load the vertex data
        GLES20.glVertexAttribPointer(0, 3, GLES20.GL_FLOAT, false, 0, mVertices);
        GLES20.glEnableVertexAttribArray(0);
 
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
    }
 
    // /
    // Handle surface changes
    //
    public void onSurfaceChanged(GL10 glUnused, int width, int height)
    {
        mWidth = width;
        mHeight = height;
    }
 
    // Member variables
    private int mProgramObject;
    private int mWidth;
    private int mHeight;
    private FloatBuffer mVertices;
    private static String TAG = "HelloTriangleRenderer";
 
    private final float[] mVerticesData =
    { 0.0f, 0.5f, 0.0f, -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f };
 
}

Кликните здесь для просмотра всего текста
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package com.opengles.hellotriangle;
 
import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;
import android.content.pm.ConfigurationInfo;
import android.opengl.GLSurfaceView;
import android.os.Bundle;
import android.util.Log;
 
/**
 * Activity class for example program that detects OpenGL ES 2.0.
 **/
public class HelloTriangle extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) 
    {
        super.onCreate(savedInstanceState);
        mGLSurfaceView = new GLSurfaceView(this);
        if (detectOpenGLES20()) 
        {
            // Tell the surface view we want to create an OpenGL ES 2.0-compatible
            // context, and set an OpenGL ES 2.0-compatible renderer.
            mGLSurfaceView.setEGLContextClientVersion(2);
            mGLSurfaceView.setRenderer(new HelloTriangleRenderer(this));
        } 
        else
        {
            Log.e("HelloTriangle", "OpenGL ES 2.0 not supported on device.  Exiting...");
            finish();
           
        }
        setContentView(mGLSurfaceView);
    }
 
    private boolean detectOpenGLES20() 
    {
        ActivityManager am =
            (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        return (info.reqGlEsVersion >= 0x20000);
    }
 
    @Override
    protected void onResume() 
    {
        // Ideally a game should implement onResume() and onPause()
        // to take appropriate action when the activity looses focus
        super.onResume();
        mGLSurfaceView.onResume();
    }
 
    @Override
    protected void onPause() 
    {
        // Ideally a game should implement onResume() and onPause()
        // to take appropriate action when the activity looses focus
        super.onPause();
        mGLSurfaceView.onPause();
    }
 
    private GLSurfaceView mGLSurfaceView;
}
Yandex
Объявления
13.11.2014, 18:30     GLES 2 ошибка при отрисовке квадрата
Ответ Создать тему
Опции темы

Текущее время: 13:43. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru