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; }