bool begin() { bool Validated(true); Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION); Validated = Validated && glf::checkExtension("GL_ARB_explicit_uniform_location"); if(Validated && glf::checkExtension("GL_ARB_debug_output")) Validated = initDebugOutput(); if(Validated) Validated = initTest(); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); return Validated; }
bool begin() { bool Validated = true; Validated = Validated && this->checkExtension("GL_AMD_vertex_shader_viewport_index"); Validated = Validated && this->checkExtension("GL_AMD_vertex_shader_layer"); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); if(Validated) Validated = initSampler(); return Validated; }
bool begin() { bool Validated = true; Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION); Validated = Validated && glf::checkExtension("GL_GTC_direct_state_access"); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initSampler(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); return Validated && glf::checkError("begin"); }
bool begin() { bool Validated(true); glEnable(GL_PROGRAM_POINT_SIZE); glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT); //glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_UPPER_LEFT); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); return Validated; }
bool begin() { bool Validated(true); // Explicitly convert linear pixel color to sRGB color space, as FramebufferName is a sRGB FBO // Shader execution is done with linear color to get correct linear algebra working. glEnable(GL_FRAMEBUFFER_SRGB); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); return Validated; }
bool begin() { bool Validated = true; if(Validated) Validated = initTexture(); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_PROGRAM_POINT_SIZE); //glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT); glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_UPPER_LEFT); return Validated && this->checkError("begin"); }
bool begin() { bool Validated = true; Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION); if(Validated && glf::checkExtension("GL_ARB_debug_output")) Validated = initDebugOutput(); if(Validated) Validated = initProgram(); glf::checkError("initProgram Apple workaround"); if(Validated) Validated = initBuffer(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); if(Validated) Validated = initVertexArray(); return Validated && glf::checkError("begin"); }
bool begin() { bool Validated = this->checkExtension("GL_ARB_sparse_buffer"); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) { UniformPointer = (glm::mat4*)glMapNamedBufferRange( BufferName[buffer::TRANSFORM], 0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); } return Validated; }
CompoTexture::CompoTexture(const CompoImage &image): mpTextureID(COMPO_MAKE_SHARED<GLuint>(initTexture())) { const GLint width = image.width(); const GLint height = image.height(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image.pixels()); glFlush(); if (glGetError() != GL_NO_ERROR) { LOGE("Error on transferring data"); LOGE("<<----Failed Creating Texture"); return; } else { LOGI("---->>Texture Created %d", *mpTextureID); } glBindTexture(GL_TEXTURE_2D, 0); }
bool begin() { GLint NumProgramBinaryFormats(0); glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &NumProgramBinaryFormats); std::vector<GLint> ProgramBinaryFormats(static_cast<std::size_t>(NumProgramBinaryFormats)); glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, &ProgramBinaryFormats[0]); bool Validated = NumProgramBinaryFormats > 0 ? true : false; if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); return Validated; }
bool begin() { bool Validated = this->checkExtension("GL_INTEL_fragment_shader_ordering"); /* glm::vec2 const WindowSize(this->getWindowSize()); glm::vec2 const WindowRange = WindowSize * 3.f; this->Viewports.resize(1000); for (std::size_t i = 0; i < this->Viewports.size(); ++i) { glm::vec2 const ViewportPos(i % 17u, i % 13u); glm::vec2 const ViewportSize(i % 11u); this->Viewports[i] = glm::vec4(ViewportPos / glm::vec2(17, 13) * WindowRange - WindowSize, ViewportSize / glm::vec2(11)); } */ glm::vec2 WindowSize(this->getWindowSize()); this->Viewports.resize(1000); for (std::size_t i = 0; i < this->Viewports.size(); ++i) { this->Viewports[i] = glm::vec4( glm::linearRand(-WindowSize.x, WindowSize.x * 2.0f), glm::linearRand(-WindowSize.y, WindowSize.y * 2.0f), WindowSize * glm::linearRand(0.0f, 1.0f)); } if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); return Validated; }
void D3Dtex::setTexture(IDirect3DDevice9 * pDevice, int pw, int ph, unsigned char * pdata) { //texture doesn't exist yet if (ptex == NULL || ((pw > width || ph > height)&&(width != 4096 && height != 4096))) { int size; size = pw > ph ? pw : ph; if (pw > 4096 || ph > 4096) { slog("D3Dtex warning: video size [%d x %d] not supported, too large (max: 4096x4096) \n ", pw, ph); }//endif initTexture(pDevice, size); }//endif //an extra test but just to prevent crashing if (pw > width) { pw = width; } if (ph > height) { ph = height; } unsigned int * data; int i; data = (unsigned int *) pdata; D3DLOCKED_RECT lockedRect; HRESULT hResult = ptex->LockRect(0, &lockedRect, NULL, D3DLOCK_DISCARD); if(FAILED(hResult)) { return; }// Or handle error BYTE* pBits = (BYTE*)lockedRect.pBits; for (i = 0; i < ph; ++i) { memcpy(pBits + i*lockedRect.Pitch, data + i*pw, pw*4); } ptex->UnlockRect(0); }//settexture
bool begin() { bool Validated = this->checkExtension("GL_EXT_direct_state_access"); if(Validated) Validated = initProgram(); if(Validated) Validated = initSampler(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); //glEnable(GL_SAMPLE_MASK); //glSampleMaski(0, 0xFF); return Validated; }
bool begin() { bool Validated(true); Validated = Validated && this->checkExtension("GL_ARB_framebuffer_no_attachments"); Validated = Validated && this->checkExtension("GL_ARB_clear_texture"); Validated = Validated && this->checkExtension("GL_ARB_shader_storage_buffer_object"); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initSampler(); if(Validated) Validated = initFramebuffer(); return Validated; }
bool begin() { bool Validated = true; Validated = Validated && this->checkExtension("GL_NV_explicit_multisample"); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initSampler(); if(Validated) Validated = initRenderbuffer(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); return Validated && this->checkError("begin"); }
void loadImageData(int argc, char **argv) { // load image from disk uchar *h_data = NULL; char *srcImagePath = NULL; if ((srcImagePath = sdkFindFilePath(srcImageFilename, argv[0])) == NULL) { printf("bicubicTexture loadImageData() could not find <%s>\nExiting...\n", srcImageFilename); exit(EXIT_FAILURE); } sdkLoadPGM<unsigned char>(srcImagePath, &h_data, &imageWidth, &imageHeight); printf("Loaded '%s', %d x %d pixels\n", srcImageFilename, imageWidth, imageHeight); cx = imageWidth * 0.5f; cy = imageHeight * 0.5f; // initialize texture initTexture(imageWidth, imageHeight, h_data); }
bool begin() { bool Validated = true; if(Validated) Validated = initProgram(); if(Validated) Validated = initSampler(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); //glEnable(GL_SAMPLE_MASK); //glSampleMaski(0, 0xFF); return Validated; }
bool begin() { bool Validated(true); Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION); GLint MaxVaryingOutputComp(0); glGetIntegerv(GL_MAX_VARYING_COMPONENTS, &MaxVaryingOutputComp); GLint MaxVaryingOutputVec(0); glGetIntegerv(GL_MAX_VARYING_VECTORS, &MaxVaryingOutputVec); if(Validated && glf::checkExtension("GL_ARB_debug_output")) Validated = initDebugOutput(); if(Validated) Validated = initTexture(); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); return Validated; }
void OSystem_Android::initSize(uint width, uint height, const Graphics::PixelFormat *format) { ENTER("%d, %d, %p", width, height, format); GLTHREADCHECK; #ifdef USE_RGB_COLOR initTexture(&_game_texture, width, height, format); #else _game_texture->allocBuffer(width, height); #endif updateScreenRect(); updateEventScale(); // Don't know mouse size yet - it gets reallocated in // setMouseCursor. We need the palette allocated before // setMouseCursor however, so just take a guess at the desired // size (it's small). _mouse_texture_palette->allocBuffer(20, 20); clearScreen(kClear); }
bool begin() { bool Validated = true; Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION); Validated = Validated && glf::checkExtension("GL_EXT_texture_sRGB_decode"); if(Validated && glf::checkExtension("GL_ARB_debug_output")) Validated = initDebugOutput(); if(Validated) Validated = initProgram(); if(Validated) Validated = initSampler(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); if(Validated) Validated = initVertexArray(); return Validated; }
Robot() { initStructuralConstraints(); initTexture(); initLights(); initHip(); initBust(); initNeck(); initHead(); initLeftShoulder(); initRightShoulder(); initLeftUpperArmFront(); initLeftLowerArmFront(); initRightUpperArmFront(); initRightLowerArmFront(); initLeftUpperArmBehind(); initLeftLowerArmBehind(); initRightUpperArmBehind(); initRightLowerArmBehind(); initLeftFrontHand(); initRightFrontHand(); initLeftBehindHand(); initRightBehindHand(); initLeftUpperLeg(); initLeftLowerLeg(); initRightUpperLeg(); initRightLowerLeg(); initLeftFoot(); initRightFoot(); behindArmAngle=0; keys = KeyControls(); }
bool begin() { glm::uvec2 WindowSize = this->getWindowSize(); glm::vec2 ViewportSize(WindowSize.x * 0.33f, WindowSize.y * 0.50f); Viewport[viewport::VIEWPORT0] = glm::vec4(ViewportSize.x * 0.0f, ViewportSize.y * 0.0f, ViewportSize.x * 1.0f, ViewportSize.y * 1.0f); Viewport[viewport::VIEWPORT1] = glm::vec4(ViewportSize.x * 1.0f, ViewportSize.y * 0.0f, ViewportSize.x * 1.0f, ViewportSize.y * 1.0f); Viewport[viewport::VIEWPORT2] = glm::vec4(ViewportSize.x * 2.0f, ViewportSize.y * 0.0f, ViewportSize.x * 1.0f, ViewportSize.y * 1.0f); Viewport[viewport::VIEWPORT3] = glm::vec4(ViewportSize.x * 0.0f, ViewportSize.y * 1.0f, ViewportSize.x * 1.0f, ViewportSize.y * 1.0f); Viewport[viewport::VIEWPORT4] = glm::vec4(ViewportSize.x * 1.0f, ViewportSize.y * 1.0f, ViewportSize.x * 1.0f, ViewportSize.y * 1.0f); Viewport[viewport::VIEWPORT5] = glm::vec4(ViewportSize.x * 2.0f, ViewportSize.y * 1.0f, ViewportSize.x * 1.0f, ViewportSize.y * 1.0f); bool Validated = true; Validated = Validated && this->checkExtension("GL_ARB_texture_mirror_clamp_to_edge"); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initTexture(); if(Validated) Validated = initSampler(); if(Validated) Validated = initVertexArray(); if(Validated) { glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); UniformPointer = (glm::mat4*)glMapBufferRange( GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT); } return Validated; }
bool begin() { bool Validated(true); float MinFragmentInterpolationOffset(0); float MaxFragmentInterpolationOffset(0); float FragmentInterpolationOffsetBits(0); glGetFloatv(GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, &MinFragmentInterpolationOffset); glGetFloatv(GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, &MaxFragmentInterpolationOffset); glGetFloatv(GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, &FragmentInterpolationOffsetBits); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); return Validated; }
bool begin() { bool Validated = true; Validated = Validated && this->checkExtension("GL_AMD_performance_monitor"); if(Validated) { this->Monitor.reset(new monitor()); this->Monitor->record("CP", 1); } if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initTexture(); if(Validated) Validated = initFramebuffer(); return Validated; }
/** Initialize */ void mainInit() { glClearColor(1.0,1.0,1.0,0.0); glColor3f(0.0f,0.0f,0.0f); setWindow(); setViewport(0, windowWidth, 0, windowHeight); //initSound(); TODO Disabled until we got some real sounds. // Enables hidden surfaces removal glFrontFace (GL_CCW); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); initTexture(); initModel(); initLight(); printf("w - acelerar \n"); printf("a - esquerda \n"); printf("d - direita \n"); }
void updateCursor (CompCursor *c, int x, int y, unsigned long serial) { /* new current cursor */ if (!c->image || c->image->serial != serial) { CompCursorImage *cursorImage; cursorImage = findCursorImageAtScreen (c->screen, serial); if (!cursorImage) { Display *dpy = c->screen->display->display; XFixesCursorImage *image; image = XFixesGetCursorImage (dpy); if (!image) return; cursorImage = malloc (sizeof (CompCursorImage)); if (!cursorImage) { XFree (image); return; } x = image->x; y = image->y; cursorImage->serial = image->cursor_serial; cursorImage->xhot = image->xhot; cursorImage->yhot = image->yhot; cursorImage->width = image->width; cursorImage->height = image->height; initTexture (c->screen, &cursorImage->texture); if (!imageBufferToTexture (c->screen, &cursorImage->texture, (char *) image->pixels, image->width, image->height)) { free (cursorImage); XFree (image); return; } XFree (image); cursorImage->next = c->screen->cursorImages; c->screen->cursorImages = cursorImage; } if (c->image) addCursorDamage (c); c->image = cursorImage; c->x = x - c->image->xhot; c->y = y - c->image->yhot; setCursorMatrix (c); addCursorDamage (c); } else { int newX, newY; newX = x - c->image->xhot; newY = y - c->image->yhot; if (c->x != newX || c->y != newY) { addCursorDamage (c); c->x = newX; c->y = newY; setCursorMatrix (c); addCursorDamage (c); } } }
bool BootAnimation::movie() { ZipEntryRO desc = mZip->findEntryByName("desc.txt"); ALOGE_IF(!desc, "couldn't find desc.txt"); if (!desc) { return false; } FileMap* descMap = mZip->createEntryFileMap(desc); mZip->releaseEntry(desc); ALOGE_IF(!descMap, "descMap is null"); if (!descMap) { return false; } String8 desString((char const*)descMap->getDataPtr(), descMap->getDataLength()); descMap->release(); char const* s = desString.string(); Animation animation; // Parse the description file for (;;) { const char* endl = strstr(s, "\n"); if (!endl) break; String8 line(s, endl - s); const char* l = line.string(); int fps, width, height, count, pause; char path[ANIM_ENTRY_NAME_MAX]; char pathType; if (sscanf(l, "%d %d %d", &width, &height, &fps) == 3) { //LOGD("> w=%d, h=%d, fps=%d", width, height, fps); animation.width = width; animation.height = height; animation.fps = fps; } else if (sscanf(l, " %c %d %d %s", &pathType, &count, &pause, path) == 4) { //LOGD("> type=%c, count=%d, pause=%d, path=%s", pathType, count, pause, path); Animation::Part part; part.playUntilComplete = pathType == 'c'; part.count = count; part.pause = pause; part.path = path; animation.parts.add(part); } s = ++endl; } // read all the data structures const size_t pcount = animation.parts.size(); void *cookie = NULL; if (!mZip->startIteration(&cookie)) { return false; } ZipEntryRO entry; char name[ANIM_ENTRY_NAME_MAX]; while ((entry = mZip->nextEntry(cookie)) != NULL) { const int foundEntryName = mZip->getEntryFileName(entry, name, ANIM_ENTRY_NAME_MAX); if (foundEntryName > ANIM_ENTRY_NAME_MAX || foundEntryName == -1) { ALOGE("Error fetching entry file name"); continue; } const String8 entryName(name); const String8 path(entryName.getPathDir()); const String8 leaf(entryName.getPathLeaf()); if (leaf.size() > 0) { for (size_t j=0 ; j<pcount ; j++) { if (path == animation.parts[j].path) { int method; // supports only stored png files if (mZip->getEntryInfo(entry, &method, NULL, NULL, NULL, NULL, NULL)) { if (method == ZipFileRO::kCompressStored) { FileMap* map = mZip->createEntryFileMap(entry); if (map) { Animation::Frame frame; frame.name = leaf; frame.map = map; Animation::Part& part(animation.parts.editItemAt(j)); part.frames.add(frame); } } } } } } } mZip->endIteration(cookie); // clear screen glShadeModel(GL_FLAT); glDisable(GL_DITHER); glDisable(GL_SCISSOR_TEST); glDisable(GL_BLEND); glClearColor(0,0,0,1); glClear(GL_COLOR_BUFFER_BIT); eglSwapBuffers(mDisplay, mSurface); glBindTexture(GL_TEXTURE_2D, 0); glEnable(GL_TEXTURE_2D); glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); const int xc = (mWidth - animation.width) / 2; const int yc = ((mHeight - animation.height) / 2); nsecs_t lastFrame = systemTime(); nsecs_t frameDuration = s2ns(1) / animation.fps; Region clearReg(Rect(mWidth, mHeight)); clearReg.subtractSelf(Rect(xc, yc, xc+animation.width, yc+animation.height)); for (size_t i=0 ; i<pcount ; i++) { const Animation::Part& part(animation.parts[i]); const size_t fcount = part.frames.size(); glBindTexture(GL_TEXTURE_2D, 0); for (int r=0 ; !part.count || r<part.count ; r++) { // Exit any non playuntil complete parts immediately if(exitPending() && !part.playUntilComplete) break; for (size_t j=0 ; j<fcount && (!exitPending() || part.playUntilComplete) ; j++) { const Animation::Frame& frame(part.frames[j]); nsecs_t lastFrame = systemTime(); if (r > 0) { glBindTexture(GL_TEXTURE_2D, frame.tid); } else { if (part.count != 1) { glGenTextures(1, &frame.tid); glBindTexture(GL_TEXTURE_2D, frame.tid); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } initTexture(frame); } if (!clearReg.isEmpty()) { Region::const_iterator head(clearReg.begin()); Region::const_iterator tail(clearReg.end()); glEnable(GL_SCISSOR_TEST); while (head != tail) { const Rect& r(*head++); glScissor(r.left, mHeight - r.bottom, r.width(), r.height()); glClear(GL_COLOR_BUFFER_BIT); } glDisable(GL_SCISSOR_TEST); } glDrawTexiOES(xc, yc, 0, animation.width, animation.height); eglSwapBuffers(mDisplay, mSurface); nsecs_t now = systemTime(); nsecs_t delay = frameDuration - (now - lastFrame); //ALOGD("%lld, %lld", ns2ms(now - lastFrame), ns2ms(delay)); lastFrame = now; if (delay > 0) { struct timespec spec; spec.tv_sec = (now + delay) / 1000000000; spec.tv_nsec = (now + delay) % 1000000000; int err; do { err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL); } while (err<0 && errno == EINTR); } checkExit(); } usleep(part.pause * ns2us(frameDuration)); // For infinite parts, we've now played them at least once, so perhaps exit if(exitPending() && !part.count) break; } // free the textures for this part if (part.count != 1) { for (size_t j=0 ; j<fcount ; j++) { const Animation::Frame& frame(part.frames[j]); glDeleteTextures(1, &frame.tid); } } } return false; }
bool GLWidgetRendererPrivate::initTextures(const VideoFormat &fmt) { // isSupported(pixfmt) if (!fmt.isValid()) return false; video_format.setPixelFormatFFmpeg(fmt.pixelFormatFFmpeg()); //http://www.berkelium.com/OpenGL/GDC99/internalformat.html //NV12: UV is 1 plane. 16 bits as a unit. GL_LUMINANCE4, 8, 16, ... 32? //GL_LUMINANCE, GL_LUMINANCE_ALPHA are deprecated in GL3, removed in GL3.1 //replaced by GL_RED, GL_RG, GL_RGB, GL_RGBA? for 1, 2, 3, 4 channel image //http://www.gamedev.net/topic/634850-do-luminance-textures-still-exist-to-opengl/ //https://github.com/kivy/kivy/issues/1738: GL_LUMINANCE does work on a Galaxy Tab 2. LUMINANCE_ALPHA very slow on Linux //ALPHA: vec4(1,1,1,A), LUMINANCE: (L,L,L,1), LUMINANCE_ALPHA: (L,L,L,A) /* * To support both planar and packed use GL_ALPHA and in shader use r,g,a like xbmc does. * or use Swizzle_mask to layout the channels: http://www.opengl.org/wiki/Texture#Swizzle_mask * GL ES2 support: GL_RGB, GL_RGBA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_ALPHA * http://stackoverflow.com/questions/18688057/which-opengl-es-2-0-texture-formats-are-color-depth-or-stencil-renderable */ internal_format = QVector<GLint>(fmt.planeCount(), FMT_INTERNAL); data_format = QVector<GLenum>(fmt.planeCount(), FMT); data_type = QVector<GLenum>(fmt.planeCount(), GL_UNSIGNED_BYTE); if (fmt.isPlanar()) { /*! * GLES internal_format == data_format, GL_LUMINANCE_ALPHA is 2 bytes * so if NV12 use GL_LUMINANCE_ALPHA, YV12 use GL_ALPHA */ qDebug("///////////bpp %d", fmt.bytesPerPixel()); internal_format[0] = data_format[0] = GL_LUMINANCE; //or GL_RED for GL if (fmt.planeCount() == 2) { internal_format[1] = data_format[1] = GL_LUMINANCE_ALPHA; } else { if (fmt.bytesPerPixel(1) == 2) { // read 16 bits and compute the real luminance in shader internal_format[0] = data_format[0] = GL_LUMINANCE_ALPHA; internal_format[1] = data_format[1] = GL_LUMINANCE_ALPHA; //vec4(L,L,L,A) internal_format[2] = data_format[2] = GL_LUMINANCE_ALPHA; } else { internal_format[1] = data_format[1] = GL_LUMINANCE; //vec4(L,L,L,1) internal_format[2] = data_format[2] = GL_ALPHA;//GL_ALPHA; } } for (int i = 0; i < internal_format.size(); ++i) { // xbmc use bpp not bpp(plane) //internal_format[i] = GetGLInternalFormat(data_format[i], fmt.bytesPerPixel(i)); //data_format[i] = internal_format[i]; } } else { //glPixelStorei(GL_UNPACK_ALIGNMENT, fmt.bytesPerPixel()); // TODO: if no alpha, data_fmt is not GL_BGRA. align at every upload? } for (int i = 0; i < fmt.planeCount(); ++i) { //qDebug("format: %#x GL_LUMINANCE_ALPHA=%#x", data_format[i], GL_LUMINANCE_ALPHA); if (fmt.bytesPerPixel(i) == 2 && fmt.planeCount() == 3) { //data_type[i] = GL_UNSIGNED_SHORT; } int bpp_gl = bytesOfGLFormat(data_format[i], data_type[i]); int pad = qCeil((qreal)(texture_size[i].width() - effective_tex_width[i])/(qreal)bpp_gl); texture_size[i].setWidth(qCeil((qreal)texture_size[i].width()/(qreal)bpp_gl)); effective_tex_width[i] /= bpp_gl; //fmt.bytesPerPixel(i); //effective_tex_width_ratio = qDebug("texture width: %d - %d = pad: %d. bpp(gl): %d", texture_size[i].width(), effective_tex_width[i], pad, bpp_gl); } /* * there are 2 fragment shaders: rgb and yuv. * only 1 texture for packed rgb. planar rgb likes yuv * To support both planar and packed yuv, and mixed yuv(NV12), we give a texture sample * for each channel. For packed, each (channel) texture sample is the same. For planar, * packed channels has the same texture sample. * But the number of actural textures we upload is plane count. * Which means the number of texture id equals to plane count */ if (textures.size() != fmt.planeCount()) { glDeleteTextures(textures.size(), textures.data()); qDebug("delete %d textures", textures.size()); textures.clear(); textures.resize(fmt.planeCount()); glGenTextures(textures.size(), textures.data()); } if (!hasGLSL) { initTexture(textures[0], internal_format[0], data_format[0], data_type[0], texture_size[0].width(), texture_size[0].height()); // more than 1? qWarning("Does not support GLSL!"); return false; } qDebug("init textures..."); initTexture(textures[0], internal_format[0], data_format[0], data_type[0], texture_size[0].width(), texture_size[0].height()); for (int i = 1; i < textures.size(); ++i) { initTexture(textures[i], internal_format[i], data_format[i], data_type[i], texture_size[i].width(), texture_size[i].height()); } return true; }
bool BootAnimation::android() { initTexture(&mAndroid[0], mAssets, "images/android-logo-mask.png"); initTexture(&mAndroid[1], mAssets, "images/android-logo-shine.png"); // clear screen glShadeModel(GL_FLAT); glDisable(GL_DITHER); glDisable(GL_SCISSOR_TEST); glClearColor(0,0,0,1); glClear(GL_COLOR_BUFFER_BIT); eglSwapBuffers(mDisplay, mSurface); glEnable(GL_TEXTURE_2D); glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); const GLint xc = (mWidth - mAndroid[0].w) / 2; const GLint yc = (mHeight - mAndroid[0].h) / 2; const Rect updateRect(xc, yc, xc + mAndroid[0].w, yc + mAndroid[0].h); glScissor(updateRect.left, mHeight - updateRect.bottom, updateRect.width(), updateRect.height()); // Blend state glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); const nsecs_t startTime = systemTime(); do { nsecs_t now = systemTime(); double time = now - startTime; float t = 4.0f * float(time / us2ns(16667)) / mAndroid[1].w; GLint offset = (1 - (t - floorf(t))) * mAndroid[1].w; GLint x = xc - offset; glDisable(GL_SCISSOR_TEST); glClear(GL_COLOR_BUFFER_BIT); glEnable(GL_SCISSOR_TEST); glDisable(GL_BLEND); glBindTexture(GL_TEXTURE_2D, mAndroid[1].name); glDrawTexiOES(x, yc, 0, mAndroid[1].w, mAndroid[1].h); glDrawTexiOES(x + mAndroid[1].w, yc, 0, mAndroid[1].w, mAndroid[1].h); glEnable(GL_BLEND); glBindTexture(GL_TEXTURE_2D, mAndroid[0].name); glDrawTexiOES(xc, yc, 0, mAndroid[0].w, mAndroid[0].h); EGLBoolean res = eglSwapBuffers(mDisplay, mSurface); if (res == EGL_FALSE) break; // 12fps: don't animate too fast to preserve CPU const nsecs_t sleepTime = 83333 - ns2us(systemTime() - now); if (sleepTime > 0) usleep(sleepTime); checkExit(); } while (!exitPending()); glDeleteTextures(1, &mAndroid[0].name); glDeleteTextures(1, &mAndroid[1].name); return false; }
void DrawDepthMap(const xn::DepthMetaData& dm) { static bool bInitialized = false; static GLuint depthTexID; static unsigned char* pDepthTexBuf; static int texWidth, texHeight; float topLeftX; float topLeftY; float bottomRightY; float bottomRightX; float texXpos; float texYpos; if(!bInitialized) { XnUInt16 nXRes = dm.XRes(); XnUInt16 nYRes = dm.YRes(); texWidth = getClosestPowerOfTwo(nXRes); texHeight = getClosestPowerOfTwo(nYRes); depthTexID = initTexture((void**)&pDepthTexBuf,texWidth, texHeight) ; bInitialized = true; topLeftX = nXRes; topLeftY = 0; bottomRightY = nYRes; bottomRightX = 0; texXpos =(float)nXRes/texWidth; texYpos =(float)nYRes/texHeight; memset(texcoords, 0, 8*sizeof(float)); texcoords[0] = texXpos, texcoords[1] = texYpos, texcoords[2] = texXpos, texcoords[7] = texYpos; } unsigned int nValue = 0; unsigned int nHistValue = 0; unsigned int nIndex = 0; unsigned int nX = 0; unsigned int nY = 0; unsigned int nNumberOfPoints = 0; XnUInt16 g_nXRes = dm.XRes(); XnUInt16 g_nYRes = dm.YRes(); unsigned char* pDestImage = pDepthTexBuf; const XnUInt16* pDepth = dm.Data(); // Calculate the accumulative histogram memset(g_pDepthHist, 0, MAX_DEPTH*sizeof(float)); for (nY=0; nY<g_nYRes; nY++) { for (nX=0; nX<g_nXRes; nX++) { nValue = *pDepth; if (nValue != 0) { g_pDepthHist[nValue]++; nNumberOfPoints++; } pDepth++; } } for (nIndex=1; nIndex<MAX_DEPTH; nIndex++) { g_pDepthHist[nIndex] += g_pDepthHist[nIndex-1]; } if (nNumberOfPoints) { for (nIndex=1; nIndex<MAX_DEPTH; nIndex++) { g_pDepthHist[nIndex] = (unsigned int)(256 * (1.0f - (g_pDepthHist[nIndex] / nNumberOfPoints))); } } pDepth = dm.Data(); { XnUInt32 nIndex = 0; // Prepare the texture map for (nY=0; nY<g_nYRes; nY++) { for (nX=0; nX < g_nXRes; nX++, nIndex++) { nValue = *pDepth; if (nValue != 0) { nHistValue = g_pDepthHist[nValue]; pDestImage[0] = nHistValue; pDestImage[1] = nHistValue; pDestImage[2] = nHistValue; } else { pDestImage[0] = 0; pDestImage[1] = 0; pDestImage[2] = 0; } pDepth++; pDestImage+=3; } pDestImage += (texWidth - g_nXRes) *3; } } glBindTexture(GL_TEXTURE_2D, depthTexID); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pDepthTexBuf); // Display the OpenGL texture map glColor4f(0.5,0.5,0.5,1); glEnable(GL_TEXTURE_2D); DrawTexture(dm.XRes(),dm.YRes(),0,0); glDisable(GL_TEXTURE_2D); }