gfx/layers/Effects.h

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2 * This Source Code Form is subject to the terms of the Mozilla Public
   3 * License, v. 2.0. If a copy of the MPL was not distributed with this
   4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef MOZILLA_LAYERS_EFFECTS_H
   7 #define MOZILLA_LAYERS_EFFECTS_H
   8
   9 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
  10 #include "mozilla/RefPtr.h"             // for RefPtr, TemporaryRef, etc
  11 #include "mozilla/gfx/Matrix.h"         // for Matrix4x4
  12 #include "mozilla/gfx/Point.h"          // for IntSize
  13 #include "mozilla/gfx/Rect.h"           // for Rect
  14 #include "mozilla/gfx/Types.h"          // for Filter, etc
  15 #include "mozilla/layers/CompositorTypes.h"  // for EffectTypes, etc
  16 #include "mozilla/layers/LayersTypes.h"
  17 #include "mozilla/layers/TextureHost.h"  // for CompositingRenderTarget, etc
  18 #include "mozilla/mozalloc.h"           // for operator delete, etc
  19 #include "nscore.h"                     // for nsACString
  20 #include "mozilla/EnumeratedArray.h"
  21 #include "gfxVR.h"
  22
  23 namespace mozilla {
  24 namespace layers {
  25
  26 /**
  27  * Effects and effect chains are used by the compositor API (see Compositor.h).
  28  * An effect chain represents a rendering method, for example some shader and
  29  * the data required for that shader to run. An effect is some component of the
  30  * chain and its data.
  31  *
  32  * An effect chain consists of a primary effect - how the 'texture' memory should
  33  * be interpreted (RGBA, BGRX, YCBCR, etc.) - and any number of secondary effects
  34  * - any way in which rendering can be changed, e.g., applying a mask layer.
  35  *
  36  * During the rendering process, an effect chain is created by the layer being
  37  * rendered and the primary effect is added by the compositable host. Secondary
  38  * effects may be added by the layer or compositable. The effect chain is passed
  39  * to the compositor by the compositable host as a parameter to DrawQuad.
  40  */
  41
  42 struct Effect
  43 {
  44   NS_INLINE_DECL_REFCOUNTING(Effect)
  45
  46   explicit Effect(EffectTypes aType) : mType(aType) {}
  47
  48   EffectTypes mType;
  49
  50   virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) = 0;
  51
  52 protected:
  53   virtual ~Effect() {}
  54 };
  55
  56 // Render from a texture
  57 struct TexturedEffect : public Effect
  58 {
  59   TexturedEffect(EffectTypes aType,
  60                  TextureSource *aTexture,
  61                  bool aPremultiplied,
  62                  gfx::Filter aFilter)
  63      : Effect(aType)
  64      , mTextureCoords(0, 0, 1.0f, 1.0f)
  65      , mTexture(aTexture)
  66      , mPremultiplied(aPremultiplied)
  67      , mFilter(aFilter)
  68   {}
  69
  70   virtual const char* Name() = 0;
  71   virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
  72
  73   gfx::Rect mTextureCoords;
  74   TextureSource* mTexture;
  75   bool mPremultiplied;
  76   gfx::Filter mFilter;
  77 };
  78
  79 // Support an alpha mask.
  80 struct EffectMask : public Effect
  81 {
  82   EffectMask(TextureSource *aMaskTexture,
  83              gfx::IntSize aSize,
  84              const gfx::Matrix4x4 &aMaskTransform)
  85     : Effect(EffectTypes::MASK)
  86     , mMaskTexture(aMaskTexture)
  87     , mIs3D(false)
  88     , mSize(aSize)
  89     , mMaskTransform(aMaskTransform)
  90   {}
  91
  92   virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
  93
  94   TextureSource* mMaskTexture;
  95   bool mIs3D;
  96   gfx::IntSize mSize;
  97   gfx::Matrix4x4 mMaskTransform;
  98 };
  99
 100 struct EffectVRDistortion : public Effect
 101 {
 102   EffectVRDistortion(gfx::VRHMDInfo* aHMD,
 103                      CompositingRenderTarget* aRenderTarget)
 104     : Effect(EffectTypes::VR_DISTORTION)
 105     , mHMD(aHMD)
 106     , mRenderTarget(aRenderTarget)
 107     , mTexture(aRenderTarget)
 108   {}
 109
 110   EffectVRDistortion(gfx::VRHMDInfo* aHMD,
 111                      TextureSource* aTexture)
 112     : Effect(EffectTypes::VR_DISTORTION)
 113     , mHMD(aHMD)
 114     , mRenderTarget(nullptr)
 115     , mTexture(aTexture)
 116   {}
 117
 118   virtual const char* Name() { return "EffectVRDistortion"; }
 119   virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
 120
 121   nsRefPtr<gfx::VRHMDInfo> mHMD;
 122   RefPtr<CompositingRenderTarget> mRenderTarget;
 123   TextureSource* mTexture;
 124
 125   // The viewport for each eye in the source and
 126   // destination textures.
 127   gfx::IntRect mViewports[2];
 128 };
 129
 130 struct EffectBlendMode : public Effect
 131 {
 132   explicit EffectBlendMode(gfx::CompositionOp aBlendMode)
 133     : Effect(EffectTypes::BLEND_MODE)
 134     , mBlendMode(aBlendMode)
 135   { }
 136
 137   virtual const char* Name() { return "EffectBlendMode"; }
 138   virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
 139
 140   gfx::CompositionOp mBlendMode;
 141 };
 142
 143 // Render to a render target rather than the screen.
 144 struct EffectRenderTarget : public TexturedEffect
 145 {
 146   explicit EffectRenderTarget(CompositingRenderTarget *aRenderTarget)
 147     : TexturedEffect(EffectTypes::RENDER_TARGET, aRenderTarget, true, gfx::Filter::LINEAR)
 148     , mRenderTarget(aRenderTarget)
 149   {}
 150
 151   virtual const char* Name() { return "EffectRenderTarget"; }
 152   virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
 153
 154   RefPtr<CompositingRenderTarget> mRenderTarget;
 155
 156 protected:
 157   EffectRenderTarget(EffectTypes aType, CompositingRenderTarget *aRenderTarget)
 158     : TexturedEffect(aType, aRenderTarget, true, gfx::Filter::LINEAR)
 159     , mRenderTarget(aRenderTarget)
 160   {}
 161
 162 };
 163
 164 // Render to a render target rather than the screen.
 165 struct EffectColorMatrix : public Effect
 166 {
 167   explicit EffectColorMatrix(gfx::Matrix5x4 aMatrix)
 168     : Effect(EffectTypes::COLOR_MATRIX)
 169     , mColorMatrix(aMatrix)
 170   {}
 171
 172   virtual const char* Name() { return "EffectColorMatrix"; }
 173   virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
 174   const gfx::Matrix5x4 mColorMatrix;
 175 };
 176
 177
 178 struct EffectRGB : public TexturedEffect
 179 {
 180   EffectRGB(TextureSource *aTexture,
 181             bool aPremultiplied,
 182             gfx::Filter aFilter,
 183             bool aFlipped = false)
 184     : TexturedEffect(EffectTypes::RGB, aTexture, aPremultiplied, aFilter)
 185   {}
 186
 187   virtual const char* Name() { return "EffectRGB"; }
 188 };
 189
 190 struct EffectYCbCr : public TexturedEffect
 191 {
 192   EffectYCbCr(TextureSource *aSource, gfx::Filter aFilter)
 193     : TexturedEffect(EffectTypes::YCBCR, aSource, false, aFilter)
 194   {}
 195
 196   virtual const char* Name() { return "EffectYCbCr"; }
 197 };
 198
 199 struct EffectComponentAlpha : public TexturedEffect
 200 {
 201   EffectComponentAlpha(TextureSource *aOnBlack,
 202                        TextureSource *aOnWhite,
 203                        gfx::Filter aFilter)
 204     : TexturedEffect(EffectTypes::COMPONENT_ALPHA, nullptr, false, aFilter)
 205     , mOnBlack(aOnBlack)
 206     , mOnWhite(aOnWhite)
 207   {}
 208
 209   virtual const char* Name() { return "EffectComponentAlpha"; }
 210
 211   TextureSource* mOnBlack;
 212   TextureSource* mOnWhite;
 213 };
 214
 215 struct EffectSolidColor : public Effect
 216 {
 217   explicit EffectSolidColor(const gfx::Color &aColor)
 218     : Effect(EffectTypes::SOLID_COLOR)
 219     , mColor(aColor)
 220   {}
 221
 222   virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
 223
 224   gfx::Color mColor;
 225 };
 226
 227 struct EffectChain
 228 {
 229   EffectChain() : mLayerRef(nullptr) {}
 230   explicit EffectChain(void* aLayerRef) : mLayerRef(aLayerRef) {}
 231
 232   RefPtr<Effect> mPrimaryEffect;
 233   EnumeratedArray<EffectTypes, EffectTypes::MAX_SECONDARY, RefPtr<Effect>>
 234     mSecondaryEffects;
 235   void* mLayerRef; //!< For LayerScope logging
 236 };
 237
 238 /**
 239  * Create a Textured effect corresponding to aFormat and using
 240  * aSource as the (first) texture source.
 241  *
 242  * Note that aFormat can be different form aSource->GetFormat if, we are
 243  * creating an effect that takes several texture sources (like with YCBCR
 244  * where aFormat would be FOMRAT_YCBCR and each texture source would be
 245  * a one-channel A8 texture)
 246  */
 247 inline TemporaryRef<TexturedEffect>
 248 CreateTexturedEffect(gfx::SurfaceFormat aFormat,
 249                      TextureSource* aSource,
 250                      const gfx::Filter& aFilter,
 251                      bool isAlphaPremultiplied)
 252 {
 253   MOZ_ASSERT(aSource);
 254   RefPtr<TexturedEffect> result;
 255   switch (aFormat) {
 256   case gfx::SurfaceFormat::B8G8R8A8:
 257   case gfx::SurfaceFormat::B8G8R8X8:
 258   case gfx::SurfaceFormat::R8G8B8X8:
 259   case gfx::SurfaceFormat::R5G6B5:
 260   case gfx::SurfaceFormat::R8G8B8A8:
 261     result = new EffectRGB(aSource, isAlphaPremultiplied, aFilter);
 262     break;
 263   case gfx::SurfaceFormat::YUV:
 264     result = new EffectYCbCr(aSource, aFilter);
 265     break;
 266   default:
 267     NS_WARNING("unhandled program type");
 268     break;
 269   }
 270
 271   return result;
 272 }
 273
 274 /**
 275  * Create a textured effect based on aSource format and the presence of
 276  * aSourceOnWhite.
 277  *
 278  * aSourceOnWhite can be null.
 279  */
 280 inline TemporaryRef<TexturedEffect>
 281 CreateTexturedEffect(TextureSource* aSource,
 282                      TextureSource* aSourceOnWhite,
 283                      const gfx::Filter& aFilter,
 284                      bool isAlphaPremultiplied)
 285 {
 286   MOZ_ASSERT(aSource);
 287   if (aSourceOnWhite) {
 288     MOZ_ASSERT(aSource->GetFormat() == gfx::SurfaceFormat::R8G8B8X8 ||
 289                aSourceOnWhite->GetFormat() == gfx::SurfaceFormat::B8G8R8X8);
 290     return new EffectComponentAlpha(aSource, aSourceOnWhite, aFilter);
 291   }
 292
 293   return CreateTexturedEffect(aSource->GetFormat(),
 294                               aSource,
 295                               aFilter,
 296                               isAlphaPremultiplied);
 297 }
 298
 299 /**
 300  * Create a textured effect based on aSource format.
 301  *
 302  * This version excudes the possibility of component alpha.
 303  */
 304 inline TemporaryRef<TexturedEffect>
 305 CreateTexturedEffect(TextureSource *aTexture,
 306                      const gfx::Filter& aFilter)
 307 {
 308   return CreateTexturedEffect(aTexture, nullptr, aFilter, true);
 309 }
 310
 311
 312 } // namespace layers
 313 } // namespace mozilla
 314
 315 #endif