/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_gfx_layers_mlgpu_FrameBuilder_h

#define mozilla_gfx_layers_mlgpu_FrameBuilder_h

#include "mozilla/RefPtr.h"

#include "mozilla/gfx/Point.h"

#include "mozilla/gfx/Types.h"

#include "MaskOperation.h"

#include "MLGDevice.h"

#include "nsDataHashtable.h"

#include "nsRefPtrHashtable.h"

#include "ShaderDefinitionsMLGPU.h"

#include "SharedBufferMLGPU.h"

#include "Units.h"

#include <map>

#include <vector>

namespace mozilla {

namespace layers {

class ContainerLayer;

class ContainerLayerMLGPU;

class Layer;

class LayerMLGPU;

class LayerManagerMLGPU;

class MLGDevice;

class MLGRenderTarget;

class MLGSwapChain;

class RenderViewMLGPU;

struct ItemInfo;

class FrameBuilder final

{

public:

  FrameBuilder(LayerManagerMLGPU* aManager, MLGSwapChain* aSwapChain);

  ~FrameBuilder();

  bool Build();

  void Render();

  bool AddLayerToConstantBuffer(ItemInfo& aItem);

  LayerManagerMLGPU* GetManager() const {

    return mManager;

  }

  MLGDevice* GetDevice() const {

    return mDevice;

  }

  const ConstantBufferSection& GetDefaultMaskInfo() const {

    return mDefaultMaskInfo;

  }

  // Called during tile construction. Finds or adds a mask layer chain to the

  // cache, that will be flattened as a dependency to rendering batches.

  MaskOperation* AddMaskOperation(LayerMLGPU* aLayer);

  // Note: These should only be called during batch construction.

  size_t CurrentLayerBufferIndex() const;

  size_t CurrentMaskRectBufferIndex() const;

  // These are called during rendering, and may return null if a buffer

  // couldn't be allocated.

  ConstantBufferSection GetLayerBufferByIndex(size_t aIndex) const;

  ConstantBufferSection GetMaskRectBufferByIndex(size_t aIndex) const;

  // Hold a layer alive until the frame ends.

  void RetainTemporaryLayer(LayerMLGPU* aLayer);

private:

  void AssignLayer(Layer* aLayer,

                   RenderViewMLGPU* aView,

                   const RenderTargetIntRect& aClipRect,

                   Maybe<gfx::Polygon>&& aGeometry);

  void ProcessChildList(ContainerLayer* aContainer,

                        RenderViewMLGPU* aView,

                        const RenderTargetIntRect& aParentClipRect,

                        const Maybe<gfx::Polygon>& aParentGeometry);

  mlg::LayerConstants* AllocateLayerInfo(ItemInfo& aItem);

  bool AddMaskRect(const gfx::Rect& aRect, uint32_t* aOutIndex);

  void FinishCurrentLayerBuffer();

  void FinishCurrentMaskRectBuffer();

  // Returns true to continue, false to stop - false does not indicate

  // failure.

  bool ProcessContainerLayer(ContainerLayer* aLayer,

                             RenderViewMLGPU* aView,

                             const RenderTargetIntRect& aClipRect,

                             Maybe<gfx::Polygon>& aGeometry);

private:

  RefPtr<LayerManagerMLGPU> mManager;

  RefPtr<MLGDevice> mDevice;

  RefPtr<MLGSwapChain> mSwapChain;

  RefPtr<RenderViewMLGPU> mWidgetRenderView;

  LayerMLGPU* mRoot;

  // Each time we consume a layer in a tile, we make sure a constant buffer

  // exists that contains information about the layer. The mapping is valid

  // for the most recent buffer, and once the buffer fills, we begin a new

  // one and clear the map.

  nsTArray<ConstantBufferSection> mLayerBuffers;

  nsTArray<mlg::LayerConstants> mCurrentLayerBuffer;

  nsDataHashtable<nsPtrHashKey<LayerMLGPU>, uint32_t> mLayerBufferMap;

  // We keep mask rects in a separate buffer since they're rare.

  nsTArray<ConstantBufferSection> mMaskRectBuffers;

  nsTArray<gfx::Rect> mCurrentMaskRectList;

  // For values that *can* change every render pass, but almost certainly do

  // not, we pre-fill and cache some buffers.

  ConstantBufferSection mDefaultMaskInfo;

  // Cache for MaskOperations.

  nsRefPtrHashtable<nsRefPtrHashKey<TextureSource>, MaskOperation> mSingleTextureMasks;

  std::map<MaskTextureList, RefPtr<MaskCombineOperation>> mCombinedTextureMasks;

  // This list of temporary layers is wiped out when the frame is completed.

  std::vector<RefPtr<Layer>> mTemporaryLayers;

};

} // namespace layers

} // namespace mozilla

#endif // mozilla_gfx_layers_mlgpu_FrameBuilder_h