DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (95ddb3213aec)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
/* -*- 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_RenderViewMLGPU_h
#define mozilla_gfx_layers_mlgpu_RenderViewMLGPU_h

#include "LayerManagerMLGPU.h"
#include "ClearRegionHelper.h"
#include "RenderPassMLGPU.h"
#include "Units.h"
#include <deque>

namespace mozilla {
namespace layers {

class FrameBuilder;
class ContainerLayerMLGPU;
class MLGRenderTarget;

class RenderViewMLGPU {
 public:
  NS_INLINE_DECL_REFCOUNTING(RenderViewMLGPU)

  // Constructor for the widget render target.
  RenderViewMLGPU(FrameBuilder* aBuilder, MLGRenderTarget* aTarget,
                  const nsIntRegion& aInvalidRegion);

  // Constructor for intermediate surfaces.
  RenderViewMLGPU(FrameBuilder* aBuilder, ContainerLayerMLGPU* aContainer,
                  RenderViewMLGPU* aParent);

  void Prepare();
  void Render();
  void AddChild(RenderViewMLGPU* aParent);
  void AddItem(LayerMLGPU* aItem, const gfx::IntRect& aBounds,
               Maybe<gfx::Polygon>&& aGeometry);
  void FinishBuilding();

  const gfx::IntPoint& GetTargetOffset() const { return mTargetOffset; }
  RenderViewMLGPU* GetParent() const { return mParent; }
  bool HasDepthBuffer() const { return mUseDepthBuffer; }

  // Render after having previously delayed rendering due to the view
  // requiring a backdrop copy.
  void RenderAfterBackdropCopy();
  void RestoreDeviceState();

  // The size and render target cannot be read until the view has finished
  // building, since we try to right-size the render target to the visible
  // region.
  MLGRenderTarget* GetRenderTarget() const;
  gfx::IntSize GetSize() const;

  gfx::IntRect GetInvalidRect() const { return mInvalidBounds; }

 private:
  RenderViewMLGPU(FrameBuilder* aBuilder, RenderViewMLGPU* aParent);
  ~RenderViewMLGPU();

  void ExecuteRendering();
  bool UpdateVisibleRegion(ItemInfo& aItem);
  void AddItemFrontToBack(LayerMLGPU* aLayer, ItemInfo& aItem);
  void AddItemBackToFront(LayerMLGPU* aLayer, ItemInfo& aItem);

  void PrepareClears();
  void SetDeviceState();
  void SetDepthTestMode(MLGDepthTestMode aMode);

  void ExecutePass(RenderPassMLGPU* aPass);

  // Return the sorting index offset to use.
  int32_t PrepareDepthBuffer();

 private:
  std::deque<RefPtr<RenderPassMLGPU>> mFrontToBack;
  std::deque<RefPtr<RenderPassMLGPU>> mBackToFront;

  FrameBuilder* mBuilder;
  RefPtr<MLGDevice> mDevice;
  RenderViewMLGPU* mParent;
  std::vector<RefPtr<RenderViewMLGPU>> mChildren;

  // Shader data.
  ConstantBufferSection mWorldConstants;

  // Information for the initial target surface clear. This covers the area that
  // won't be occluded by opaque content.
  ClearRegionHelper mPreClear;

  // The post-clear region, that must be cleared after all drawing is done.
  nsIntRegion mPostClearRegion;
  ClearRegionHelper mPostClear;

  // Either an MLGSwapChain-derived render target, or an intermediate surface.
  RefPtr<MLGRenderTarget> mTarget;

  // For intermediate render targets only, this is the layer owning the render
  // target.
  ContainerLayerMLGPU* mContainer;

  // The offset adjustment from container layer space to render target space.
  // This is 0,0 for the root view.
  gfx::IntPoint mTargetOffset;

  // The invalid bounds as computed by LayerTreeInvalidation. This is the
  // initial render bounds size, if invalidation is disabled.
  gfx::IntRect mInvalidBounds;

  // The occluded region, which is updated every time we process an opaque,
  // rectangular item. This is not actually in LayerPixels, we do this to
  // avoid FromUnknownRegion which has array copies.
  LayerIntRegion mOccludedRegion;

  // True if we've finished adding layers to the view.
  bool mFinishedBuilding;

  // This state is used to avoid changing buffers while we execute batches.
  size_t mCurrentLayerBufferIndex;
  size_t mCurrentMaskRectBufferIndex;

  // This state is saved locally so it can be restored in RestoreDeviceState.
  MLGDepthTestMode mCurrentDepthMode;

  // Depth-buffer tracking.
  int32_t mNextSortIndex;
  bool mUseDepthBuffer;
  bool mDepthBufferNeedsClear;
};

}  // namespace layers
}  // namespace mozilla

#endif  // mozilla_gfx_layers_mlgpu_RenderViewMLGPU_h