Java 类android.opengl.GLSurfaceView.Renderer 实例源码

public void setRenderer(Renderer renderer) {
    checkRenderThreadState();
    if (mEGLConfigChooser == null) {
        mEGLConfigChooser = new SimpleEGLConfigChooser(true, mEGLContextClientVersion);
    }
    if (mEGLContextFactory == null) {
        mEGLContextFactory = new DefaultContextFactory();
    }
    if (mEGLWindowSurfaceFactory == null) {
        mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
    }
    mGLThread = new GLThread(renderer, mEGLConfigChooser,
            mEGLContextFactory, mEGLWindowSurfaceFactory, mGLWrapper,
            mEGLContextClientVersion);
    mGLThread.start();
}

GLThread(Renderer renderer, EGLConfigChooser chooser,
        EGLContextFactory contextFactory,
        EGLWindowSurfaceFactory surfaceFactory, GLWrapper wrapper,
        int eglContextClientVersion) {
    super();
    mDone = false;
    mWidth = 0;
    mHeight = 0;
    mRequestRender = true;
    mRenderMode = GLWallpaperService.RgbrnGLEngine.RENDERMODE_CONTINUOUSLY;
    mRenderer = renderer;
    this.mEGLConfigChooser = chooser;
    this.mEGLContextFactory = contextFactory;
    this.mEGLWindowSurfaceFactory = surfaceFactory;
    this.mGLWrapper = wrapper;
    this.mEGLContextClientVersion = eglContextClientVersion;
}

public void setRenderer(Renderer renderer) {
    checkRenderThreadState();
    if (mEGLConfigChooser == null) {
        mEGLConfigChooser = new SimpleEGLConfigChooser(true, mEGLContextClientVersion);
    }
    if (mEGLContextFactory == null) {
        mEGLContextFactory = new DefaultContextFactory();
    }
    if (mEGLWindowSurfaceFactory == null) {
        mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
    }
    mGLThread = new GLThread(renderer, mEGLConfigChooser,
            mEGLContextFactory, mEGLWindowSurfaceFactory, mGLWrapper,
            mEGLContextClientVersion);
    mGLThread.start();
}

GLThread(Renderer renderer, EGLConfigChooser chooser,
        EGLContextFactory contextFactory,
        EGLWindowSurfaceFactory surfaceFactory, GLWrapper wrapper,
        int eglContextClientVersion) {
    super();
    mDone = false;
    mWidth = 0;
    mHeight = 0;
    mRequestRender = true;
    mRenderMode = GLWallpaperService.GLEngine.RENDERMODE_CONTINUOUSLY;
    mRenderer = renderer;
    this.mEGLConfigChooser = chooser;
    this.mEGLContextFactory = contextFactory;
    this.mEGLWindowSurfaceFactory = surfaceFactory;
    this.mGLWrapper = wrapper;
    this.mEGLContextClientVersion = eglContextClientVersion;
}

/**
 * Constructs this object.
 * 
 * @param view the current glSurfaceView
 * @param renderer the renderer to wrap
 * @param latch the count down latch
 */

public GLRenderWrapper(GLSurfaceView view,
        Renderer renderer, CountDownLatch latch) {
    this.view = view;
    this.renderer = renderer;
    this.latch = latch;

    this.width = view.getWidth();
    this.height = view.getHeight();

    Integer out = new Reflect(view).field("mEGLContextClientVersion")
            .out(Integer.class);
    if ( out != null ) {
        this.glVersion = out.intValue();
    } else {
        this.glVersion = -1;
        this.takeScreenshot = false;
    }
}

/**
 * Constructs this object.
 * 
 * @param view the current glSurfaceView
 * @param renderer the renderer to wrap
 * @param latch the count down latch
 */

public GLRenderWrapper(GLSurfaceView view,
        Renderer renderer, CountDownLatch latch) {
    this.view = view;
    this.renderer = renderer;
    this.latch = latch;

    this.width = view.getWidth();
    this.height = view.getHeight();

    Integer out = new Reflect(view).field("mEGLContextClientVersion")
            .out(Integer.class);
    if ( out != null ) {
        this.glVersion = out.intValue();
    } else {
        this.glVersion = -1;
        this.takeScreenshot = false;
    }
}

public RendererHelper(CardboardView.Renderer renderer) {
    this.mRenderer = renderer;
    this.mHmd = new HeadMountedDisplay(CardboardView.this.mHmd);
    this.mHeadTransform = new HeadTransform();
    this.mMonocular = new EyeParams(0);
    this.mLeftEye = new EyeParams(1);
    this.mRightEye = new EyeParams(2);
    updateFieldOfView(this.mLeftEye.getFov(), this.mRightEye.getFov());
    CardboardView.this.mDistortionRenderer = new DistortionRenderer();

    this.mLeftEyeTranslate = new float[16];
    this.mRightEyeTranslate = new float[16];

    this.mVRMode = CardboardView.this.mVRMode;
    this.mDistortionCorrectionEnabled = CardboardView.this.mDistortionCorrectionEnabled;
    this.mDistortionCorrectionScale = CardboardView.this.mDistortionCorrectionScale;
    this.mZNear = CardboardView.this.mZNear;
    this.mZFar = CardboardView.this.mZFar;

    this.mProjectionChanged = true;
}

@Override
public void onDrawFrame(GL10 gl) {
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
    GLES20.glDisable(GLES20.GL_BLEND);
    com.qualcomm.vuforia.Renderer renderer = com.qualcomm.vuforia.Renderer
            .getInstance();
    State state = renderer.begin();
    renderer.drawVideoBackground();
    maybeCreateTrackable();
    if (state.getNumTrackableResults() > 0) {
        generateMvpMatrices(state);
        GLES20.glEnable(GLES20.GL_DEPTH_TEST);
        GLES20.glEnable(GLES20.GL_BLEND);
        texture.bindTexture();
        drawClip();
        drawBackground();
        drawFeature();
        drawWhite();
        drawDetails();
        drawStatus();
    }
    renderer.end();
}

public void setRenderer(Renderer renderer) {
    if (LoggerConfig.ON) {
        Log.d(TAG, "setRenderer(" + renderer + ")");
    }

    glSurfaceView.setRenderer(renderer);
    rendererHasBeenSet = true;
}

protected void setRenderer(Renderer renderer) {
    if (LoggerConfig.ON) {
        Log.d(TAG, "setRenderer(" + renderer + ")");
    }

    glSurfaceView.setRenderer(renderer);
    rendererHasBeenSet = true;
}

/**
 * {@inheritDoc}
 */
@Override
public void onDestroy() {
    if (DEBUG) Log.d(TAG, "onDestroy");
    super.onDestroy();
    for (Renderer renderer : mRenderers) {
        ((PhotoPhaseRenderer) renderer).onDestroy();
    }
}

/**
 * {@inheritDoc}
 */
@Override
public void onLowMemory() {
    super.onLowMemory();
    Log.i(TAG, "onLowMemory");
    for (Renderer renderer : mRenderers) {
        // Pause the wallpaper and destroy the cached textures
        ((PhotoPhaseRenderer) renderer).onPause();
        ((PhotoPhaseRenderer) renderer).onLowMemory();
    }
}

/**
 * {@inheritDoc}
 */
@Override
public void onDestroyEGLView(GLSurfaceView view, Renderer renderer) {
    if (DEBUG) Log.d(TAG, "onDestroyEGLView" + renderer);
    mRenderers.remove(renderer);
    ((PhotoPhaseRenderer)renderer).onPause();
    ((PhotoPhaseRenderer)renderer).onDestroy();
}

/**
 * {@inheritDoc}
 */
@Override
public Renderer getNewRenderer(GLSurfaceView view) {
    if (DEBUG) Log.d(TAG, "getNewRenderer()");
    PhotoPhaseRenderer renderer = new PhotoPhaseRenderer(this,
            new GLESSurfaceDispatcher(view), mEngine.isPreview());
    renderer.onCreate();
    mRenderers.add(renderer);
    if (DEBUG) Log.d(TAG, "renderer" + renderer);
    return renderer;
}

public void setRenderer(GLSurfaceView.Renderer paramRenderer)
{
  checkRenderThreadState();
  if (this.mEGLConfigChooser == null)
    this.mEGLConfigChooser = new GLBaseSurfaceView.SimpleEGLConfigChooser(true);
  if (this.mEGLContextFactory == null)
    this.mEGLContextFactory = new GLBaseSurfaceView.DefaultContextFactory();
  if (this.mEGLWindowSurfaceFactory == null)
    this.mEGLWindowSurfaceFactory = new GLBaseSurfaceView.DefaultWindowSurfaceFactory();
  this.mGLThread = new GLBaseSurfaceView.GLThread(this, paramRenderer);
  this.mGLThread.start();
}

@Override
Renderer getNewRenderer() {
    return new LessonThreeRenderer();
}

@Override
Renderer getNewRenderer() {
    return new LessonThreeRenderer();
}

@Override
Renderer getNewRenderer() {
    return new LessonThreeRenderer();
}

public void setRenderer(Renderer renderer) {
    if (mRenderThread != null) {
        throw new IllegalArgumentException("Renderer already set");
    }
    mRenderThread = new RenderThread(renderer);
}

public RenderThread(Renderer renderer) {
    super("RenderThread");
    mRenderer = renderer;
    start();
}

public void setRenderer(Renderer renderer) {
    if (mRenderThread != null) {
        throw new IllegalArgumentException("Renderer already set");
    }
    mRenderThread = new RenderThread(renderer);
}

public RenderThread(Renderer renderer) {
    super("RenderThread");
    mRenderer = renderer;
    start();
}

public void setRenderer(Renderer renderer) {
    if (mRenderThread != null) {
        throw new IllegalArgumentException("Renderer already set");
    }
    mRenderThread = new RenderThread(renderer);
}

public RenderThread(Renderer renderer) {
    super("RenderThread");
    mRenderer = renderer;
    start();
}

void setRenderer(Renderer renderer)
{
    puvoGLSurfaceView.setRenderer(renderer);
    preserveContext = (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB);
}

public void setRenderer(Renderer renderer) {
    if (mRenderThread != null) {
        throw new IllegalArgumentException("Renderer already set");
    }
    mRenderThread = new RenderThread(renderer);
}

public RenderThread(Renderer renderer) {
    super("RenderThread");
    mRenderer = renderer;
    start();
}

/**
 * Set the renderer associated with this view. Also starts the thread that
 * will call the renderer, which in turn causes the rendering to start.
 * <p>This method should be called once and only once in the life-cycle of
 * a GLSurfaceView.
 * <p>The following GLSurfaceView methods can only be called <em>before</em>
 * setRenderer is called:
 * <ul>
 * <li>{@link #setEGLConfigChooser(boolean)}
 * <li>{@link #setEGLConfigChooser(EGLConfigChooser)}
 * <li>{@link #setEGLConfigChooser(int, int, int, int, int, int)}
 * </ul>
 * <p>
 * The following GLSurfaceView methods can only be called <em>after</em>
 * setRenderer is called:
 * <ul>
 * <li>{@link #getRenderMode()}
 * <li>{@link #onPause()}
 * <li>{@link #onResume()}
 * <li>{@link #queueEvent(Runnable)}
 * <li>{@link #requestRender()}
 * <li>{@link #setRenderMode(int)}
 * </ul>
 *
 * @param renderer the renderer to use to perform OpenGL drawing.
 */
public void setRenderer(Renderer renderer) {
    checkRenderThreadState();
    if (mEGLConfigChooser == null) {
        mEGLConfigChooser = new SimpleEGLConfigChooser(true);
    }
    if (mEGLContextFactory == null) {
        mEGLContextFactory = new DefaultContextFactory();
    }
    if (mEGLWindowSurfaceFactory == null) {
        mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
    }
    mRenderer = renderer;
    mGLThread = new GLThread(mThisWeakRef);
    mGLThread.start();
}

public void setRenderer(Renderer renderer) {
    this.mRendererHelper = (renderer != null ? new RendererHelper(renderer)
            : null);
    super.setRenderer(this.mRendererHelper);
}

public void setRenderer(StereoRenderer renderer) {
    setRenderer(renderer != null ? new StereoRendererHelper(renderer)
            : (Renderer) null);
}

public void setRenderer(GLSurfaceView.Renderer renderer) {
    throw new RuntimeException(
            "Please use the CardboardView renderer interfaces");
}

@Override
public void setRenderer(Renderer renderer) {
    super.setRenderer(renderer);
    this.mRenderer = (MyRenderer)renderer;
}

/**
 * {@inheritDoc}
 */
@Override
public void onPause(Renderer renderer) {
    if (DEBUG) Log.d(TAG, "onPause: " + renderer);
    ((PhotoPhaseRenderer)renderer).onPause();
}

/**
 * {@inheritDoc}
 */
@Override
public void onResume(Renderer renderer) {
    if (DEBUG) Log.d(TAG, "onResume: " + renderer);
    ((PhotoPhaseRenderer)renderer).onResume();
}

public void setRenderer(GLSurfaceView.Renderer paramRenderer)
{
  if (this.mRenderer != null)
    throw new IllegalStateException("setRenderer has already been called for this instance.");
  this.mRenderer = paramRenderer;
}

GLBaseSurfaceView$GLThread(GLBaseSurfaceView paramGLBaseSurfaceView, GLSurfaceView.Renderer paramRenderer)
{
  this.mRenderer = paramRenderer;
}

GLSurfaceViewCupcake$GLThread(GLSurfaceViewCupcake paramGLSurfaceViewCupcake, GLSurfaceView.Renderer paramRenderer)
{
  this.mRenderer = paramRenderer;
  this.mSizeChanged = true;
  setName("GLThread");
}

/**
 * Method invoked when the EGL surface is recycled.
 *
 * @param view GLSurfaceView The EGL view
 * @param renderer The renderer associated
 */
void onDestroyEGLView(GLSurfaceView view, Renderer renderer);

/**
 * Method invoked when the EGL context is paused
 *
 * @param renderer The renderer associated
 */
void onPause(Renderer renderer);

/**
 * Method invoked when the EGL context is resumed
 *
 * @param renderer The renderer associated
 */
void onResume(Renderer renderer);