JNIEXPORT void JNICALL Java_com_ti_omap4_android_camera_panorama_MosaicRenderer_transferGPUtoCPU(
JNIEnv * env, jobject obj)
{
double t0, t1, time_c;
gYVURenderer[LR].DrawTexture();
gYVURenderer[HR].DrawTexture();
sem_wait(&gPreviewImage_semaphore);
// Bind to the input LR FBO and read the Low-Res data from there...
glBindFramebuffer(GL_FRAMEBUFFER, gBufferInputYVU[LR].GetFrameBufferName());
t0 = now_ms();
glReadPixels(0,
0,
gBufferInput[LR].GetWidth(),
gBufferInput[LR].GetHeight(),
GL_RGBA,
GL_UNSIGNED_BYTE,
gPreviewImage[LR]);
checkGlError("glReadPixels LR");
// Bind to the input HR FBO and read the high-res data from there...
glBindFramebuffer(GL_FRAMEBUFFER, gBufferInputYVU[HR].GetFrameBufferName());
t0 = now_ms();
glReadPixels(0,
0,
gBufferInput[HR].GetWidth(),
gBufferInput[HR].GetHeight(),
GL_RGBA,
GL_UNSIGNED_BYTE,
gPreviewImage[HR]);
checkGlError("glReadPixels HR");
sem_post(&gPreviewImage_semaphore);
}
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);
ALOGE("Could not link program:\n%s\n", buf);
free(buf);
}
}
glDeleteProgram(program);
program = 0;
}
}
return program;
}
GLuint createProgram(std::string pVertexSource, std::string pFragmentSource) {
GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource.c_str());
if (!vertexShader) {
return 0;
}
GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource.c_str());
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 = new char[bufLength];
if (buf) {
glGetProgramInfoLog(program, bufLength, 0, buf);
debug_print("Could not link program:\n%s\n", buf);
delete buf;
}
}
glDeleteProgram(program);
program = 0;
}
}
return program;
}
void setupHandles(){
gMVP = glGetUniformLocation(gProgram, "modelViewMatrix");
gModelMatrix = glGetUniformLocation(gProgram, "ModelMatrix");
gNomralMatrix = glGetUniformLocation(gProgram, "NomralMatrix");
gS_Texture = glGetUniformLocation(gProgram, "s_texture");
gLightSource = glGetUniformLocation(gProgram, "lightSource");
gEye = glGetUniformLocation(gProgram, "eye");
// gLightsCount = glGetUniformLocation(gProgram, "lightsCount");
// fLightsCount = glGetUniformLocation(gProgram, "fragLightsCount");
gvPositionHandle = glGetAttribLocation(gProgram, "vPosition");
gvNormal = glGetAttribLocation(gProgram, "vNormal");
gvTexture = glGetAttribLocation(gProgram, "vTexture");
checkGlError("glGetAttribLocation");
}
void GLES2Lesson::prepareShaderProgram() {
glUseProgram(gProgram);
checkGlError("glUseProgram");
glUniform1i(samplerUniformPosition, twinkling ? 1 : 0);
glActiveTexture(GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glActiveTexture(GL_TEXTURE1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
void VertexArrayObject::bind() const {
useProgram();
switch (vaoSupported_) {
case VaoSupported::CHECK_SUPPORTED:
if (mw::Window::getOpenGlMajorVersion() >= 3) {
vaoSupported_ = VaoSupported::SUPPORTED;
// Fall trough to next case.
} else {
vaoSupported_ = VaoSupported::NOT_SUPPORTED;
bindBuffer();
setVertexAttribPointer();
break;
}
case VaoSupported::SUPPORTED:
if (*vao_ == 0) { // Create the vertex array only the first time.
glGenVertexArrays(1, &*vao_);
glBindVertexArray(*vao_);
checkGlError();
// Remove the block to unneeded calls to buffer changes.
VertexBufferObject::setIgnoreCurrentBind(true);
bindBuffer();
// Restore the block.
VertexBufferObject::setIgnoreCurrentBind(false);
currentVertexArrayObject = *vao_;
setVertexAttribPointer();
} else {
glBindVertexArray(*vao_);
checkGlError();
}
break;
case VaoSupported::NOT_SUPPORTED:
bindBuffer();
setVertexAttribPointer();
break;
}
}
int32_t TerrainSimRenderer::render(GLuint posXYHandle, GLuint normalHeightHandle)
{
glBindBuffer(GL_ARRAY_BUFFER, m_positionXZVBO);
glVertexAttribPointer(posXYHandle, 2, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_NormalsAndHeightsVBO);
glVertexAttribPointer(normalHeightHandle, 4, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
checkGlError("glBindBuffer vertices", "TerrainSimRenderer::render()");
glEnableVertexAttribArray(posXYHandle);
glEnableVertexAttribArray(normalHeightHandle);
checkGlError("attrs bound", "TerrainSimRenderer::render()");
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_IBO);
checkGlError("glBindBuffer IBO", "TerrainSimRenderer::render()");
glDrawElements(GL_TRIANGLES, m_indexCount, GL_UNSIGNED_SHORT, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDisableVertexAttribArray(posXYHandle);
glDisableVertexAttribArray(normalHeightHandle);
return m_indexCount;
}
void gles2_init()
{
dt_lock (&mutex);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
checkGlError("glClearColor");
memset(&gl_ctx,0,sizeof(gles2_ctx_t));
gl_ctx.simpleProgram = buildProgram(VERTEX_SHADER, FRAG_SHADER);
glUseProgram(gl_ctx.simpleProgram);
glGenTextures(1, &gl_ctx.g_texYId);
glGenTextures(1, &gl_ctx.g_texUId);
glGenTextures(1, &gl_ctx.g_texVId);
checkGlError("glGenTextures");
char *glExtension = (char *)glGetString(GL_EXTENSIONS);
if(strstr(glExtension, "GL_AMD_compressed_ATC_texture") != NULL)
gl_ctx.vertex_index = 1;
else
gl_ctx.vertex_index = 0;
gl_ctx.initialized = 1;
dt_unlock (&mutex);
__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "opengl esv2 init ok, ext:%s\n ", glExtension);
}
GLuint CreateGLProgram(const char * vShader, const char * fShader){
GLuint vertexShader = LoadShader(GL_VERTEX_SHADER, vShader);
GLuint pixelShader = LoadShader(GL_FRAGMENT_SHADER, fShader);
GLuint program = glCreateProgram();
if(!program){
LOGI(" Problems with ProgramObject");
return 0;
}
glAttachShader(program, vertexShader ); checkGlError(" glAttachShader: VertexShader");
glAttachShader(program, pixelShader ); checkGlError(" glAttachShader: FragmentShader");
glLinkProgram(program); checkGlError(" glLinkProgram");
// Check the link status
GLint linked = GL_FALSE;
glGetProgramiv( program, GL_LINK_STATUS, &linked );
if (linked != 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;
}
static GLuint buildProgram(const char* vertexShaderSource,
const char* fragmentShaderSource)
{
GLuint vertexShader = buildShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint fragmentShader = buildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
GLuint programHandle = glCreateProgram();
if (programHandle)
{
glAttachShader(programHandle, vertexShader);
checkGlError("glAttachShader");
glAttachShader(programHandle, fragmentShader);
checkGlError("glAttachShader");
glLinkProgram(programHandle);
GLint linkStatus = GL_FALSE;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkStatus);
if (linkStatus != GL_TRUE) {
GLint bufLength = 0;
glGetProgramiv(programHandle, GL_INFO_LOG_LENGTH, &bufLength);
if (bufLength) {
char* buf = (char*) malloc(bufLength);
if (buf) {
glGetProgramInfoLog(programHandle, bufLength, NULL, buf);
__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG," error: Could not link programe: %s\n", buf);
free(buf);
}
}
glDeleteProgram(programHandle);
programHandle = 0;
}
}
return programHandle;
}
void GLES2Lesson::render() {
clearBuffers();
prepareShaderProgram();
setPerspective();
resetTransformMatrices();
glUniformMatrix4fv(modelMatrixAttributePosition, 1, false, &glm::mat4(1.0f)[0][0]);
checkGlError("before drawing");
glEnableVertexAttribArray(vertexAttributePosition);
glEnableVertexAttribArray(textureCoordinatesAttributePosition);
for (auto &pair : mBatches) {
glBindTexture(GL_TEXTURE_2D, pair.first);
pair.second->draw(vertexAttributePosition, textureCoordinatesAttributePosition);
}
glDisableVertexAttribArray(vertexAttributePosition);
glDisableVertexAttribArray(textureCoordinatesAttributePosition);
checkGlError("after drawing");
}
// Create a shader program
int
ShaderUtils::createProgramFromBuffer(const char* pszVertexSource, const char* pszFragmentSource)
{
GLuint program = 0;
GLuint vertexShader = initShader(GL_VERTEX_SHADER, pszVertexSource);
GLuint fragmentShader = initShader(GL_FRAGMENT_SHADER, pszFragmentSource);
if (vertexShader && fragmentShader) {
program = glCreateProgram();
if (program) {
glAttachShader(program, vertexShader);
checkGlError("glAttachShader");
glAttachShader(program, fragmentShader);
checkGlError("glAttachShader");
glLinkProgram(program);
GLint linkStatus;
glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
if (!GL_TRUE == linkStatus) {
GLint infoLen = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen) {
char* buf = new char[infoLen];
glGetProgramInfoLog(program, infoLen, NULL, buf);
printf("Could not link program %d: %s\n", program, buf);
delete[] buf;
}
}
}
}
return program;
}
bool setupGraphics(struct android_app* state) {
const EGLint attribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_BLUE_SIZE,
8, EGL_GREEN_SIZE, 8, EGL_RED_SIZE, 8, EGL_NONE };
EGLint contextAttrs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint w, h, dummy, format;
EGLint numConfigs;
EGLConfig config;
EGLContext context;
display = eglGetDisplay(EGL_DEFAULT_DISPLAY );
eglInitialize(display, 0, 0);
defaultEGLChooser(display, config);
//eglChooseConfig(display, attribs, &config, 1, &numConfigs);
eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
context = eglCreateContext(display, config, NULL, contextAttrs);
ANativeWindow_setBuffersGeometry(state->window, 0, 0, format);
surface = eglCreateWindowSurface(display, config, state->window, NULL);
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);
printGLString("Version", GL_VERSION);
printGLString("Vendor", GL_VENDOR);
printGLString("Renderer", GL_RENDERER);
printGLString("Extensions", GL_EXTENSIONS);
LOGI("setupGraphics(%d, %d)", w, h);
render->SetPivotPoint(w * 0.5f, h * 0.5f);
std::string resourcePath("/sdcard");
render->SetResourcePath(resourcePath);
render->Initialize(w, h);
checkGlError("glViewport");
return true;
}
bool App::setupGraphics(int w, int h) {
this->screenWidth = w;
this->screenHeight = h;
LOGD("App", "width: %d, height: %d", w, h);
printGLString("Version", GL_VERSION);
printGLString("Vendor", GL_VENDOR);
printGLString("Renderer", GL_RENDERER);
printGLString("Extensions", GL_EXTENSIONS);
LOGI("App", "setupGraphics(%d, %d)", w, h);
Director::shared->start();
glViewport(0, 0, w, h);
checkGlError("glViewport");
float half_width = (float) w * 0.5f;
float half_height = (float) h * 0.5f;
Director::shared->setMatrixMode(PROJECTION_MATRIX);
Director::shared->loadIdentity();
Director::shared->setPerspective(60.0f,
(float) App::shared->getScreenWidth() / (float) App::shared->getScreenHeight(),
0.01f,
3550.0f,
0.0f);
glDisable(GL_CULL_FACE);
// Director::shared->setOrthoGraphic2D(-half_width,
// half_width,
// -half_height,
// half_height);
Director::shared->translate(-half_width, -half_height, 0.0f);
// vec3 c = {0.0f, 0.0f, 0.0f }; // center
vec3 c = { 0.0f, 0.0f, 0.0f }; // center
vec3 u = { 0.0f, 0.0f, -1.0f }; // up
// vec3 e = { 0.0f, 0.001f, 545.0f }; // eye
vec3 e = { 0.0f, 0.0001f, 2.2566f * w }; // eye
// vec3 c = { App::shared->getScreenWidth() / 2.0f, App::shared->getScreenHeight() / 2.0f, 0.0f }; // center
// vec3 u = { 0.0f, 0.0f, 1.0f }; // up
Director::shared->lookAt(&e, &c, &u);
// glDisable(GL_DEPTH_TEST);
// glDepthMask(GL_FALSE);
isRenderable = 1;
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
return true;
}
void checkFramebufferStatus(const char* name) {
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status == 0) {
LOGE("Checking completeness of Framebuffer:%s", name);
checkGlError("checkFramebufferStatus (is the target \"GL_FRAMEBUFFER\"?)");
} else if (status != GL_FRAMEBUFFER_COMPLETE) {
const char* msg = "not listed";
switch (status) {
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: msg = "attachment"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: msg = "dimensions"; break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: msg = "missing attachment"; break;
case GL_FRAMEBUFFER_UNSUPPORTED: msg = "unsupported"; break;
}
LOGE("Framebuffer: %s is INCOMPLETE: %s, %x", name, msg, status);
}
}
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);
*/
Effect* effect = Assets::getInstance().CreateEffect("Default");
sprite.SetEffect(effect);
effect->SetSource(Assets::DefaultVertexShader, Assets::DefaultFragmentShader);
effect->CompileAndLink();
//std::vector<unsigned char> image;
unsigned long iw=4;
unsigned long ih;
h=4;
std::vector<unsigned char> image(16*4);
for (int k=0; k< 16; k++)
{
for (int j=0; j< 4; j++)
image[k*4+j] = 0;
image[k*4] = 255;
image[k*4+3] = 255;
}
Texture* texture = Assets::getInstance().CreateTexture("Default");
texture->SetImageBuffer(image, 4, 4);
texture->GPULoad();
sprite.SetTexture(texture);
glViewport(0, 0, w, h);
checkGlError("glViewport");
return true;
}
bool particleRenderer::init() {
if (!shader.init()) return false;
if (!system.init()) return false;
TEX_PARTICLE_TEXTURE.loadSurface(loadImageFromResource("IDT_PARTICLE_TEXTURE"));
if (shader.bindProgram()) {
shader.setTexSize(0.5f);
shader.setParticleTexture(0);
shader.unbindProgram();
} else {
return false;
}
return checkGlError("Failed to init particle system renderer");
}
void display ()
{
/////////////////////////////////////////////////////////
//Color + Matrix setup
glClearColor( 1,1,1,1 );
glClear( GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
Shader *shader = shaderDefault;
shader->use();
Int32 uModelview = shader->program->getUniform( "modelview" );
glUniformMatrix4fv( uModelview, 1, false, (GLfloat*) matModelView.top().m );
Int32 uProjection = shader->program->getUniform( "projection" );
glUniformMatrix4fv( uProjection, 1, false, (GLfloat*) matProjection.top().m );
Int32 uColor = shaderDefault->program->getUniform( "color" );
glUniform4f( uColor, 1.0f, 0.0f, 0.0f, 0.0f );
//////////////////////////////////////////////////////////
//Render
renderQuad( shaderDefault, Vec2(100,100), Vec2(200,200) );
//////////////////////////////////////////////////////////
//FPS
//Add to fps
static int fps = 0;
fps++;
//Check if 1 second elapsed
static int lastUpdate = glutGet( GLUT_ELAPSED_TIME );
int now = glutGet( GLUT_ELAPSED_TIME );
if (now - lastUpdate > 1000)
{
std::cout << "Fps: " << fps << std::endl;
lastUpdate = now;
fps = 0;
}
//Check for errors
checkGlError( "display end" );
glutSwapBuffers();
}
void GlHelper::init() {
gProgram = GlHelper::createProgram(VERTEX_SHADER, FRAG_SHADER);
if (!gProgram) {
LOGE("Could not create program.");
}
this->gPositionHandle = glGetAttribLocation(gProgram, "vPosition");
GlHelper::checkGlError("glGetAttribLocation");
LOG("glGetAttribLocation(\"vPosition\") = %d\n", this->gPositionHandle);
glViewport(0, 0, this->nGlViewWidth, this->nGlViewHeight);
checkGlError("glViewport");
glUseProgram(gProgram);
glGenTextures(1, &gTexYId);
glGenTextures(1, &gTexUId);
glGenTextures(1, &gTexVId);
}
GLuint createProgram(const char* vtxSrc, const char* fragSrc) {
GLuint vtxShader = 0;
GLuint fragShader = 0;
GLuint program = 0;
GLint linked = GL_FALSE;
vtxShader = createShader(GL_VERTEX_SHADER, vtxSrc);
if (!vtxShader)
goto exit;
fragShader = createShader(GL_FRAGMENT_SHADER, fragSrc);
if (!fragShader)
goto exit;
program = glCreateProgram();
if (!program) {
checkGlError("glCreateProgram");
goto exit;
}
glAttachShader(program, vtxShader);
glAttachShader(program, fragShader);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked) {
ALOGE("Could not link program");
GLint infoLogLen = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLen);
if (infoLogLen) {
GLchar* infoLog = (GLchar*)malloc(infoLogLen);
if (infoLog) {
glGetProgramInfoLog(program, infoLogLen, NULL, infoLog);
ALOGE("Could not link program:\n%s\n", infoLog);
free(infoLog);
}
}
glDeleteProgram(program);
program = 0;
}
exit:
glDeleteShader(vtxShader);
glDeleteShader(fragShader);
return program;
}
void ObjRenderer::render(vector<float> vertices, Colour colour, float angle, GLenum mode, float scale_offset) {
// Change renderer
glUseProgram(_program);
checkGlError("glUseProgram");
/* Matrix transformations -------- */
// Model matrix
glm::mat4 model_mat;
model_mat = glm::rotate(model_mat,
static_cast<float>(angle*PI/180),
glm::vec3(0.0f, 0.0f, 1.0f));
// View matrix
Point2D ctr = Point2D(Game::getScreenWidth()/2, Game::getScreenHeight()/2);
Point2D anchor_pt = _cam->getPos();
glm::mat4 view_mat;
view_mat = glm::translate(view_mat, glm::vec3(ctr.getX(), ctr.getY(), 0));
view_mat = glm::rotate(view_mat,
static_cast<float>(_cam->getRotAngle()*PI/180),
glm::vec3(0.0f, 0.0f, 1.0f));
view_mat = glm::scale(view_mat, glm::vec3(_cam->getScale() + scale_offset, _cam->getScale() + scale_offset, _cam->getScale() + scale_offset));
view_mat = glm::translate(view_mat, glm::vec3(-anchor_pt.getX(), -anchor_pt.getY(), 0));
// MVP
glm::mat4 MVP_mat = _proj_mat * view_mat * model_mat;
/* ------------------------------- */
// Pass MVP to shader
glUniformMatrix4fv(_mMVP_handle, 1, GL_FALSE, glm::value_ptr(MVP_mat));
checkGlError("glUniformMatrix4fv, mMVP");
float col[4] {
colour.r,
colour.g,
colour.b,
colour.a
};
glUniform4fv(_vColor_handle, 1, col);
checkGlError("glUniformMatrix4fv, vColour");
glVertexAttribPointer(_vPos_handle, 2, GL_FLOAT, GL_FALSE, 0, &vertices[0]);
checkGlError("glVertexAttrib");
glEnableVertexAttribArray(_vPos_handle);
checkGlError("glEnableVertexAttribArray");
// Pass attributes to shader
glDrawArrays(mode, 0, vertices.size()/2);
checkGlError("glDrawArrays");
}
/*新建一个renderbuffer绑定到fbo（其实就是模拟系统的工作原理）*/
GLuint initForRenderTOrenderBuffer(int w, int h){
LOGI("initForRenderTOrenderBuffer");
glBindFramebuffer(GL_FRAMEBUFFER,0);
checkGlError("glBindFramebuffer");
glGenRenderbuffers(1,&rboID);
checkGlError("glGenRenderbuffers");
glBindRenderbuffer(GL_RENDERBUFFER,rboID);
checkGlError("glBindRenderbuffer");
glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA4,w,h);
checkGlError("glRenderbufferStorage");
glGenFramebuffers(1,&fboID);
checkGlError("glGenFramebuffers");
glBindFramebuffer(GL_FRAMEBUFFER,fboID);
checkGlError("glBindFramebuffer");
glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_RENDERBUFFER,rboID);
checkGlError("glFramebufferRenderbuffer");
glGenTextures(1, &RTtexture);
checkGlError("glGenTextures");
gInitialized = true;
}
bool Shader::glCreateLineProgram()
{
gLineProgram = createProgram(gLineVertexShader, gFragmentLineShader);
if (!gProgram) {
LOGE("Could not create program.");
return false;
}
gvLinePositionHandle = glGetAttribLocation(gLineProgram, "vPosition");
checkGlError("glGetAttribLocation");
LOGI("glGetAttribLocation(\"vPosition\") = %d\n",
gvLinePositionHandle);
gLineColorHandle = glGetUniformLocation(gLineProgram,"uColor");
gPLineMatrixHandle = glGetUniformLocation(gLineProgram, "projMatrix");
gMLineMatrixHandle = glGetUniformLocation(gLineProgram, "modelMatrix");
return true;
}
static GLuint gles2_bindTexture(GLuint texture, const uint8_t *buffer, GLuint w , GLuint h)
{
checkGlError("glGenTextures");
glBindTexture ( GL_TEXTURE_2D, texture );
checkGlError("glBindTexture");
glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE, w, h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, buffer);
checkGlError("glTexImage2D");
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
checkGlError("glTexParameteri");
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
checkGlError("glTexParameteri");
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
checkGlError("glTexParameteri");
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
checkGlError("glTexParameteri");
return texture;
}
gl_transient_state(android_app *app)
: context_( app ),
program_(gVertexShader, gFragmentShader ),
visible_(false)
{
printGLString("Version", GL_VERSION);
printGLString("Vendor", GL_VENDOR);
printGLString("Renderer", GL_RENDERER);
printGLString("Extensions", GL_EXTENSIONS);
glViewport(0, 0, context_.get_w(), context_.get_h());
checkGlError("glViewport");
LOGI( ">>>>>>>>> engine()\n" );
}
int gles2_surface_changed(int w, int h)
{
dt_lock(&mutex);
gl_ctx.g_width = w;
gl_ctx.g_height = h;
gl_ctx.status = GLRENDER_STATUS_RUNNING;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
checkGlError("glClearColor");
int width = gl_ctx.g_width;
int height = gl_ctx.g_height;
glViewport(0, 0, width, height);
__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "on surface changed\n ");
dt_unlock(&mutex);
}
void TerrainSimRenderer::updateBufferData()
{
// If this were a real application of dynamic data - such as a terrain engine with deformation - we ought to double-buffer
// the data to improve CPU-GPU concurrency. Here, we only alter the data in response to user tweaks of the sliders
// and so it only needs to be fast enough to be interactive. We omit double-buffering for the sake of simplicity.
glBindBuffer(GL_ARRAY_BUFFER, m_NormalsAndHeightsVBO);
void *ptr2 = glMapBufferRangePtr(GL_ARRAY_BUFFER, 0, nInterleavedDynamicBytes(), GL_MAP_WRITE_BIT);
int32_t error = glGetError();
if (error || !ptr2)
return;
convertDynamicAttrsToFloat((float*)ptr2);
glUnmapBufferPtr(GL_ARRAY_BUFFER);
glBindBuffer(GL_ARRAY_BUFFER, 0);
checkGlError("end", "TerrainSimRenderer::updateBufferData()");
// Too much spew:
//LOGI("TerrainSimRenderer::updateBufferData() for %d vertices, m_current=%d", m_vertCount, m_current);
}
void UnlitFboShader::render(RenderState* rstate,
RenderData* render_data, Material* material) {
Texture* texture = material->getTexture("main_texture");
glm::vec3 color = material->getVec3("color");
float opacity = material->getFloat("opacity");
if (texture->getTarget() != GL_TEXTURE_2D) {
std::string error = "UnlitFboShader::render : texture with wrong target";
throw error;
}
glUseProgram(program_->id());
glUniformMatrix4fv(u_mvp_, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_mvp));
glActiveTexture (GL_TEXTURE0);
glBindTexture(texture->getTarget(), texture->getId());
glUniform1i(u_texture_, 0);
glUniform3f(u_color_, color.r, color.g, color.b);
glUniform1f(u_opacity_, opacity);
checkGlError("UnlitFboShader::render");
}
bool GlslProgram :: loadShader ( GLhandleARB shader, Data * data )
{
const char * body = (const char *) data -> getPtr ( 0 );
GLint len = data -> getLength ();
GLint compileStatus;
glShaderSourceARB ( shader, 1, &body, &len );
// compile the particle vertex shader, and print out
glCompileShaderARB ( shader );
if ( !checkGlError() ) // check for OpenGL errors
return false;
glGetObjectParameterivARB ( shader, GL_OBJECT_COMPILE_STATUS_ARB, &compileStatus );
loadLog ( shader );
return compileStatus != 0;
}
bool GLES2Lesson::init(float w, float h, const std::string &vertexShader,
const std::string &fragmentShader) {
printVerboseDriverInformation();
gProgram = createProgram(vertexShader.c_str(), fragmentShader.c_str());
if (!gProgram) {
LOGE("Could not create program.");
return false;
}
fetchShaderLocations();
glViewport(0, 0, w, h);
checkGlError("glViewport");
resetTransformMatrices( w, h );
return true;
}
