/* -*- 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_SHADERDEFINITIONSMLGPU_H

#define MOZILLA_GFX_SHADERDEFINITIONSMLGPU_H

#include "mozilla/gfx/Point.h"

#include "mozilla/gfx/Triangle.h"

#include "mozilla/gfx/Types.h"

#include "mozilla/layers/LayersHelpers.h"

#include "nsTArray.h"

namespace mozilla {

namespace layers {

struct ItemInfo;

class ShaderRenderPass;

namespace mlg {

// These may need to move into run-time values determined by MLGDevice.

static const size_t kConstantBufferElementSize = 16;

static const size_t kMaxConstantBufferSize = 4096 * kConstantBufferElementSize;

// Vertex shader slots. We reverse the first two slots across all shaders,

// and the first three slots free across all RenderPass shaders, for

// uniformity.

static const uint32_t kWorldConstantBufferSlot = 0;

static const uint32_t kLayerBufferSlot = 1;

static const uint32_t kMaskBufferSlot = 3;

static const uint32_t kBlendConstantBufferSlot = 4;

static const uint32_t kClearConstantBufferSlot = 2;

// This is specified in common-ps.hlsl.

static const uint32_t kMaskLayerTextureSlot = 4;

static const uint32_t kDefaultSamplerSlot = 0;

static const uint32_t kMaskSamplerSlot = 1;

// These are the maximum slot numbers we bind. We assert that no binding

// happens above the max slot, since we try to clear buffer bindings at

// the end of each frame.

static const uint32_t kMaxVertexShaderConstantBuffers = 5;

static const uint32_t kMaxPixelShaderConstantBuffers = 2;

// Maximum depth in the depth buffer. This must match common-vs.hlsl.

static const int32_t kDepthLimit = 1000000;

struct WorldConstants

{

  float projection[4][4];

  gfx::Point targetOffset;

  int sortIndexOffset;

  unsigned debugFrameNumber;

};

struct ClearConstants

{

  explicit ClearConstants(int aDepth) : depth(aDepth)

  {}

  int depth;

  int padding[3];

};

struct LayerConstants

{

  float transform[4][4];

  gfx::Rect clipRect;

  uint32_t maskIndex;

  uint32_t padding[3];

};

struct MaskCombineInput

{

  float texCoords[4];

};

struct MaskInformation

{

  MaskInformation(float aOpacity, bool aHasMask)

   : opacity(aOpacity),

     hasMask(aHasMask ? 1 : 0)

  {}

  float opacity;

  uint32_t hasMask;

  uint32_t padding[2];

};

struct YCbCrShaderConstants {

  float yuvColorMatrix[3][4];

};

struct BlendVertexShaderConstants {

  float backdropTransform[4][4];

};

template <typename T>

static inline nsTArray<gfx::IntRect>

ToRectArray(const T& aRegion)

{

  nsTArray<gfx::IntRect> rects;

  for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {

    rects.AppendElement(iter.Get().ToUnknownRect());

  }

  return rects;

}

Unexecuted instantiation: Unified_cpp_gfx_layers10.cpp:nsTArray<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> > mozilla::layers::mlg::ToRectArray<mozilla::gfx::IntRegionTyped<mozilla::LayerPixel> >(mozilla::gfx::IntRegionTyped<mozilla::LayerPixel> const&)

Unexecuted instantiation: Unified_cpp_gfx_layers10.cpp:nsTArray<mozilla::gfx::IntRectTyped<mozilla::gfx::UnknownUnits> > mozilla::layers::mlg::ToRectArray<mozilla::gfx::IntRegionTyped<mozilla::gfx::UnknownUnits> >(mozilla::gfx::IntRegionTyped<mozilla::gfx::UnknownUnits> const&)

struct SimpleTraits

{

  explicit SimpleTraits(const ItemInfo& aItem, const gfx::Rect& aRect)

   : mItem(aItem),

     mRect(aRect)

  {}

  // Helper nonce structs so functions can break vertex data up by each

  // triangle in a quad, or return vertex info for a unit quad.

  struct AnyTriangle { };

  struct FirstTriangle : AnyTriangle { };

  struct SecondTriangle : AnyTriangle { };

  struct UnitQuad { };

  // This is the base vertex layout used by all unit quad shaders.

  struct UnitQuadVertex {

    gfx::Rect rect;

    uint32_t layerIndex;

    int depth;

  };

  // This is the base vertex layout used by all unit triangle shaders.

  struct TriangleVertices {

    gfx::Point p1, p2, p3;

    uint32_t layerIndex;

    int depth;

  };

  // Helper functions for populating a TriangleVertices. The first two use mRect

  // to generate triangles, the third function uses coordinates from an already

  // computed triangle.

  TriangleVertices MakeVertex(const FirstTriangle& aIgnore) const;

  TriangleVertices MakeVertex(const SecondTriangle& aIgnore) const;

  TriangleVertices MakeVertex(const gfx::Triangle& aTriangle) const;

  UnitQuadVertex MakeUnitQuadVertex() const;

  // This default GenerateTriangles only computes the 3 points of each triangle

  // in the polygon. If needed, shaders can override this and return a more

  // complex triangle, to encode dependent information in extended vertex data.

  //

  // AddShaderVertices will deduce this return type. It should be an nsTArray<T>

  // where T inherits from Triangle.

  nsTArray<gfx::Triangle> GenerateTriangles(const gfx::Polygon& aPolygon) const;

  // Accessors.

  const Maybe<gfx::Polygon>& geometry() const;

  const gfx::Rect& rect() const {

    return mRect;

  }

  const ItemInfo& mItem;

  gfx::Rect mRect;

};

struct ColorTraits : public SimpleTraits

{

  ColorTraits(const ItemInfo& aItem, const gfx::Rect& aRect, const gfx::Color& aColor)

   : SimpleTraits(aItem, aRect), mColor(aColor)

  {}

  // Color data is the same across all vertex types.

  template <typename VertexType>

  const gfx::Color& MakeVertexData(const VertexType& aIgnore) const {

    return mColor;

  }

Unexecuted instantiation: mozilla::gfx::Color const& mozilla::layers::mlg::ColorTraits::MakeVertexData<mozilla::layers::mlg::SimpleTraits::FirstTriangle>(mozilla::layers::mlg::SimpleTraits::FirstTriangle const&) const

Unexecuted instantiation: mozilla::gfx::Color const& mozilla::layers::mlg::ColorTraits::MakeVertexData<mozilla::layers::mlg::SimpleTraits::SecondTriangle>(mozilla::layers::mlg::SimpleTraits::SecondTriangle const&) const

Unexecuted instantiation: mozilla::gfx::Color const& mozilla::layers::mlg::ColorTraits::MakeVertexData<mozilla::gfx::TriangleTyped<mozilla::gfx::UnknownUnits, float> >(mozilla::gfx::TriangleTyped<mozilla::gfx::UnknownUnits, float> const&) const

Unexecuted instantiation: mozilla::gfx::Color const& mozilla::layers::mlg::ColorTraits::MakeVertexData<mozilla::layers::mlg::SimpleTraits::UnitQuad>(mozilla::layers::mlg::SimpleTraits::UnitQuad const&) const

  gfx::Color mColor;

};

struct TexturedTraits : public SimpleTraits

{

  TexturedTraits(const ItemInfo& aItem, const gfx::Rect& aRect, const gfx::Rect& aTexCoords)

   : SimpleTraits(aItem, aRect), mTexCoords(aTexCoords)

  {}

  // Textured triangles need to compute a texture coordinate for each vertex.

  nsTArray<gfx::TexturedTriangle> GenerateTriangles(const gfx::Polygon& aPolygon) const;

  struct VertexData {

    gfx::Point p1, p2, p3;

  };

  VertexData MakeVertexData(const FirstTriangle& aIgnore) const;

  VertexData MakeVertexData(const SecondTriangle& aIgnore) const;

  VertexData MakeVertexData(const gfx::TexturedTriangle& aTriangle) const;

  const gfx::Rect& MakeVertexData(const UnitQuad& aIgnore) const {

    return mTexCoords;

  }

  gfx::Rect mTexCoords;

};

} // namespace mlg

} // namespace layers

} // namespace mozilla

#endif