以砖块纹理为例---创建简单工程过程

我就是我 2022-08-07 17:41 176阅读 0赞

案例效果图：

![20150421194435024][]

第一步：创建一个普通工程

第二步：右键工程->Android Tools->add native support；之后出现jni文件夹。效果如下图：

![20150421194046562][]

第三步：修改Android.mk文件：

LOCAL_PATH := $(call my-dir)
    
    include $(CLEAR_VARS)
    
    LOCAL_MODULE    := AA
    LOCAL_CFLAGS    :=-Werror
    LOCAL_SRC_FILES := AA.cpp
    LOCAL_LDLIBS    :=-llog -lGLESv2
    include $(BUILD_SHARED_LIBRARY)

第四步：修改Application.mk文件：

APP_ABI := all

第五步：AA.cpp文件内容

#include <jni.h>
    #include <android/log.h>
    
    #include <GLES2/gl2.h>
    #include <GLES2/gl2ext.h>
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    #define  LOG_TAG    "libgl2jni"
    #define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
    #define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
    
    static void printGLString(const char *name, GLenum s) {
    	const char *v = (const char *) glGetString(s);
    	LOGI("GL %s=%s\n", name, v);
    }
    
    static void checkGlError(const char* op) {
    	for (GLint error = glGetError(); error; error = glGetError()) {
    		LOGI("after %s() glError (0x%x)\n", op, error);
    	}
    }
    
    static const char gVertexShader[] = "attribute vec4 vPosition;\n"
    		"varying vec2 MCposition;\n"
    		"void main() {\n"
    		"  MCposition  = vPosition.xy;\n"
    		"  gl_Position = vPosition;\n"
    		"}\n";
    
    static const char gFragmentShader[] = "precision mediump float;\n"
    		"varying vec2 MCposition;\n"
    		"void main() {\n"
    		" vec3 BrickColor=vec3(0.7,0.3,0.2); \n"
    		" vec3 MortarColor=vec3(0.85,0.86,0.84);\n"
    		" vec2  BrickSize=vec2(0.1,0.05638);\n"
    		" vec2  BrickPct=vec2(0.9,0.85);\n"
    		" vec3 color;\n"
    		" vec2 position;\n"
    		" vec2 useBrick;\n"
    		" position=MCposition/BrickSize;\n"
    		" if(fract(position.y*0.5)>0.5) position.x+=0.5;\n"
    		" position=fract(position);\n"
    		" useBrick=step(position,BrickPct);\n"
    		" color=mix(MortarColor,BrickColor,useBrick.x*useBrick.y);\n"
    		"  gl_FragColor = vec4(color, 1.0);\n"
    		"}\n";
    
    GLuint loadShader(GLenum shaderType, const char* pSource) {
        GLuint shader = glCreateShader(shaderType);
        if (shader) {
            glShaderSource(shader, 1, &pSource, NULL);
            glCompileShader(shader);
            GLint compiled = 0;
            glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
            if (!compiled) {
                GLint infoLen = 0;
                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
                if (infoLen) {
                    char* buf = (char*) malloc(infoLen);
                    if (buf) {
                        glGetShaderInfoLog(shader, infoLen, NULL, buf);
                        LOGE("Could not compile shader %d:\n%s\n%s\n",
                                shaderType, buf,pSource);
                        free(buf);
                    }
                    glDeleteShader(shader);
                    shader = 0;
                }
            }
        }
        return shader;
    }
    
    GLuint createProgram(const char* pVertexSource, const char* pFragmentSource) {
        GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
        if (!vertexShader) {
            return 0;
        }
    
        GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
        if (!pixelShader) {
            return 0;
        }
    
        GLuint program = glCreateProgram();
        if (program) {
            glAttachShader(program, vertexShader);
            checkGlError("glAttachShader");
            glAttachShader(program, pixelShader);
            checkGlError("glAttachShader");
            glLinkProgram(program);
            GLint linkStatus = GL_FALSE;
            glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
            if (linkStatus != GL_TRUE) {
                GLint bufLength = 0;
                glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
                if (bufLength) {
                    char* buf = (char*) malloc(bufLength);
                    if (buf) {
                        glGetProgramInfoLog(program, bufLength, NULL, buf);
                        LOGE("Could not link program:\n%s\n", buf);
                        free(buf);
                    }
                }
                glDeleteProgram(program);
                program = 0;
            }
        }
        return program;
    }
    
    GLuint gProgram;
    GLuint gvPositionHandle;
    
    bool setupGraphics(int w, int h) {
        printGLString("Version", GL_VERSION);
        printGLString("Vendor", GL_VENDOR);
        printGLString("Renderer", GL_RENDERER);
        printGLString("Extensions", GL_EXTENSIONS);
    
        LOGI("setupGraphics(%d, %d)", w, h);
        gProgram = createProgram(gVertexShader, gFragmentShader);
        if (!gProgram) {
            LOGE("Could not create program.");
            return false;
        }
        gvPositionHandle = glGetAttribLocation(gProgram, "vPosition");
        checkGlError("glGetAttribLocation");
        LOGI("glGetAttribLocation(\"vPosition\") = %d\n",
                gvPositionHandle);
    
        glViewport(0, 0, w, h);
        checkGlError("glViewport");
        return true;
    }
    
    const GLfloat gTriangleVertices[] = {
    		-0.5f, 0.5f,
    		-0.5f, -0.5f,
            0.5f, -0.5f ,
            -0.5f, 0.5f,
            0.5f, -0.5f ,
            0.5f, 0.5f
    };
    
    
    void renderFrame() {
        static float grey;
        grey = 0.0f;
        if (grey > 1.0f) {
            grey = 0.0f;
        }
        glClearColor(grey, grey, grey, 1.0f);
        checkGlError("glClearColor");
        glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
        checkGlError("glClear");
    
        glUseProgram(gProgram);
        checkGlError("glUseProgram");
    
        glVertexAttribPointer(gvPositionHandle, 2, GL_FLOAT, GL_FALSE, 0, gTriangleVertices);
        checkGlError("glVertexAttribPointer");
        glEnableVertexAttribArray(gvPositionHandle);
        checkGlError("glEnableVertexAttribArray");
        glDrawArrays(GL_TRIANGLES, 0, 6);
        checkGlError("glDrawArrays");
    }
    
    extern "C"{
        JNIEXPORT void JNICALL Java_com_example_aa_GL2JNILib_init(JNIEnv* env,jobject obj,jint width,jint height);
        JNIEXPORT void JNICALL Java_com_example_aa_GL2JNILib_step(JNIEnv* env,jobject obj);
    }
    
    JNIEXPORT void JNICALL Java_com_example_aa_GL2JNILib_init(JNIEnv* env,jobject obj,jint width,jint height){
    	setupGraphics(width,height);
    }
    
    JNIEXPORT void JNICALL Java_com_example_aa_GL2JNILib_step(JNIEnv* env,jobject obj){
    	renderFrame();
    }

第六步：ndk的加载

package com.example.aa;
    
    public class GL2JNILib {
    
    	static{
    		System.loadLibrary("AA");
    	}
    	public static native void init(int width,int height);
    	public static native void step();
    }

package com.example.aa;
    
    import javax.microedition.khronos.egl.EGL10;
    import javax.microedition.khronos.egl.EGLConfig;
    import javax.microedition.khronos.egl.EGLContext;
    import javax.microedition.khronos.egl.EGLDisplay;
    import javax.microedition.khronos.opengles.GL10;
    
    import android.content.Context;
    import android.graphics.PixelFormat;
    import android.opengl.GLSurfaceView;
    import android.util.Log;
    
    public class GL2JNIView extends GLSurfaceView {
    
    	private static String TAG = "GL2JNIView";
    	private static final boolean DEBUG = false;
    
    	public GL2JNIView(Context context) {
    		super(context);
    		init(false, 0, 0);
    		// TODO Auto-generated constructor stub
    	}
    
    	private void init(boolean translucent, int depth, int stencil) {
    		if (translucent) {
    			this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
    		}
    		setEGLContextFactory(new ContextFactory());
    
    		setEGLConfigChooser(translucent ? new ConfigChooser(8, 8, 8, 8, depth, stencil) : new ConfigChooser(5, 6, 5, 0, depth, stencil));
    
    		setRenderer(new Renderer());
    	}
    
    	private static class Renderer implements GLSurfaceView.Renderer {
    		public void onDrawFrame(GL10 gl) {
    			GL2JNILib.step();
    		}
    
    		public void onSurfaceChanged(GL10 gl, int width, int height) {
    			GL2JNILib.init(width, height);
    		}
    
    		public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    			// Do nothing.
    		}
    	}
    
    	private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
    		private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
    
    		public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
    			Log.w(TAG, "creating OpenGL ES 2.0 context");
    			checkEglError("Before eglCreateContext", egl);
    			int[] attrib_list = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
    			EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
    			checkEglError("After eglCreateContext", egl);
    			return context;
    		}
    
    		public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
    			egl.eglDestroyContext(display, context);
    		}
    	}
    
    	private static void checkEglError(String prompt, EGL10 egl) {
    		int error;
    		while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
    			Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
    		}
    	}
    
    	private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {
    
    		public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
    			mRedSize = r;
    			mGreenSize = g;
    			mBlueSize = b;
    			mAlphaSize = a;
    			mDepthSize = depth;
    			mStencilSize = stencil;
    		}
    
    		/*
    		 * This EGL config specification is used to specify 2.0 rendering. We
    		 * use a minimum size of 4 bits for red/green/blue, but will perform
    		 * actual matching in chooseConfig() below.
    		 */
    		private static int EGL_OPENGL_ES2_BIT = 4;
    		private static int[] s_configAttribs2 = { EGL10.EGL_RED_SIZE, 4, EGL10.EGL_GREEN_SIZE, 4, EGL10.EGL_BLUE_SIZE, 4, EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL10.EGL_NONE };
    
    		public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
    
    			/*
    			 * Get the number of minimally matching EGL configurations
    			 */
    			int[] num_config = new int[1];
    			egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);
    
    			int numConfigs = num_config[0];
    
    			if (numConfigs <= 0) {
    				throw new IllegalArgumentException("No configs match configSpec");
    			}
    
    			/*
    			 * Allocate then read the array of minimally matching EGL configs
    			 */
    			EGLConfig[] configs = new EGLConfig[numConfigs];
    			egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);
    
    			if (DEBUG) {
    				printConfigs(egl, display, configs);
    			}
    			/*
    			 * Now return the "best" one
    			 */
    			return chooseConfig(egl, display, configs);
    		}
    
    		public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display, EGLConfig[] configs) {
    			for (EGLConfig config : configs) {
    				int d = findConfigAttrib(egl, display, config, EGL10.EGL_DEPTH_SIZE, 0);
    				int s = findConfigAttrib(egl, display, config, EGL10.EGL_STENCIL_SIZE, 0);
    
    				// We need at least mDepthSize and mStencilSize bits
    				if (d < mDepthSize || s < mStencilSize)
    					continue;
    
    				// We want an *exact* match for red/green/blue/alpha
    				int r = findConfigAttrib(egl, display, config, EGL10.EGL_RED_SIZE, 0);
    				int g = findConfigAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);
    				int b = findConfigAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);
    				int a = findConfigAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);
    
    				if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
    					return config;
    			}
    			return null;
    		}
    
    		private int findConfigAttrib(EGL10 egl, EGLDisplay display, EGLConfig config, int attribute, int defaultValue) {
    
    			if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
    				return mValue[0];
    			}
    			return defaultValue;
    		}
    
    		private void printConfigs(EGL10 egl, EGLDisplay display, EGLConfig[] configs) {
    			int numConfigs = configs.length;
    			Log.w(TAG, String.format("%d configurations", numConfigs));
    			for (int i = 0; i < numConfigs; i++) {
    				Log.w(TAG, String.format("Configuration %d:\n", i));
    				printConfig(egl, display, configs[i]);
    			}
    		}
    
    		private void printConfig(EGL10 egl, EGLDisplay display, EGLConfig config) {
    			int[] attributes = { EGL10.EGL_BUFFER_SIZE, EGL10.EGL_ALPHA_SIZE, EGL10.EGL_BLUE_SIZE, EGL10.EGL_GREEN_SIZE, EGL10.EGL_RED_SIZE, EGL10.EGL_DEPTH_SIZE, EGL10.EGL_STENCIL_SIZE, EGL10.EGL_CONFIG_CAVEAT, EGL10.EGL_CONFIG_ID, EGL10.EGL_LEVEL, EGL10.EGL_MAX_PBUFFER_HEIGHT, EGL10.EGL_MAX_PBUFFER_PIXELS, EGL10.EGL_MAX_PBUFFER_WIDTH, EGL10.EGL_NATIVE_RENDERABLE, EGL10.EGL_NATIVE_VISUAL_ID, EGL10.EGL_NATIVE_VISUAL_TYPE, 0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
    					EGL10.EGL_SAMPLES, EGL10.EGL_SAMPLE_BUFFERS, EGL10.EGL_SURFACE_TYPE, EGL10.EGL_TRANSPARENT_TYPE, EGL10.EGL_TRANSPARENT_RED_VALUE, EGL10.EGL_TRANSPARENT_GREEN_VALUE, EGL10.EGL_TRANSPARENT_BLUE_VALUE, 0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
    					0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
    					0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
    					0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
    					EGL10.EGL_LUMINANCE_SIZE, EGL10.EGL_ALPHA_MASK_SIZE, EGL10.EGL_COLOR_BUFFER_TYPE, EGL10.EGL_RENDERABLE_TYPE, 0x3042 // EGL10.EGL_CONFORMANT
    			};
    			String[] names = { "EGL_BUFFER_SIZE", "EGL_ALPHA_SIZE", "EGL_BLUE_SIZE", "EGL_GREEN_SIZE", "EGL_RED_SIZE", "EGL_DEPTH_SIZE", "EGL_STENCIL_SIZE", "EGL_CONFIG_CAVEAT", "EGL_CONFIG_ID", "EGL_LEVEL", "EGL_MAX_PBUFFER_HEIGHT", "EGL_MAX_PBUFFER_PIXELS", "EGL_MAX_PBUFFER_WIDTH", "EGL_NATIVE_RENDERABLE", "EGL_NATIVE_VISUAL_ID", "EGL_NATIVE_VISUAL_TYPE", "EGL_PRESERVED_RESOURCES", "EGL_SAMPLES", "EGL_SAMPLE_BUFFERS", "EGL_SURFACE_TYPE", "EGL_TRANSPARENT_TYPE", "EGL_TRANSPARENT_RED_VALUE", "EGL_TRANSPARENT_GREEN_VALUE", "EGL_TRANSPARENT_BLUE_VALUE", "EGL_BIND_TO_TEXTURE_RGB", "EGL_BIND_TO_TEXTURE_RGBA", "EGL_MIN_SWAP_INTERVAL", "EGL_MAX_SWAP_INTERVAL", "EGL_LUMINANCE_SIZE", "EGL_ALPHA_MASK_SIZE", "EGL_COLOR_BUFFER_TYPE", "EGL_RENDERABLE_TYPE", "EGL_CONFORMANT" };
    			int[] value = new int[1];
    			for (int i = 0; i < attributes.length; i++) {
    				int attribute = attributes[i];
    				String name = names[i];
    				if (egl.eglGetConfigAttrib(display, config, attribute, value)) {
    					Log.w(TAG, String.format("  %s: %d\n", name, value[0]));
    				} else {
    					// Log.w(TAG, String.format("  %s: failed\n", name));
    					while (egl.eglGetError() != EGL10.EGL_SUCCESS)
    						;
    				}
    			}
    		}
    
    		// Subclasses can adjust these values:
    		protected int mRedSize;
    		protected int mGreenSize;
    		protected int mBlueSize;
    		protected int mAlphaSize;
    		protected int mDepthSize;
    		protected int mStencilSize;
    		private int[] mValue = new int[1];
    	}
    
    }

package com.example.aa;
    
    import android.support.v7.app.ActionBarActivity;
    import android.os.Bundle;
    
    
    public class MainActivity extends ActionBarActivity {
    	
    	GL2JNIView mView;
    
    	    @Override protected void onCreate(Bundle icicle) {
    	        super.onCreate(icicle);
    	        mView = new GL2JNIView(getApplication());
    		    setContentView(mView);
    	    }
    
    	    @Override protected void onPause() {
    	        super.onPause();
    	        mView.onPause();
    	    }
    
    	    @Override protected void onResume() {
    	        super.onResume();
    	        mView.onResume();
    	    }
    }

源文件下载地址：在csdn中，下载->高级搜索->ID号输入：sh15285118586->点击搜索。进入后下载相关源文件。

[20150421194435024]: /images/20220805/81d04156f2784927a5087ccf7e7d37a1.png
[20150421194046562]: /images/20220805/1ede6b3c464a403e8b0f03d51e746c1e.png