[RenderEngine] Organize RenderEngine directory.

        mRefreshPending(false) {

    ALOGV("Creating Layer %s", name.string());

    mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName);

    mTexture.init(renderengine::Texture::TEXTURE_EXTERNAL, mTextureName);

    mPremultipliedAlpha = !(flags & ISurfaceComposerClient::eNonPremultiplied);

    // TODO: we probably want to generate the texture coords with the mesh

    // here we assume that we only have 4 vertices

    Mesh::VertexArray<vec2> texCoords(getBE().mMesh.getTexCoordArray<vec2>());

    renderengine::Mesh::VertexArray<vec2> texCoords(getBE().mMesh.getTexCoordArray<vec2>());

    texCoords[0] = vec2(left, 1.0f - top);

    texCoords[1] = vec2(left, 1.0f - bottom);

    texCoords[2] = vec2(right, 1.0f - bottom);

    bool mBufferLatched; // TODO: Use mActiveBuffer?

    // The texture used to draw the layer in GLES composition mode

    mutable Texture mTexture;

    mutable renderengine::Texture mTexture;

    bool mRefreshPending;

};

static const mat4 mtxIdentity;

BufferLayerConsumer::BufferLayerConsumer(const sp<IGraphicBufferConsumer>& bq,

                                         RE::RenderEngine& engine, uint32_t tex, Layer* layer)

                                         renderengine::RenderEngine& engine, uint32_t tex,

                                         Layer* layer)

      : ConsumerBase(bq, false),

        mCurrentCrop(Rect::EMPTY_RECT),

        mCurrentTransform(0),

    ConsumerBase::dumpLocked(result, prefix);

}

BufferLayerConsumer::Image::Image(sp<GraphicBuffer> graphicBuffer, RE::RenderEngine& engine)

BufferLayerConsumer::Image::Image(sp<GraphicBuffer> graphicBuffer,

                                  renderengine::RenderEngine& engine)

      : mGraphicBuffer(graphicBuffer),

        mImage{engine.createImage()},

        mCreated(false),

class Layer;

class String8;

namespace RE {

namespace renderengine {

class RenderEngine;

class Image;

} // namespace RE

} // namespace renderengine

/*

 * BufferLayerConsumer consumes buffers of graphics data from a BufferQueue,

    // BufferLayerConsumer constructs a new BufferLayerConsumer object.  The

    // tex parameter indicates the name of the RenderEngine texture to which

    // images are to be streamed.

    BufferLayerConsumer(const sp<IGraphicBufferConsumer>& bq, RE::RenderEngine& engine,

    BufferLayerConsumer(const sp<IGraphicBufferConsumer>& bq, renderengine::RenderEngine& engine,

                        uint32_t tex, Layer* layer);

    // Sets the contents changed listener. This should be used instead of

    status_t bindTextureImageLocked();

private:

    // Image is a utility class for tracking and creating RE::Images. There

    // Image is a utility class for tracking and creating renderengine::Images. There

    // is primarily just one image per slot, but there is also special cases:

    //  - After freeBuffer, we must still keep the current image/buffer

    // Reference counting RE::Images lets us handle all these cases easily while

    // also only creating new RE::Images from buffers when required.

    // Reference counting renderengine::Images lets us handle all these cases easily while

    // also only creating new renderengine::Images from buffers when required.

    class Image : public LightRefBase<Image> {

    public:

        Image(sp<GraphicBuffer> graphicBuffer, RE::RenderEngine& engine);

        Image(sp<GraphicBuffer> graphicBuffer, renderengine::RenderEngine& engine);

        Image(const Image& rhs) = delete;

        Image& operator=(const Image& rhs) = delete;

        // createIfNeeded creates an RE::Image if we haven't created one yet.

        // createIfNeeded creates an renderengine::Image if we haven't created one yet.

        status_t createIfNeeded();

        const sp<GraphicBuffer>& graphicBuffer() { return mGraphicBuffer; }

            return mGraphicBuffer == nullptr ? nullptr : mGraphicBuffer->handle;

        }

        const RE::Image& image() const { return *mImage; }

        const renderengine::Image& image() const { return *mImage; }

    private:

        // Only allow instantiation using ref counting.

        sp<GraphicBuffer> mGraphicBuffer;

        // mImage is the image created from mGraphicBuffer.

        std::unique_ptr<RE::Image> mImage;

        std::unique_ptr<renderengine::Image> mImage;

        bool mCreated;

        int32_t mCropWidth;

        int32_t mCropHeight;

    // freeBufferLocked frees up the given buffer slot. If the slot has been

    // initialized this will release the reference to the GraphicBuffer in

    // that slot and destroy the RE::Image in that slot.  Otherwise it has no

    // that slot and destroy the renderengine::Image in that slot.  Otherwise it has no

    // effect.

    //

    // This method must be called with mMutex locked.

    // setFilteringEnabled().

    bool mFilteringEnabled;

    RE::RenderEngine& mRE;

    renderengine::RenderEngine& mRE;

    // mTexName is the name of the RenderEngine texture to which streamed

    // images will be bound when bindTexImage is called. It is set at

private:

    void onFirstRef() override;

    std::unique_ptr<RE::Image> mTextureImage;

    std::unique_ptr<renderengine::Image> mTextureImage;

    std::array<float, 16> mTransformMatrix;