¿Es posible renderizar una vista de Android a un OpenGL FBO o textura?

Question

¿Es posible representar una Vista (por ejemplo, una Vista Web) en un FBO para que pueda usarse como una textura en una composición OpenGL?

Answer 1

Sí es ciertamente posible, he redactado un how-to aquí; http://www.felixjones.co.uk/neo%20website/Android_View/

Sin embargo, para los elementos estáticos que no cambian, la opción de mapa de bits puede ser mejor.

Answer 2

Al menos alguien se las arregló para hacer que el texto de esta manera:

Rendering Text in OpenGL on Android

En él se describe el método que utiliza para la prestación de alta calidad de texto dinámico eficiente usando OpenGL ES 1.0, con TrueType/OpenType archivos de fuentes.

[...]

Todo el proceso es realmente muy fácil. Generamos el mapa de bits (como una textura), calculamos y almacenamos el tamaño de cada personaje, así como su ubicación en la textura (coordenadas UV). Hay algunos otros detalles más finos, pero llegaremos a eso.

OpenGL ES 2.0 Versión: https://github.com/d3kod/Texample2

Answer 3

El proyecto de demostración completo que permite ver texturas GL en tiempo real de manera eficiente se puede encontrar en this repo. Muestra cómo renderizar WebView a textura GL en tiempo real como un ejemplo.

también un código breve para esto puede ser similar al siguiente (tomado del proyecto de demostración de la cesión temporal anterior):

public class GLWebView extends WebView { 

    private ViewToGLRenderer mViewToGLRenderer; 
    ... 
    // drawing magic 
    @Override 
    public void draw(Canvas canvas) { 
     //returns canvas attached to gl texture to draw on 
     Canvas glAttachedCanvas = mViewToGLRenderer.onDrawViewBegin(); 
     if(glAttachedCanvas != null) { 
      //translate canvas to reflect view scrolling 
      float xScale = glAttachedCanvas.getWidth()/(float)canvas.getWidth(); 
      glAttachedCanvas.scale(xScale, xScale); 
      glAttachedCanvas.translate(-getScrollX(), -getScrollY()); 
      //draw the view to provided canvas 
      super.draw(glAttachedCanvas); 
     } 
     // notify the canvas is updated 
     mViewToGLRenderer.onDrawViewEnd(); 
    } 

    ... 
} 


public class ViewToGLRenderer implements GLSurfaceView.Renderer{ 

    private SurfaceTexture mSurfaceTexture; 
    private Surface mSurface; 

    private int mGlSurfaceTexture; 
    private Canvas mSurfaceCanvas; 

    ... 

    @Override 
    public void onDrawFrame(GL10 gl){ 
     synchronized (this){ 
      // update texture 
      mSurfaceTexture.updateTexImage(); 
     } 
    } 

    @Override 
    public void onSurfaceChanged(GL10 gl, int width, int height){ 
     releaseSurface(); 
     mGlSurfaceTexture = createTexture(); 
     if (mGlSurfaceTexture > 0){ 
      //attach the texture to a surface. 
      //It's a clue class for rendering an android view to gl level 
      mSurfaceTexture = new SurfaceTexture(mGlSurfaceTexture); 
      mSurfaceTexture.setDefaultBufferSize(mTextureWidth, mTextureHeight); 
      mSurface = new Surface(mSurfaceTexture); 
     } 

    } 

    public Canvas onDrawViewBegin(){ 
     mSurfaceCanvas = null; 
     if (mSurface != null) { 
      try { 
       mSurfaceCanvas = mSurface.lockCanvas(null); 
      }catch (Exception e){ 
       Log.e(TAG, "error while rendering view to gl: " + e); 
      } 
     } 
     return mSurfaceCanvas; 
    } 

    public void onDrawViewEnd(){ 
     if(mSurfaceCanvas != null) { 
      mSurface.unlockCanvasAndPost(mSurfaceCanvas); 
     } 
     mSurfaceCanvas = null; 
    } 
} 

La demo de salida de pantalla: