Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 84a4c887 authored by John Reck's avatar John Reck
Browse files

Remove GLRenderer

Change-Id: I180286417c1a354fc7eb1eadb1884ac6add0795c
parent c7ad12f4
Loading
Loading
Loading
Loading
+4 −110
Original line number Diff line number Diff line
@@ -75,22 +75,10 @@ class GLES20Canvas extends HardwareCanvas {
    // Constructors
    ///////////////////////////////////////////////////////////////////////////

    /**
     * Creates a canvas to render directly on screen.
     */
    GLES20Canvas(boolean translucent) {
        this(false, translucent);
    }
    
    protected GLES20Canvas(boolean record, boolean translucent) {
        mOpaque = !translucent;

        if (record) {
    // TODO: Merge with GLES20RecordingCanvas
    protected GLES20Canvas() {
        mOpaque = false;
        mRenderer = nCreateDisplayListRenderer();
        } else {
            mRenderer = nCreateRenderer();
        }

        setupFinalizer();
    }

@@ -102,7 +90,6 @@ class GLES20Canvas extends HardwareCanvas {
        }
    }

    private static native long nCreateRenderer();
    private static native long nCreateDisplayListRenderer();
    private static native void nResetDisplayListRenderer(long renderer);
    private static native void nDestroyRenderer(long renderer);
@@ -130,36 +117,6 @@ class GLES20Canvas extends HardwareCanvas {

    private static native void nSetProperty(String name, String value);

    ///////////////////////////////////////////////////////////////////////////
    // Hardware layers
    ///////////////////////////////////////////////////////////////////////////

    @Override
    void pushLayerUpdate(HardwareLayer layer) {
        nPushLayerUpdate(mRenderer, layer.getLayer());
    }

    @Override
    void cancelLayerUpdate(HardwareLayer layer) {
        nCancelLayerUpdate(mRenderer, layer.getLayer());
    }

    @Override
    void flushLayerUpdates() {
        nFlushLayerUpdates(mRenderer);
    }

    @Override
    void clearLayerUpdates() {
        nClearLayerUpdates(mRenderer);
    }

    static native boolean nCopyLayer(long layerId, long bitmap);
    private static native void nClearLayerUpdates(long renderer);
    private static native void nFlushLayerUpdates(long renderer);
    private static native void nPushLayerUpdate(long renderer, long layer);
    private static native void nCancelLayerUpdate(long renderer, long layer);

    ///////////////////////////////////////////////////////////////////////////
    // Canvas management
    ///////////////////////////////////////////////////////////////////////////
@@ -234,20 +191,6 @@ class GLES20Canvas extends HardwareCanvas {

    private static native void nFinish(long renderer);

    /**
     * Returns the size of the stencil buffer required by the underlying
     * implementation.
     * 
     * @return The minimum number of bits the stencil buffer must. Always >= 0.
     * 
     * @hide
     */
    public static int getStencilSize() {
        return nGetStencilSize();
    }

    private static native int nGetStencilSize();

    ///////////////////////////////////////////////////////////////////////////
    // Functor
    ///////////////////////////////////////////////////////////////////////////
@@ -284,49 +227,6 @@ class GLES20Canvas extends HardwareCanvas {
     */
    static final int FLUSH_CACHES_FULL = 2;

    /**
     * Flush caches to reclaim as much memory as possible. The amount of memory
     * to reclaim is indicate by the level parameter.
     * 
     * The level can be one of {@link #FLUSH_CACHES_MODERATE} or
     * {@link #FLUSH_CACHES_FULL}.
     * 
     * @param level Hint about the amount of memory to reclaim
     */
    static void flushCaches(int level) {
        nFlushCaches(level);
    }

    private static native void nFlushCaches(int level);

    /**
     * Release all resources associated with the underlying caches. This should
     * only be called after a full flushCaches().
     * 
     * @hide
     */
    static void terminateCaches() {
        nTerminateCaches();
    }

    private static native void nTerminateCaches();

    static boolean initCaches() {
        return nInitCaches();
    }

    private static native boolean nInitCaches();

    ///////////////////////////////////////////////////////////////////////////
    // Atlas
    ///////////////////////////////////////////////////////////////////////////

    static void initAtlas(GraphicBuffer buffer, long[] map) {
        nInitAtlas(buffer, map, map.length);
    }

    private static native void nInitAtlas(GraphicBuffer buffer, long[] map, int count);

    ///////////////////////////////////////////////////////////////////////////
    // Display list
    ///////////////////////////////////////////////////////////////////////////
@@ -899,12 +799,6 @@ class GLES20Canvas extends HardwareCanvas {
    private static native void nDrawPath(long renderer, long path, long paint);
    private static native void nDrawRects(long renderer, long region, long paint);

    void drawRects(float[] rects, int count, Paint paint) {
        nDrawRects(mRenderer, rects, count, paint.mNativePaint);
    }

    private static native void nDrawRects(long renderer, float[] rects, int count, long paint);

    @Override
    public void drawPicture(Picture picture) {
        if (picture.createdFromStream) {
+1 −1
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ class GLES20RecordingCanvas extends GLES20Canvas {
    RenderNode mNode;

    private GLES20RecordingCanvas() {
        super(true, true);
        super();
    }

    static GLES20RecordingCanvas obtain(@NonNull RenderNode node) {
+0 −1521

File deleted.

Preview size limit exceeded, changes collapsed.

+0 −42
Original line number Diff line number Diff line
@@ -110,48 +110,6 @@ public abstract class HardwareCanvas extends Canvas {
        return RenderNode.STATUS_DONE;
    }

    /**
     * Indicates that the specified layer must be updated as soon as possible.
     *
     * @param layer The layer to update
     *
     * @see #clearLayerUpdates()
     *
     * @hide
     */
    abstract void pushLayerUpdate(HardwareLayer layer);

    /**
     * Cancels a queued layer update. If the specified layer was not
     * queued for update, this method has no effect.
     *
     * @param layer The layer whose update to cancel
     *
     * @see #pushLayerUpdate(HardwareLayer)
     * @see #clearLayerUpdates()
     *
     * @hide
     */
    abstract void cancelLayerUpdate(HardwareLayer layer);

    /**
     * Immediately executes all enqueued layer updates.
     *
     * @see #pushLayerUpdate(HardwareLayer)
     *
     * @hide
     */
    abstract void flushLayerUpdates();

    /**
     * Removes all enqueued layer updates.
     *
     * @see #pushLayerUpdate(HardwareLayer)
     *
     * @hide
     */
    abstract void clearLayerUpdates();

    public abstract void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,
            CanvasProperty<Float> radius, CanvasProperty<Paint> paint);
}
+0 −37
Original line number Diff line number Diff line
@@ -172,24 +172,6 @@ final class HardwareLayer {
        });
    }

    /**
     * This exists to minimize impact into the current HardwareLayer paths as
     * some of the specifics of how to handle error cases in the fully
     * deferred model will work
     */
    @Deprecated
    public void flushChanges() {
        if (HardwareRenderer.sUseRenderThread) {
            // Not supported, don't try.
            return;
        }

        boolean success = nFlushChanges(mFinalizer.get());
        if (!success) {
            destroy();
        }
    }

    public long getLayer() {
        return nGetLayer(mFinalizer.get());
    }
@@ -216,33 +198,14 @@ final class HardwareLayer {
        return st;
    }

    /**
     * This should only be used by HardwareRenderer! Do not call directly
     */
    static HardwareLayer createTextureLayer(HardwareRenderer renderer) {
        return new HardwareLayer(renderer, nCreateTextureLayer(), LAYER_TYPE_TEXTURE);
    }

    static HardwareLayer adoptTextureLayer(HardwareRenderer renderer, long layer) {
        return new HardwareLayer(renderer, layer, LAYER_TYPE_TEXTURE);
    }

    /**
     * This should only be used by HardwareRenderer! Do not call directly
     */
    static HardwareLayer createDisplayListLayer(HardwareRenderer renderer,
            int width, int height) {
        return new HardwareLayer(renderer, nCreateRenderLayer(width, height), LAYER_TYPE_DISPLAY_LIST);
    }

    static HardwareLayer adoptDisplayListLayer(HardwareRenderer renderer, long layer) {
        return new HardwareLayer(renderer, layer, LAYER_TYPE_DISPLAY_LIST);
    }

    /** This also creates the underlying layer */
    private static native long nCreateTextureLayer();
    private static native long nCreateRenderLayer(int width, int height);

    private static native void nOnTextureDestroyed(long layerUpdater);

    private static native boolean nPrepare(long layerUpdater, int width, int height, boolean isOpaque);
Loading