private int createProgram(String vertexSource, String fragmentSource) { int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource); if (vertexShader == 0) { return TRIANGLE_VERTICES_DATA_POS_OFFSET; } int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource); if (pixelShader == 0) { return TRIANGLE_VERTICES_DATA_POS_OFFSET; } int program = GLES20.glCreateProgram(); checkGlError("glCreateProgram"); if (program == 0) { Log.e(TAG, "Could not create program"); } GLES20.glAttachShader(program, vertexShader); checkGlError("glAttachShader"); GLES20.glAttachShader(program, pixelShader); checkGlError("glAttachShader"); GLES20.glLinkProgram(program); int[] linkStatus = new int[FLIP_TYPE_HORIZONTAL]; GLES20.glGetProgramiv( program, GLES20.GL_LINK_STATUS, linkStatus, TRIANGLE_VERTICES_DATA_POS_OFFSET); if (linkStatus[TRIANGLE_VERTICES_DATA_POS_OFFSET] == FLIP_TYPE_HORIZONTAL) { return program; } Log.e(TAG, "Could not link program: "); Log.e(TAG, GLES20.glGetProgramInfoLog(program)); GLES20.glDeleteProgram(program); throw new IllegalStateException("Could not link program"); }
private int createProgram(final String vertexSource, final String fragmentSource) { final int vertexShader = this.loadShader(GLES20.GL_VERTEX_SHADER, vertexSource); if (vertexShader == 0) { return 0; } final int pixelShader = this.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource); if (pixelShader == 0) { return 0; } int program = GLES20.glCreateProgram(); if (program != 0) { GLES20.glAttachShader(program, vertexShader); this.checkGlError("glAttachShader"); GLES20.glAttachShader(program, pixelShader); this.checkGlError("glAttachShader"); GLES20.glLinkProgram(program); final int[] linkStatus = {0}; GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0); if (linkStatus[0] != 1) { Log.e("DistortionRenderer", "Could not link program: "); Log.e("DistortionRenderer", GLES20.glGetProgramInfoLog(program)); GLES20.glDeleteProgram(program); program = 0; } } return program; }
public circle(float r) { transMatrix = new float[16]; int sides = 24; vertexCoords = new float[sides * 3]; double angle = 2 * Math.PI / sides; for (int i = 0; i < sides; i++) { vertexCoords[3 * i] = (float) (Math.cos(i * angle) * r); vertexCoords[3 * i + 1] = (float) (Math.sin(i * angle) * r); vertexCoords[3 * i + 2] = 0f; } vertexCount = vertexCoords.length / COORDS_PER_VERTEX; vertexStride = COORDS_PER_VERTEX * 4; ByteBuffer bb = ByteBuffer.allocateDirect(vertexCoords.length * 4); bb.order(ByteOrder.nativeOrder()); vertexBuffer = bb.asFloatBuffer(); vertexBuffer.put(vertexCoords); vertexBuffer.position(0); int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = 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 }
/** * Creates a shader program by compiling the vertex and fragment shaders from a string. * * @param vertexSource * @param fragmentSource * @return */ private int createProgram(String vertexSource, String fragmentSource) { mVShaderHandle = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource); if (mVShaderHandle == 0) { return 0; } mFShaderHandle = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource); if (mFShaderHandle == 0) { return 0; } int program = GLES20.glCreateProgram(); if (program != 0) { GLES20.glAttachShader(program, mVShaderHandle); GLES20.glAttachShader(program, mFShaderHandle); GLES20.glLinkProgram(program); int[] linkStatus = new int[1]; GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0); if (linkStatus[0] != GLES20.GL_TRUE) { RajLog.e("Could not link program in " + getClass().getCanonicalName() + ": "); RajLog.e(GLES20.glGetProgramInfoLog(program)); GLES20.glDeleteProgram(program); program = 0; } } return program; }
public void onSurfaceCreated(GL10 unused, EGLConfig config) { // Set the background frame color GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); GLES20.glDisable(GLES20.GL_DITHER); GLES20.glDisable(GL10.GL_LIGHTING); GLES20.glDisable(GLES20.GL_DEPTH_TEST); GLES20.glEnable(GLES20.GL_TEXTURE_2D); GLES20.glEnable(GL10.GL_BLEND); GLES20.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA); inirBuffers(); int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = 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); // creates OpenGL program executables // get handle to the vertex shader's vPosition member maPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition"); maTexCoordsHandle = GLES20.glGetAttribLocation(mProgram, "aTexCoords"); mSampleHandle = GLES20.glGetUniformLocation(mProgram, "u_Texture"); // mSampleHandle2 = GLES20.glGetUniformLocation(mProgram, "u_Texture2"); mOpacityHandle = GLES20.glGetUniformLocation(mProgram, "u_Opacity"); }
public static int createProgram(int vertexShaderHandle, int fragmentShaderHandle) { int mProgram = GLES20.glCreateProgram(); if (mProgram != 0) { GLES20.glAttachShader(mProgram, vertexShaderHandle); GLES20.glAttachShader(mProgram, fragmentShaderHandle); GLES20.glLinkProgram(mProgram); final int[] linkStatus = new int[1]; GLES20.glGetProgramiv(mProgram, GLES20.GL_LINK_STATUS, linkStatus, 0); if (linkStatus[0] == 0) { Log.v(OpenGLUtil.class.getCanonicalName(), GLES20.glGetProgramInfoLog(mProgram)); GLES20.glDeleteProgram(mProgram); mProgram = 0; } } if (mProgram == 0) { throw new RuntimeException("Error creating program."); } return mProgram; }
/** * load, compile and link shader * * @param vss source of vertex shader * @param fss source of fragment shader * @return */ public static int loadShader(final String vss, final String fss) { if (DEBUG) Log.v(TAG, "loadShader:"); int vs = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER); GLES20.glShaderSource(vs, vss); GLES20.glCompileShader(vs); final int[] compiled = new int[1]; GLES20.glGetShaderiv(vs, GLES20.GL_COMPILE_STATUS, compiled, 0); if (compiled[0] == 0) { if (DEBUG) Log.e(TAG, "Failed to compile vertex shader:" + GLES20.glGetShaderInfoLog(vs)); GLES20.glDeleteShader(vs); vs = 0; } int fs = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER); GLES20.glShaderSource(fs, fss); GLES20.glCompileShader(fs); GLES20.glGetShaderiv(fs, GLES20.GL_COMPILE_STATUS, compiled, 0); if (compiled[0] == 0) { if (DEBUG) Log.w(TAG, "Failed to compile fragment shader:" + GLES20.glGetShaderInfoLog(fs)); GLES20.glDeleteShader(fs); fs = 0; } final int program = GLES20.glCreateProgram(); GLES20.glAttachShader(program, vs); GLES20.glAttachShader(program, fs); GLES20.glLinkProgram(program); return program; }
public axizLines(float size) { triangleCoords = new float[] { 0f, 0f, 0f, size, 0f, 0f, 0f, 0f, 0f, 0f, 0, size, 0f, 0f, 0f, 0f, size, 0f, // 0f,0f,0f, // size,size,size }; vertexCount = triangleCoords.length / COORDS_PER_VERTEX; vertexStride = COORDS_PER_VERTEX * 4; // 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 = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = 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 }
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); int vertexShader = MyGLRenderer.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = MyGLRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); // create empty OpenGL ES Program mProgram = GLES20.glCreateProgram(); // add the vertex shader to program GLES20.glAttachShader(mProgram, vertexShader); // add the fragment shader to program GLES20.glAttachShader(mProgram, fragmentShader); // creates OpenGL ES program executables GLES20.glLinkProgram(mProgram); }
@Override public void onSurfaceCreated(GL10 glUnused, EGLConfig config) { GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER); GLES20.glShaderSource(vertexShaderHandle, loadShader(R.raw.vertex_shader)); GLES20.glCompileShader(vertexShaderHandle); int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER); GLES20.glShaderSource(fragmentShaderHandle, loadShader(R.raw.fragment_shader)); GLES20.glCompileShader(fragmentShaderHandle); int programHandle = GLES20.glCreateProgram(); GLES20.glAttachShader(programHandle, vertexShaderHandle); GLES20.glAttachShader(programHandle, fragmentShaderHandle); GLES20.glLinkProgram(programHandle); GLES20.glUseProgram(programHandle); Object3D.init(programHandle); mLightPosHandle = GLES20.glGetUniformLocation(programHandle, "uLightPos"); GLES20.glEnable(GLES20.GL_DEPTH_TEST); GLES20.glEnable(GLES20.GL_CULL_FACE); GLES20.glCullFace(GLES20.GL_BACK); // GLES20.glEnable(GLES20.GL_BLEND); // GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA); mPrism.init(); mCylinder.init(); mSphere.init(); }
public static int createProgram(String vertexShaderSource, String fragmentShaderSource) { if (TextUtils.isEmpty(vertexShaderSource) || TextUtils.isEmpty(fragmentShaderSource)) { throw new IllegalArgumentException("传入的顶点着色器源码为空或者传入的片元着色器源码为空"); } int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderSource); if (vertexShader == 0) { return 0; } int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderSource); if (fragmentShader == 0) { return 0; } int program = GLES20.glCreateProgram(); if (program != 0) { GLES20.glAttachShader(program, vertexShader); checkGLError("AttachVertexShader"); GLES20.glAttachShader(program, vertexShader); checkGLError("AttachFragmentShader"); GLES20.glLinkProgram(program); int[] result = new int[1]; GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, result, 0); if (result[0] == 0) { Log.w(TAG, "加载程序失败"); Log.w(TAG, GLES20.glGetProgramInfoLog(program)); GLES20.glDeleteProgram(program); program = 0; } } return program; }
/** * Creates a new program from the supplied vertex and fragment shaders. * * @return A handle to the program, or 0 on failure. */ public static int createProgram(String vertexSource, String fragmentSource) { int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource); if (vertexShader == 0) { return 0; } int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource); if (pixelShader == 0) { return 0; } int program = GLES20.glCreateProgram(); checkGlError("glCreateProgram"); if (program == 0) { Log.e(TAG, "Could not create program"); } GLES20.glAttachShader(program, vertexShader); checkGlError("glAttachShader"); GLES20.glAttachShader(program, pixelShader); checkGlError("glAttachShader"); GLES20.glLinkProgram(program); int[] linkStatus = new int[1]; GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0); if (linkStatus[0] != GLES20.GL_TRUE) { Log.e(TAG, "Could not link program: "); Log.e(TAG, GLES20.glGetProgramInfoLog(program)); GLES20.glDeleteProgram(program); program = 0; } return program; }
@Override public void onSurfaceCreated(GL10 unused, EGLConfig config) { int program = GLES20.glCreateProgram(); addShaderTo(GLES20.GL_VERTEX_SHADER, VERTEX_SHADER_STRING, program); addShaderTo(GLES20.GL_FRAGMENT_SHADER, FRAGMENT_SHADER_STRING, program); GLES20.glLinkProgram(program); int[] result = new int[] {GLES20.GL_FALSE}; result[0] = GLES20.GL_FALSE; GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, result, 0); abortUnless(result[0] == GLES20.GL_TRUE, GLES20.glGetProgramInfoLog(program)); GLES20.glUseProgram(program); GLES20.glUniform1i(GLES20.glGetUniformLocation(program, "y_tex"), 0); GLES20.glUniform1i(GLES20.glGetUniformLocation(program, "u_tex"), 1); GLES20.glUniform1i(GLES20.glGetUniformLocation(program, "v_tex"), 2); // Actually set in drawRectangle(), but queried only once here. posLocation = GLES20.glGetAttribLocation(program, "in_pos"); int tcLocation = GLES20.glGetAttribLocation(program, "in_tc"); GLES20.glEnableVertexAttribArray(tcLocation); GLES20.glVertexAttribPointer(tcLocation, 2, GLES20.GL_FLOAT, false, 0, textureCoords); GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); checkNoGLES2Error(); }
/** * Creates the buffers we use to store information about the 3D world. OpenGL doesn't use Java * arrays, but rather needs data in a format it can understand. Hence we use ByteBuffers. * * @param config The EGL configuration used when creating the surface. */ @Override public void onSurfaceCreated(EGLConfig config) { Log.i(TAG, "In onSurfaceCreated"); GLES20.glClearColor(0.1f, 0.1f, 0.1f, 0.5f); // Dark background so camera stuff show up. ByteBuffer bb = ByteBuffer.allocateDirect(squareVertices.length * 4); bb.order(ByteOrder.nativeOrder()); vertexBuffer = bb.asFloatBuffer(); vertexBuffer.put(squareVertices); vertexBuffer.position(0); ByteBuffer dlb = ByteBuffer.allocateDirect(drawOrder.length * 2); dlb.order(ByteOrder.nativeOrder()); drawListBuffer = dlb.asShortBuffer(); drawListBuffer.put(drawOrder); drawListBuffer.position(0); ByteBuffer bb2 = ByteBuffer.allocateDirect(textureVertices.length * 4); bb2.order(ByteOrder.nativeOrder()); textureVerticesBuffer = bb2.asFloatBuffer(); textureVerticesBuffer.put(textureVertices); textureVerticesBuffer.position(0); int vertexShader = loadGLShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = loadGLShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); mProgram = GLES20.glCreateProgram(); // create empty OpenGL ES 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 a texture and start mirroring the camera on the texture: texture = createTexture(); startCamera(texture); }
public static int LoadProgram(String strVSource, String strFSource) { Log.d("Utils", "LoadProgram"); int iVShader; int iFShader; int iProgId; int[] link = new int[1]; iVShader = LoadShader(strVSource, GLES20.GL_VERTEX_SHADER); if (iVShader == 0) { Log.d("Load Program", "Vertex Shader Failed"); return 0; } iFShader = LoadShader(strFSource, GLES20.GL_FRAGMENT_SHADER); if (iFShader == 0) { Log.d("Load Program", "Fragment Shader Failed"); return 0; } iProgId = GLES20.glCreateProgram(); GLES20.glAttachShader(iProgId, iVShader); GLES20.glAttachShader(iProgId, iFShader); GLES20.glLinkProgram(iProgId); GLES20.glGetProgramiv(iProgId, GLES20.GL_LINK_STATUS, link, 0); if (link[0] <= 0) { Log.d("Load Program", "Linking Failed"); return 0; } GLES20.glDeleteShader(iVShader); GLES20.glDeleteShader(iFShader); return iProgId; }
public Square() { // initialize vertex byte buffer for shape coordinates ByteBuffer bb = ByteBuffer.allocateDirect( // (# of coordinate values * 4 bytes per float) squareCoords.length * 4); bb.order(ByteOrder.nativeOrder()); vertexBuffer = bb.asFloatBuffer(); vertexBuffer.put(squareCoords); vertexBuffer.position(0); // initialize byte buffer for the draw list ByteBuffer dlb = ByteBuffer.allocateDirect( // (# of coordinate values * 2 bytes per short) drawOrder.length * 2); dlb.order(ByteOrder.nativeOrder()); drawListBuffer = dlb.asShortBuffer(); drawListBuffer.put(drawOrder); drawListBuffer.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 }
public void init(int... shader) { programID = GLES20.glCreateProgram(); for (int i : shader) { GLES20.glAttachShader(programID, i); GLES20.glDeleteShader(i); } GLES20.glLinkProgram(programID); }
/* * In this class many game tests can be run. Simply choose the class of test to run * and instantiate it. Just instantiate a different class to run its test. */ public Game(Context c) // test. { mProgram = GLES20.glCreateProgram(); input = Input.getInstance(); Transform.setCamera( new Camera( new Vector3f(0.0f, 0.0f, 3.0f), new Vector3f(0.0f, 0.0f, -1.0f), new Vector3f(0.0f, 1.0f, 0.f))); test = new GameTest3(mProgram, c); }
public Scene(PointsRenderer pointsRenderer, GAlg galg) { this.pointsRenderer = pointsRenderer; this.rubyAlgorithms = new RubyAlgorithms(); this.galg = galg; newVertexBufferToDraw(); // prepare shaders and OpenGL program int vertexShader = PointsRenderer.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = PointsRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); mProgram = GLES20.glCreateProgram(); // create empty OpenGL Program mLinesProgram = 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 // Hmm, let'suse the same shaders for this. TODO: Really? // TODO: This is weird... :-( GLES20.glAttachShader(mLinesProgram, vertexShader); // add the vertex shader to program GLES20.glAttachShader(mLinesProgram, fragmentShader); // add the fragment shader to program GLES20.glLinkProgram(mLinesProgram); // create OpenGL program executables }
public static int getProgram(String vsSrc, String fsSrc) { // vertexShaderのコンパイル int vs = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER); GLES20.glShaderSource(vs, vsSrc); GLES20.glCompileShader(vs); // コンパイルチェック final int[] vsCompileStatus = new int[1]; GLES20.glGetShaderiv(vs, GLES20.GL_COMPILE_STATUS, vsCompileStatus, 0); if (vsCompileStatus[0] == 0) { // コンパイル失敗 GLES20.glDeleteShader(vs); vs = 0; // ログにエラーを出力 Log.d("debug", "VERTEXSHADER_COMPILE_ERROR"); } // fragmentShaderのコンパイル int fs = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER); GLES20.glShaderSource(fs, fsSrc); GLES20.glCompileShader(fs); // コンパイルチェック final int[] fsCompileStatus = new int[1]; GLES20.glGetShaderiv(fs, GLES20.GL_COMPILE_STATUS, fsCompileStatus, 0); if (fsCompileStatus[0] == 0) { // コンパイル失敗 GLES20.glDeleteShader(fs); fs = 0; Log.d("debug", "FRAGMENTSHADER_COMPILE_ERROR"); } // shaderをリンクしてProgramを作る int shaderProgram; shaderProgram = GLES20.glCreateProgram(); GLES20.glAttachShader(shaderProgram, vs); GLES20.glAttachShader(shaderProgram, fs); GLES20.glLinkProgram(shaderProgram); // リンク結果をチェック final int[] linkStatus = new int[1]; GLES20.glGetProgramiv(shaderProgram, GLES20.GL_LINK_STATUS, linkStatus, 0); if (linkStatus[0] == 0) { // リンク失敗 GLES20.glDeleteProgram(shaderProgram); shaderProgram = 0; Log.d("debug", "LINK_ERROR"); } return shaderProgram; }
public Triangle(PointF center, boolean reflec) { this.reflec = reflec; // this.bmp = bmp; this.center = center; computePoints(center, /*bmp.getWidth() * 0.8888f fix it later */ 0.2f); Lados = new ArrayList(); // In counterclockwise order v1,v2; v3,v2; v3,v1 Lados.add( new Recta(triangleCoords[0], triangleCoords[1], triangleCoords[2], triangleCoords[3])); Lados.add( new Recta(triangleCoords[4], triangleCoords[5], triangleCoords[2], triangleCoords[3])); Lados.add( new Recta(triangleCoords[4], triangleCoords[5], triangleCoords[0], triangleCoords[1])); // x=center.x - bmp.getWidth()/ 2; // y=center.y + peq + bmp.getHeight()*0.125f; // 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); // To render vertices int vertexShader = MyGLRenderer.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); // To render faces int fragmentShader = MyGLRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); // create empty OpenGL ES Program mProgram = GLES20.glCreateProgram(); // add the vertex shader to program GLES20.glAttachShader(mProgram, vertexShader); // add the fragment shader to program GLES20.glAttachShader(mProgram, fragmentShader); // creates OpenGL ES program executables GLES20.glLinkProgram(mProgram); }
public Cube(Bitmap b) { // initialize buffer for vertex coordinates ByteBuffer vpb = ByteBuffer.allocateDirect( // (# of coordinate values * 4 bytes per float) faceCoords.length * 4); vpb.order(ByteOrder.nativeOrder()); vertexBuffer = vpb.asFloatBuffer(); vertexBuffer.put(faceCoords); vertexBuffer.position(0); // initialize buffer for vertex normals ByteBuffer vnb = ByteBuffer.allocateDirect( // (# of coordinate values * 4 bytes per float) normals.length * 4); vnb.order(ByteOrder.nativeOrder()); normalBuffer = vnb.asFloatBuffer(); normalBuffer.put(normals); normalBuffer.position(0); // initialize buffer for UV Coordinates ByteBuffer uvb = ByteBuffer.allocateDirect( // (# of coordinate values * 4 bytes per float) uvs.length * 4); uvb.order(ByteOrder.nativeOrder()); uvBuffer = uvb.asFloatBuffer(); uvBuffer.put(uvs); uvBuffer.position(0); // initialize byte buffer for the draw list ByteBuffer dlb = ByteBuffer.allocateDirect( // (# of coordinate values * 2 bytes per short) drawOrder.length * 2); dlb.order(ByteOrder.nativeOrder()); drawListBuffer = dlb.asShortBuffer(); drawListBuffer.put(drawOrder); drawListBuffer.position(0); int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); shaderProgram = GLES20.glCreateProgram(); GLES20.glAttachShader(shaderProgram, vertexShader); GLES20.glAttachShader(shaderProgram, fragmentShader); GLES20.glLinkProgram(shaderProgram); loadTexture(b); }
public MarkerTile(float mx, float my, float sx, float sy, int texture) { midx = mx; midy = my; sizx = sx; sizy = sy; midOx = mx; midOy = my; sizOx = sx; sizOy = sy; midTx = mx; midTy = my; sizTx = sx; sizTy = sy; textureRef = texture; int vertexInfoShader = XQGLRenderer.loadShader(GLES20.GL_VERTEX_SHADER, vertexInfoTileShaderCode); int fragmentInfoShader = XQGLRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentInfoTileShaderCode); mProgram = GLES20.glCreateProgram(); // add the vertex shader to program GLES20.glAttachShader(mProgram, vertexInfoShader); // add the fragment shader to program GLES20.glAttachShader(mProgram, fragmentInfoShader); // creates OpenGL ES program executables GLES20.glLinkProgram(mProgram); ByteBuffer byteBuffer = ByteBuffer.allocateDirect(tileCoords.length * 4); byteBuffer.order(ByteOrder.nativeOrder()); vertexBuffer = byteBuffer.asFloatBuffer(); vertexBuffer.put(tileCoords); vertexBuffer.position(0); byteBuffer = ByteBuffer.allocateDirect(drawOrder.length * 4); byteBuffer.order(ByteOrder.nativeOrder()); indexBuffer = byteBuffer.asShortBuffer(); indexBuffer.put(drawOrder); indexBuffer.position(0); byteBuffer = ByteBuffer.allocateDirect(TextureCoords.length * 4); byteBuffer.order(ByteOrder.nativeOrder()); textureBuffer = byteBuffer.asFloatBuffer(); textureBuffer.put(TextureCoords); textureBuffer.position(0); }
/** * Links a vertex shader and a fragment shader together into an OpenGL program. Returns the OpenGL * program object ID, or 0 if linking failed. */ public static int linkProgram(int vertexShaderId, int fragmentShaderId) { // Create a new program object. final int programObjectId = GLES20.glCreateProgram(); if (programObjectId == 0) { if (LoggerConfig.ON) { Log.w(TAG, "Could not create new program"); } return 0; } // Attach the vertex shader to the program. glAttachShader(programObjectId, vertexShaderId); // Attach the fragment shader to the program. glAttachShader(programObjectId, fragmentShaderId); // Link the two shaders together into a program. glLinkProgram(programObjectId); // Get the link status. final int[] linkStatus = new int[1]; glGetProgramiv(programObjectId, GLES20.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" + GLES20.glGetProgramInfoLog(programObjectId)); } // Verify the link status. if (linkStatus[0] == 0) { // If it failed, delete the program object. GLES20.glDeleteProgram(programObjectId); if (LoggerConfig.ON) { Log.w(TAG, "Linking of program failed."); } return 0; } // Return the program object ID. return programObjectId; }
void build() { vertexCount = vertexCoords.length / COORDS_PER_VERTEX; vertexStride = COORDS_PER_VERTEX * 4; ByteBuffer bb = ByteBuffer.allocateDirect(vertexCoords.length * 4); bb.order(ByteOrder.nativeOrder()); vertexBuffer = bb.asFloatBuffer(); vertexBuffer.put(vertexCoords); vertexBuffer.position(0); int vertexShader = glObjects.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = glObjects.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 }
public static int linkProgram(int vsh, int fsh) { if (vsh == 0 || fsh == 0) { Log.e(TAG, "Invalid vertex shader and fragment shader"); return 0; } int prog = GLES20.glCreateProgram(); GLES20.glAttachShader(prog, vsh); GLES20.glAttachShader(prog, fsh); GLES20.glLinkProgram(prog); int[] status = new int[1]; GLES20.glGetProgramiv(prog, GLES20.GL_LINK_STATUS, status, 0); Log.e(TAG, "link program " + GLES20.glGetProgramInfoLog(prog)); if (status[0] == 0) { GLES20.glDeleteProgram(prog); return 0; } return prog; }
public static int createProgram(String vertexSource, String fragmentSource) { int vs = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource); int fs = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource); int program = GLES20.glCreateProgram(); GLES20.glAttachShader(program, vs); GLES20.glAttachShader(program, fs); GLES20.glLinkProgram(program); // int[] linkStatus = new int[1]; GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0); if (linkStatus[0] != GLES20.GL_TRUE) { Log.e(TAG, "Could not link program:"); Log.e(TAG, GLES20.glGetProgramInfoLog(program)); GLES20.glDeleteProgram(program); program = 0; } // return program; }
public CloudElem(Renderer3D s3D, float[] v, float[] oscDir, float[] oscPhase, float[] color) { scene = s3D; int vertexShader; if (oscDir.length == 0) { vertexShader = GLESUtils.loadShader(GLES20.GL_VERTEX_SHADER, nonMovingVerts()); } if (color.length == 4) { c = color; } else { c = new float[4]; c[0] = 0.95f; c[1] = 0.95f; c[2] = 0.95f; c[3] = 0.8f; } vertexShader = GLESUtils.loadShader(GLES20.GL_VERTEX_SHADER, vertexShader()); int fragmentShader = GLESUtils.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader()); shaderProgram = GLES20.glCreateProgram(); GLES20.glAttachShader(shaderProgram, vertexShader); GLES20.glAttachShader(shaderProgram, fragmentShader); GLES20.glLinkProgram(shaderProgram); short[] order = new short[NumVerts]; oBufferLength = NumVerts; for (int i = 0; i < NumVerts; i++) { order[i] = (short) i; } posBuffer = GLESUtils.packBuffer(NumVerts * CpV, v); if (oscDir.length > 0) { normalBuffer = GLESUtils.packBuffer(NumVerts * CpV, oscDir); phaseBuffer = GLESUtils.packBuffer(NumVerts, oscPhase); } else { float[] nullBuf = new float[NumVerts * CpV]; float[] nulleBuf = new float[NumVerts]; normalBuffer = GLESUtils.packBuffer(NumVerts * CpV, nullBuf); phaseBuffer = GLESUtils.packBuffer(NumVerts, nulleBuf); } orderBuffer = GLESUtils.packBuffer(NumVerts, order); }
public void onSurfaceCreated(GL10 unused, javax.microedition.khronos.egl.EGLConfig config) { Log.i("MyGLRenderer", "MyGLRenderer : onSurfaceCreated() - Entered onSurfaceCreated"); // Set the background frame color GLES20.glClearColor(1.0f, 0.6f, 0.0f, 1.0f); int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); mProgram = GLES20.glCreateProgram(); // create empty OpenGL ES Program GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader to program GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program GLES20.glLinkProgram(mProgram); // creates OpenGL ES program executables // initialize a triangle Log.i("MyGLRenderer", "MyGLRenderer : onSurfaceCreated() - Creating new triangle object"); mTriangle = new Triangle(mProgram); Log.i("MyGLRenderer", "MyGLRenderer : onSurfaceCreated() - New Triangle object created"); }
public Triangle() { // inicializando o vetor de bytes para a forma que sera desenha // tamanho do vetor de coordenadas * 4 butes para cada float ByteBuffer bbuffer = ByteBuffer.allocateDirect(formCoordenates.length * 4); // Hardware ByteOrder bbuffer.order(ByteOrder.nativeOrder()); this.vertexBuffer = bbuffer.asFloatBuffer(); this.vertexBuffer.put(formCoordenates); // definindo o buffer para posicao zero para ser lido a primeira coordenada this.vertexBuffer.position(0); int verTexShader = GLRenderImpl.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode); int fragmentShader = GLRenderImpl.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode); // criando um OpenGL ES program vazio compiledShader = GLES20.glCreateProgram(); GLES20.glAttachShader(compiledShader, verTexShader); GLES20.glAttachShader(compiledShader, fragmentShader); // criando um OpenGL ES program executavel GLES20.glLinkProgram(compiledShader); }