The Tor Browser: gfx/layers/opengl/OGLShaderProgram.h@129ffea94266 (annotated)

gfx/layers/opengl/OGLShaderProgram.h@129ffea94266 (annotated)

gfx/layers/opengl/OGLShaderProgram.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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 GFX_OGLSHADERPROGRAM_H
 #define GFX_OGLSHADERPROGRAM_H
 #include "GLContext.h"                  // for fast inlines of glUniform*
 #include "gfx3DMatrix.h"                // for gfx3DMatrix
 #include "gfxTypes.h"
 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
 #include "mozilla/RefPtr.h"             // for RefPtr
 #include "mozilla/gfx/Matrix.h"         // for Matrix4x4
 #include "mozilla/gfx/Rect.h"           // for Rect
 #include "mozilla/gfx/Types.h"
 #include "nsDebug.h"                    // for NS_ASSERTION
 #include "nsPoint.h"                    // for nsIntPoint
 #include "nsTArray.h"                   // for nsTArray
 #include "mozilla/layers/CompositorTypes.h"
 #include <string>
 struct gfxRGBA;
 struct nsIntRect;
 namespace mozilla {
 namespace layers {
 class Layer;
 enum ShaderFeatures {
   ENABLE_RENDER_COLOR=0x01,
   ENABLE_TEXTURE_RECT=0x02,
   ENABLE_TEXTURE_EXTERNAL=0x04,
   ENABLE_TEXTURE_YCBCR=0x08,
   ENABLE_TEXTURE_COMPONENT_ALPHA=0x10,
   ENABLE_TEXTURE_NO_ALPHA=0x20,
   ENABLE_TEXTURE_RB_SWAP=0x40,
   ENABLE_OPACITY=0x80,
   ENABLE_BLUR=0x100,
   ENABLE_COLOR_MATRIX=0x200,
   ENABLE_MASK_2D=0x400,
   ENABLE_MASK_3D=0x800
 };
 class KnownUniform {
 public:
   enum KnownUniformName {
     NotAKnownUniform = -1,
     LayerTransform = 0,
     MaskQuadTransform,
     LayerQuadTransform,
     MatrixProj,
     TextureTransform,
     RenderTargetOffset,
     LayerOpacity,
     Texture,
     YTexture,
     CbTexture,
     CrTexture,
     BlackTexture,
     WhiteTexture,
     MaskTexture,
     RenderColor,
     TexCoordMultiplier,
     TexturePass2,
     KnownUniformCount
   };
   KnownUniform()
   {
     mName = NotAKnownUniform;
     mNameString = nullptr;
     mLocation = -1;
     memset(&mValue, 0, sizeof(mValue));
   }
   bool UpdateUniform(int32_t i1) {
     if (mLocation == -1) return false;
     if (mValue.i1 != i1) {
       mValue.i1 = i1;
       return true;
     }
     return false;
   }
   bool UpdateUniform(float f1) {
     if (mLocation == -1) return false;
     if (mValue.f1 != f1) {
       mValue.f1 = f1;
       return true;
     }
     return false;
   }
   bool UpdateUniform(float f1, float f2) {
     if (mLocation == -1) return false;
     if (mValue.f16v[0] != f1 ||
         mValue.f16v[1] != f2)
     {
       mValue.f16v[0] = f1;
       mValue.f16v[1] = f2;
       return true;
     }
     return false;
   }
   bool UpdateUniform(float f1, float f2, float f3, float f4) {
     if (mLocation == -1) return false;
     if (mValue.f16v[0] != f1 ||
         mValue.f16v[1] != f2 ||
         mValue.f16v[2] != f3 ||
         mValue.f16v[3] != f4)
     {
       mValue.f16v[0] = f1;
       mValue.f16v[1] = f2;
       mValue.f16v[2] = f3;
       mValue.f16v[3] = f4;
       return true;
     }
     return false;
   }
   bool UpdateUniform(int cnt, const float *fp) {
     if (mLocation == -1) return false;
     switch (cnt) {
     case 1:
     case 2:
     case 3:
     case 4:
     case 16:
       if (memcmp(mValue.f16v, fp, sizeof(float) * cnt) != 0) {
         memcpy(mValue.f16v, fp, sizeof(float) * cnt);
         return true;
       }
       return false;
     }
     NS_NOTREACHED("cnt must be 1 2 3 4 or 16");
     return false;
   }
   KnownUniformName mName;
   const char *mNameString;
   int32_t mLocation;
   union {
     int i1;
     float f1;
     float f16v[16];
   } mValue;
 };
 class ShaderConfigOGL
 {
 public:
   ShaderConfigOGL() :
     mFeatures(0) {}
   void SetRenderColor(bool aEnabled);
   void SetTextureTarget(GLenum aTarget);
   void SetRBSwap(bool aEnabled);
   void SetNoAlpha(bool aEnabled);
   void SetOpacity(bool aEnabled);
   void SetYCbCr(bool aEnabled);
   void SetComponentAlpha(bool aEnabled);
   void SetColorMatrix(bool aEnabled);
   void SetBlur(bool aEnabled);
   void SetMask2D(bool aEnabled);
   void SetMask3D(bool aEnabled);
   bool operator< (const ShaderConfigOGL& other) const {
     return mFeatures < other.mFeatures;
   }
 public:
   void SetFeature(int aBitmask, bool aState) {
     if (aState)
       mFeatures |= aBitmask;
     else
       mFeatures &= (~aBitmask);
   }
   int mFeatures;
 };
 static inline ShaderConfigOGL
 ShaderConfigFromTargetAndFormat(GLenum aTarget,
                                 gfx::SurfaceFormat aFormat)
 {
   ShaderConfigOGL config;
   config.SetTextureTarget(aTarget);
   config.SetRBSwap(aFormat == gfx::SurfaceFormat::B8G8R8A8 ||
                    aFormat == gfx::SurfaceFormat::B8G8R8X8);
   config.SetNoAlpha(aFormat == gfx::SurfaceFormat::B8G8R8X8 ||
                     aFormat == gfx::SurfaceFormat::R8G8B8X8 ||
                     aFormat == gfx::SurfaceFormat::R5G6B5);
   return config;
 }
 /**
  * This struct represents the shaders that make up a program and the uniform
  * and attribute parmeters that those shaders take.
  * It is used by ShaderProgramOGL.
  * Use the factory method GetProfileFor to create instances.
  */
 struct ProgramProfileOGL
 {
   /**
    * Factory method; creates an instance of this class for the given
    * ShaderConfigOGL
    */
   static ProgramProfileOGL GetProfileFor(ShaderConfigOGL aConfig);
   /**
    * These two methods lookup the location of a uniform and attribute,
    * respectively. Returns -1 if the named uniform/attribute does not
    * have a location for the shaders represented by this profile.
    */
   GLint LookupAttributeLocation(const char* aName)
   {
     for (uint32_t i = 0; i < mAttributes.Length(); ++i) {
       if (strcmp(mAttributes[i].mName, aName) == 0) {
         return mAttributes[i].mLocation;
       }
     }
     return -1;
   }
   // represents the name and location of a uniform or attribute
   struct Argument
   {
     Argument(const char* aName) :
       mName(aName) {}
     const char* mName;
     GLint mLocation;
   };
   // the source code for the program's shaders
   std::string mVertexShaderString;
   std::string mFragmentShaderString;
   KnownUniform mUniforms[KnownUniform::KnownUniformCount];
   nsTArray<Argument> mAttributes;
   nsTArray<const char *> mDefines;
   uint32_t mTextureCount;
   ProgramProfileOGL() :
     mTextureCount(0)
   {}
 };
 #if defined(DEBUG)
 #define CHECK_CURRENT_PROGRAM 1
 #define ASSERT_THIS_PROGRAM                                             \
   do {                                                                  \
     GLuint currentProgram;                                              \
     mGL->GetUIntegerv(LOCAL_GL_CURRENT_PROGRAM, &currentProgram);       \
     NS_ASSERTION(currentProgram == mProgram,                            \
                  "SetUniform with wrong program active!");              \
   } while (0)
 #else
 #define ASSERT_THIS_PROGRAM                                             \
   do { } while (0)
 #endif
 /**
  * Represents an OGL shader program. The details of a program are represented
  * by a ProgramProfileOGL
  */
 class ShaderProgramOGL
 {
 public:
   typedef mozilla::gl::GLContext GLContext;
   ShaderProgramOGL(GLContext* aGL, const ProgramProfileOGL& aProfile);
   ~ShaderProgramOGL();
   bool HasInitialized() {
     NS_ASSERTION(mProgramState != STATE_OK || mProgram > 0, "Inconsistent program state");
     return mProgramState == STATE_OK;
   }
   void Activate();
   bool Initialize();
   GLint CreateShader(GLenum aShaderType, const char *aShaderSource);
   /**
    * Creates a program and stores its id.
    */
   bool CreateProgram(const char *aVertexShaderString,
                      const char *aFragmentShaderString);
   /**
    * Lookup the location of an attribute
    */
   GLint AttribLocation(const char* aName) {
     return mProfile.LookupAttributeLocation(aName);
   }
   /**
    * The following set of methods set a uniform argument to the shader program.
    * Not all uniforms may be set for all programs, and such uses will throw
    * an assertion.
    */
   void SetLayerTransform(const gfx::Matrix4x4& aMatrix) {
     SetMatrixUniform(KnownUniform::LayerTransform, aMatrix);
   }
   void SetMaskLayerTransform(const gfx::Matrix4x4& aMatrix) {
     SetMatrixUniform(KnownUniform::MaskQuadTransform, aMatrix);
   }
   void SetLayerQuadRect(const nsIntRect& aRect) {
     gfx3DMatrix m;
     m._11 = float(aRect.width);
     m._22 = float(aRect.height);
     m._41 = float(aRect.x);
     m._42 = float(aRect.y);
     SetMatrixUniform(KnownUniform::LayerQuadTransform, m);
   }
   void SetLayerQuadRect(const gfx::Rect& aRect) {
     gfx3DMatrix m;
     m._11 = aRect.width;
     m._22 = aRect.height;
     m._41 = aRect.x;
     m._42 = aRect.y;
     SetMatrixUniform(KnownUniform::LayerQuadTransform, m);
   }
   void SetProjectionMatrix(const gfx::Matrix4x4& aMatrix) {
     SetMatrixUniform(KnownUniform::MatrixProj, aMatrix);
   }
   // sets this program's texture transform, if it uses one
   void SetTextureTransform(const gfx::Matrix4x4& aMatrix) {
     SetMatrixUniform(KnownUniform::TextureTransform, aMatrix);
   }
   void SetRenderOffset(const nsIntPoint& aOffset) {
     float vals[4] = { float(aOffset.x), float(aOffset.y), 0.0f, 0.0f };
     SetUniform(KnownUniform::RenderTargetOffset, 4, vals);
   }
   void SetRenderOffset(float aX, float aY) {
     float vals[4] = { aX, aY, 0.0f, 0.0f };
     SetUniform(KnownUniform::RenderTargetOffset, 4, vals);
   }
   void SetLayerOpacity(float aOpacity) {
     SetUniform(KnownUniform::LayerOpacity, aOpacity);
   }
   void SetTextureUnit(GLint aUnit) {
     SetUniform(KnownUniform::Texture, aUnit);
   }
   void SetYTextureUnit(GLint aUnit) {
     SetUniform(KnownUniform::YTexture, aUnit);
   }
   void SetCbTextureUnit(GLint aUnit) {
     SetUniform(KnownUniform::CbTexture, aUnit);
   }
   void SetCrTextureUnit(GLint aUnit) {
     SetUniform(KnownUniform::CrTexture, aUnit);
   }
   void SetYCbCrTextureUnits(GLint aYUnit, GLint aCbUnit, GLint aCrUnit) {
     SetUniform(KnownUniform::YTexture, aYUnit);
     SetUniform(KnownUniform::CbTexture, aCbUnit);
     SetUniform(KnownUniform::CrTexture, aCrUnit);
   }
   void SetBlackTextureUnit(GLint aUnit) {
     SetUniform(KnownUniform::BlackTexture, aUnit);
   }
   void SetWhiteTextureUnit(GLint aUnit) {
     SetUniform(KnownUniform::WhiteTexture, aUnit);
   }
   void SetMaskTextureUnit(GLint aUnit) {
     SetUniform(KnownUniform::MaskTexture, aUnit);
   }
   void SetRenderColor(const gfxRGBA& aColor) {
     SetUniform(KnownUniform::RenderColor, aColor);
   }
   void SetRenderColor(const gfx::Color& aColor) {
     SetUniform(KnownUniform::RenderColor, aColor);
   }
   void SetTexCoordMultiplier(float aWidth, float aHeight) {
     float f[] = {aWidth, aHeight};
     SetUniform(KnownUniform::TexCoordMultiplier, 2, f);
   }
   // Set whether we want the component alpha shader to return the color
   // vector (pass 1, false) or the alpha vector (pass2, true). With support
   // for multiple render targets we wouldn't need two passes here.
   void SetTexturePass2(bool aFlag) {
     SetUniform(KnownUniform::TexturePass2, aFlag ? 1 : 0);
   }
   // the names of attributes
   static const char* const VertexCoordAttrib;
   static const char* const TexCoordAttrib;
 protected:
   RefPtr<GLContext> mGL;
   // the OpenGL id of the program
   GLuint mProgram;
   ProgramProfileOGL mProfile;
   enum {
     STATE_NEW,
     STATE_OK,
     STATE_ERROR
   } mProgramState;
 #ifdef CHECK_CURRENT_PROGRAM
   static int sCurrentProgramKey;
 #endif
   void SetUniform(KnownUniform::KnownUniformName aKnownUniform, float aFloatValue)
   {
     ASSERT_THIS_PROGRAM;
     NS_ASSERTION(aKnownUniform >= 0 && aKnownUniform < KnownUniform::KnownUniformCount, "Invalid known uniform");
     KnownUniform& ku(mProfile.mUniforms[aKnownUniform]);
     if (ku.UpdateUniform(aFloatValue)) {
       mGL->fUniform1f(ku.mLocation, aFloatValue);
     }
   }
   void SetUniform(KnownUniform::KnownUniformName aKnownUniform, const gfxRGBA& aColor)
   {
     ASSERT_THIS_PROGRAM;
     NS_ASSERTION(aKnownUniform >= 0 && aKnownUniform < KnownUniform::KnownUniformCount, "Invalid known uniform");
     KnownUniform& ku(mProfile.mUniforms[aKnownUniform]);
     if (ku.UpdateUniform(aColor.r, aColor.g, aColor.b, aColor.a)) {
       mGL->fUniform4fv(ku.mLocation, 1, ku.mValue.f16v);
     }
   }
   void SetUniform(KnownUniform::KnownUniformName aKnownUniform, const gfx::Color& aColor) {
     ASSERT_THIS_PROGRAM;
     NS_ASSERTION(aKnownUniform >= 0 && aKnownUniform < KnownUniform::KnownUniformCount, "Invalid known uniform");
     KnownUniform& ku(mProfile.mUniforms[aKnownUniform]);
     if (ku.UpdateUniform(aColor.r, aColor.g, aColor.b, aColor.a)) {
       mGL->fUniform4fv(ku.mLocation, 1, ku.mValue.f16v);
     }
   }
   void SetUniform(KnownUniform::KnownUniformName aKnownUniform, int aLength, float *aFloatValues)
   {
     ASSERT_THIS_PROGRAM;
     NS_ASSERTION(aKnownUniform >= 0 && aKnownUniform < KnownUniform::KnownUniformCount, "Invalid known uniform");
     KnownUniform& ku(mProfile.mUniforms[aKnownUniform]);
     if (ku.UpdateUniform(aLength, aFloatValues)) {
       switch (aLength) {
       case 1: mGL->fUniform1fv(ku.mLocation, 1, ku.mValue.f16v); break;
       case 2: mGL->fUniform2fv(ku.mLocation, 1, ku.mValue.f16v); break;
       case 3: mGL->fUniform3fv(ku.mLocation, 1, ku.mValue.f16v); break;
       case 4: mGL->fUniform4fv(ku.mLocation, 1, ku.mValue.f16v); break;
       default:
         NS_NOTREACHED("Bogus aLength param");
       }
     }
   }
   void SetUniform(KnownUniform::KnownUniformName aKnownUniform, GLint aIntValue) {
     ASSERT_THIS_PROGRAM;
     NS_ASSERTION(aKnownUniform >= 0 && aKnownUniform < KnownUniform::KnownUniformCount, "Invalid known uniform");
     KnownUniform& ku(mProfile.mUniforms[aKnownUniform]);
     if (ku.UpdateUniform(aIntValue)) {
       mGL->fUniform1i(ku.mLocation, aIntValue);
     }
   }
   void SetMatrixUniform(KnownUniform::KnownUniformName aKnownUniform, const float *aFloatValues) {
     ASSERT_THIS_PROGRAM;
     NS_ASSERTION(aKnownUniform >= 0 && aKnownUniform < KnownUniform::KnownUniformCount, "Invalid known uniform");
     KnownUniform& ku(mProfile.mUniforms[aKnownUniform]);
     if (ku.UpdateUniform(16, aFloatValues)) {
       mGL->fUniformMatrix4fv(ku.mLocation, 1, false, ku.mValue.f16v);
     }
   }
   void SetMatrixUniform(KnownUniform::KnownUniformName aKnownUniform, const gfx3DMatrix& aMatrix) {
     SetMatrixUniform(aKnownUniform, &aMatrix._11);
   }
   void SetMatrixUniform(KnownUniform::KnownUniformName aKnownUniform, const gfx::Matrix4x4& aMatrix) {
     SetMatrixUniform(aKnownUniform, &aMatrix._11);
   }
 };
 } /* layers */
 } /* mozilla */
 #endif /* GFX_OGLSHADERPROGRAM_H */

The Tor Browser / annotate

gfx/layers/opengl/OGLShaderProgram.h@129ffea94266 (annotated)

gfx/layers/opengl/OGLShaderProgram.h