2022-06-24 测试EGL_BUFFER_PRESERVE

2022-06-24  本文已影响0人  SMSM

想要用surfaceview的游戏模式，如果不需要系统UI体系的话，可以直接走NativeActivity模式，直接对接window对应的layer，而不需要走textureview的方案，先转到texture上。也不需要走surfaceview的方案，要重新申请一个layer。而是直接使用原来系统UI使用的Layer，移除系统UI

https://github.com/android/ndk-samples/tree/main/native-activity

classpath 'com.android.tools.build:gradle:3.2.1'
distributionUrl=https://services.gradle.org/distributions/gradle-4.6-all.zip

Copyright (C) The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

cmake_minimum_required(VERSION 3.4.1)

build native_app_glue as a static lib

set({CMAKE_C_FLAGS}, "{CMAKE_C_FLAGS}")
add_library(native_app_glue STATIC
${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c)

now build app's shared lib

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11 -Wall -Werror")

Export ANativeActivity_onCreate(),

Refer to: https://github.com/android-ndk/ndk/issues/381.

set(CMAKE_SHARED_LINKER_FLAGS
"${CMAKE_SHARED_LINKER_FLAGS} -u ANativeActivity_onCreate")

add_library(native-activity SHARED main.cpp)

target_include_directories(native-activity PRIVATE
${ANDROID_NDK}/sources/android/native_app_glue)

add lib dependencies

target_link_libraries(native-activity
android
native_app_glue
EGL
GLESv2
log)

/*

*/

//BEGIN_INCLUDE(all)

include <initializer_list>

include <memory>

include <cstdlib>

include <cstring>

include <jni.h>

include <cerrno>

include <cassert>

include <EGL/egl.h>

include <GLES/gl.h>

include <GLES2/gl2.h>

include <GLES2/gl2ext.h>

include <android/sensor.h>

include <android/log.h>

include <android_native_app_glue.h>

include <stdio.h>

include <stdlib.h>

include <math.h>

define LOG_TAG "native-activity"

define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,VA_ARGS)

define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,VA_ARGS)

define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "native-activity", 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);
}
}

auto gVertexShader =
"attribute vec4 vPosition;\n"
"void main() {\n"
" gl_Position = vPosition;\n"
"}\n";

auto gFragmentShader =
"precision mediump float;\n"
"void main() {\n"
" gl_FragColor = vec4(0.0, 1.0, 0.0, 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",
shaderType, buf);
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 / 2, h / 2);
checkGlError("glViewport");
return true;

}

GLfloat gTriangleVertices[] = {0.0f, 0.5f, -0.5f, -0.5f,
0.5f, -0.5f};

void renderFrame() {
static float grey;
grey += 0.01f;
if (grey > 1.0f) {
grey = 0.0f;
}
// glClearColor(grey, grey, grey, 1.0f);
// checkGlError("glClearColor");
// glClear(GL_COLOR_BUFFER_BIT);
// checkGlError("glClear");

glUseProgram(gProgram);
checkGlError("glUseProgram");

gTriangleVertices[1] = gTriangleVertices[1] + 0.01;
gTriangleVertices[3] = gTriangleVertices[3] + 0.01;
gTriangleVertices[5] = gTriangleVertices[5] + 0.01;

glVertexAttribPointer(gvPositionHandle, 2, GL_FLOAT, GL_FALSE, 0, gTriangleVertices);
checkGlError("glVertexAttribPointer");
glEnableVertexAttribArray(gvPositionHandle);
checkGlError("glEnableVertexAttribArray");
glDrawArrays(GL_TRIANGLES, 0, 3);
checkGlError("glDrawArrays");

}

/**

// EGL_BAD_ATTRIBUTE

if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) {
    LOGW("Unable to eglMakeCurrent");
    return -1;
}

eglQuerySurface(display, surface, EGL_WIDTH, &w);
eglQuerySurface(display, surface, EGL_HEIGHT, &h);

engine->display = display;
engine->context = context;
engine->surface = surface;
engine->width = w;
engine->height = h;
engine->state.angle = 0;

// Check openGL on the system
auto opengl_info = {GL_VENDOR, GL_RENDERER, GL_VERSION, GL_EXTENSIONS};
for (auto name : opengl_info) {
    auto info = glGetString(name);
    LOGI("OpenGL Info: %s", info);
}
// Initialize GL state.
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
glEnable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);

setupGraphics(w, h);

// glViewport(0, 0, w / 2, h / 2);
return 0;
}

/**

/**

/**

/**

/*

include <dlfcn.h>

ASensorManager *AcquireASensorManagerInstance(android_app *app) {

if (!app)
    return nullptr;

typedef ASensorManager *(*PF_GETINSTANCEFORPACKAGE)(const char *name);
void *androidHandle = dlopen("libandroid.so", RTLD_NOW);
auto getInstanceForPackageFunc = (PF_GETINSTANCEFORPACKAGE)
        dlsym(androidHandle, "ASensorManager_getInstanceForPackage");
if (getInstanceForPackageFunc) {
    JNIEnv *env = nullptr;
    app->activity->vm->AttachCurrentThread(&env, nullptr);

    jclass android_content_Context = env->GetObjectClass(app->activity->clazz);
    jmethodID midGetPackageName = env->GetMethodID(android_content_Context,
                                                   "getPackageName",
                                                   "()Ljava/lang/String;");
    auto packageName = (jstring) env->CallObjectMethod(app->activity->clazz,
                                                       midGetPackageName);

    const char *nativePackageName = env->GetStringUTFChars(packageName, nullptr);
    ASensorManager *mgr = getInstanceForPackageFunc(nativePackageName);
    env->ReleaseStringUTFChars(packageName, nativePackageName);
    app->activity->vm->DetachCurrentThread();
    if (mgr) {
        dlclose(androidHandle);
        return mgr;
    }
}

typedef ASensorManager *(*PF_GETINSTANCE)();
auto getInstanceFunc = (PF_GETINSTANCE)
        dlsym(androidHandle, "ASensorManager_getInstance");
// by all means at this point, ASensorManager_getInstance should be available
assert(getInstanceFunc);
dlclose(androidHandle);

return getInstanceFunc();

}

/**

//END_INCLUDE(all)

上一篇 下一篇

猜你喜欢

热点阅读