Constant Field Values

Contents

• jp.co.*

jp.co.*

jp.co.cyberagent.android.gpuimage.GLTextureView

Modifier and Type	Constant Field	Value
public static final int	DEBUG_CHECK_GL_ERROR	1
public static final int	DEBUG_LOG_GL_CALLS	2
public static final int	RENDERMODE_CONTINUOUSLY	1
public static final int	RENDERMODE_WHEN_DIRTY	0

jp.co.cyberagent.android.gpuimage.GPUImageView

Modifier and Type	Constant Field	Value
public static final int	RENDERMODE_CONTINUOUSLY	1
public static final int	RENDERMODE_WHEN_DIRTY	0

jp.co.cyberagent.android.gpuimage.filter.GPUImage3x3ConvolutionFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	THREE_X_THREE_TEXTURE_SAMPLING_FRAGMENT_SHADER	"precision highp float;\n\nuniform sampler2D inputImageTexture;\n\nuniform mediump mat3 convolutionMatrix;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nvoid main()\n{\n mediump vec4 bottomColor = texture2D(inputImageTexture, bottomTextureCoordinate);\n mediump vec4 bottomLeftColor = texture2D(inputImageTexture, bottomLeftTextureCoordinate);\n mediump vec4 bottomRightColor = texture2D(inputImageTexture, bottomRightTextureCoordinate);\n mediump vec4 centerColor = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 leftColor = texture2D(inputImageTexture, leftTextureCoordinate);\n mediump vec4 rightColor = texture2D(inputImageTexture, rightTextureCoordinate);\n mediump vec4 topColor = texture2D(inputImageTexture, topTextureCoordinate);\n mediump vec4 topRightColor = texture2D(inputImageTexture, topRightTextureCoordinate);\n mediump vec4 topLeftColor = texture2D(inputImageTexture, topLeftTextureCoordinate);\n\n mediump vec4 resultColor = topLeftColor * convolutionMatrix[0][0] + topColor * convolutionMatrix[0][1] + topRightColor * convolutionMatrix[0][2];\n resultColor += leftColor * convolutionMatrix[1][0] + centerColor * convolutionMatrix[1][1] + rightColor * convolutionMatrix[1][2];\n resultColor += bottomLeftColor * convolutionMatrix[2][0] + bottomColor * convolutionMatrix[2][1] + bottomRightColor * convolutionMatrix[2][2];\n\n gl_FragColor = resultColor;\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImage3x3TextureSamplingFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	THREE_X_THREE_TEXTURE_SAMPLING_VERTEX_SHADER	"attribute vec4 position;\nattribute vec4 inputTextureCoordinate;\n\nuniform highp float texelWidth; \nuniform highp float texelHeight; \n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nvoid main()\n{\n gl_Position = position;\n\n vec2 widthStep = vec2(texelWidth, 0.0);\n vec2 heightStep = vec2(0.0, texelHeight);\n vec2 widthHeightStep = vec2(texelWidth, texelHeight);\n vec2 widthNegativeHeightStep = vec2(texelWidth, -texelHeight);\n\n textureCoordinate = inputTextureCoordinate.xy;\n leftTextureCoordinate = inputTextureCoordinate.xy - widthStep;\n rightTextureCoordinate = inputTextureCoordinate.xy + widthStep;\n\n topTextureCoordinate = inputTextureCoordinate.xy - heightStep;\n topLeftTextureCoordinate = inputTextureCoordinate.xy - widthHeightStep;\n topRightTextureCoordinate = inputTextureCoordinate.xy + widthNegativeHeightStep;\n\n bottomTextureCoordinate = inputTextureCoordinate.xy + heightStep;\n bottomLeftTextureCoordinate = inputTextureCoordinate.xy - widthNegativeHeightStep;\n bottomRightTextureCoordinate = inputTextureCoordinate.xy + widthHeightStep;\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageAddBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	ADD_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n lowp vec4 base = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 overlay = texture2D(inputImageTexture2, textureCoordinate2);\n\n mediump float r;\n if (overlay.r * base.a + base.r * overlay.a >= overlay.a * base.a) {\n r = overlay.a * base.a + overlay.r * (1.0 - base.a) + base.r * (1.0 - overlay.a);\n } else {\n r = overlay.r + base.r;\n }\n\n mediump float g;\n if (overlay.g * base.a + base.g * overlay.a >= overlay.a * base.a) {\n g = overlay.a * base.a + overlay.g * (1.0 - base.a) + base.g * (1.0 - overlay.a);\n } else {\n g = overlay.g + base.g;\n }\n\n mediump float b;\n if (overlay.b * base.a + base.b * overlay.a >= overlay.a * base.a) {\n b = overlay.a * base.a + overlay.b * (1.0 - base.a) + base.b * (1.0 - overlay.a);\n } else {\n b = overlay.b + base.b;\n }\n\n mediump float a = overlay.a + base.a - overlay.a * base.a;\n \n gl_FragColor = vec4(r, g, b, a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageAlphaBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	ALPHA_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n uniform lowp float mixturePercent;\n\n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n\n gl_FragColor = vec4(mix(textureColor.rgb, textureColor2.rgb, textureColor2.a * mixturePercent), textureColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageBilateralBlurFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	BILATERAL_FRAGMENT_SHADER	"uniform sampler2D inputImageTexture;\n const lowp int GAUSSIAN_SAMPLES = 9;\n varying highp vec2 textureCoordinate;\n varying highp vec2 blurCoordinates[GAUSSIAN_SAMPLES];\n uniform mediump float distanceNormalizationFactor;\n void main()\n {\n lowp vec4 centralColor;\n lowp float gaussianWeightTotal;\n lowp vec4 sum;\n lowp vec4 sampleColor;\n lowp float distanceFromCentralColor;\n lowp float gaussianWeight;\n \n centralColor = texture2D(inputImageTexture, blurCoordinates[4]);\n gaussianWeightTotal = 0.18;\n sum = centralColor * 0.18;\n \n sampleColor = texture2D(inputImageTexture, blurCoordinates[0]);\n distanceFromCentralColor = min(distance(centralColor, sampleColor) * distanceNormalizationFactor, 1.0);\n gaussianWeight = 0.05 * (1.0 - distanceFromCentralColor);\n gaussianWeightTotal += gaussianWeight;\n sum += sampleColor * gaussianWeight;\n sampleColor = texture2D(inputImageTexture, blurCoordinates[1]);\n distanceFromCentralColor = min(distance(centralColor, sampleColor) * distanceNormalizationFactor, 1.0);\n gaussianWeight = 0.09 * (1.0 - distanceFromCentralColor);\n gaussianWeightTotal += gaussianWeight;\n sum += sampleColor * gaussianWeight;\n sampleColor = texture2D(inputImageTexture, blurCoordinates[2]);\n distanceFromCentralColor = min(distance(centralColor, sampleColor) * distanceNormalizationFactor, 1.0);\n gaussianWeight = 0.12 * (1.0 - distanceFromCentralColor);\n gaussianWeightTotal += gaussianWeight;\n sum += sampleColor * gaussianWeight;\n sampleColor = texture2D(inputImageTexture, blurCoordinates[3]);\n distanceFromCentralColor = min(distance(centralColor, sampleColor) * distanceNormalizationFactor, 1.0);\n gaussianWeight = 0.15 * (1.0 - distanceFromCentralColor);\n gaussianWeightTotal += gaussianWeight;\n sum += sampleColor * gaussianWeight;\n sampleColor = texture2D(inputImageTexture, blurCoordinates[5]);\n distanceFromCentralColor = min(distance(centralColor, sampleColor) * distanceNormalizationFactor, 1.0);\n gaussianWeight = 0.15 * (1.0 - distanceFromCentralColor);\n gaussianWeightTotal += gaussianWeight;\n sum += sampleColor * gaussianWeight;\n sampleColor = texture2D(inputImageTexture, blurCoordinates[6]);\n distanceFromCentralColor = min(distance(centralColor, sampleColor) * distanceNormalizationFactor, 1.0);\n gaussianWeight = 0.12 * (1.0 - distanceFromCentralColor);\n gaussianWeightTotal += gaussianWeight;\n sum += sampleColor * gaussianWeight;\n sampleColor = texture2D(inputImageTexture, blurCoordinates[7]);\n distanceFromCentralColor = min(distance(centralColor, sampleColor) * distanceNormalizationFactor, 1.0);\n gaussianWeight = 0.09 * (1.0 - distanceFromCentralColor);\n gaussianWeightTotal += gaussianWeight;\n sum += sampleColor * gaussianWeight;\n sampleColor = texture2D(inputImageTexture, blurCoordinates[8]);\n distanceFromCentralColor = min(distance(centralColor, sampleColor) * distanceNormalizationFactor, 1.0);\n gaussianWeight = 0.05 * (1.0 - distanceFromCentralColor);\n gaussianWeightTotal += gaussianWeight;\n sum += sampleColor * gaussianWeight;\n gl_FragColor = sum / gaussianWeightTotal;\n }"
public static final java.lang.String	BILATERAL_VERTEX_SHADER	"attribute vec4 position;\nattribute vec4 inputTextureCoordinate;\nconst int GAUSSIAN_SAMPLES = 9;\nuniform vec2 singleStepOffset;\nvarying vec2 textureCoordinate;\nvarying vec2 blurCoordinates[GAUSSIAN_SAMPLES];\nvoid main()\n{\n\tgl_Position = position;\n\ttextureCoordinate = inputTextureCoordinate.xy;\n\tint multiplier = 0;\n\tvec2 blurStep;\n\tfor (int i = 0; i < GAUSSIAN_SAMPLES; i++)\n\t{\n\t\tmultiplier = (i - ((GAUSSIAN_SAMPLES - 1) / 2));\n\t\tblurStep = float(multiplier) * singleStepOffset;\n\t\tblurCoordinates[i] = inputTextureCoordinate.xy + blurStep;\n\t}\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageBoxBlurFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	FRAGMENT_SHADER	"precision highp float;\n\nuniform sampler2D inputImageTexture;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepLeftTextureCoordinate;\nvarying vec2 twoStepsLeftTextureCoordinate;\nvarying vec2 oneStepRightTextureCoordinate;\nvarying vec2 twoStepsRightTextureCoordinate;\n\nvoid main()\n{\nlowp vec4 fragmentColor = texture2D(inputImageTexture, centerTextureCoordinate) * 0.2;\nfragmentColor += texture2D(inputImageTexture, oneStepLeftTextureCoordinate) * 0.2;\nfragmentColor += texture2D(inputImageTexture, oneStepRightTextureCoordinate) * 0.2;\nfragmentColor += texture2D(inputImageTexture, twoStepsLeftTextureCoordinate) * 0.2;\nfragmentColor += texture2D(inputImageTexture, twoStepsRightTextureCoordinate) * 0.2;\n\ngl_FragColor = fragmentColor;\n}\n"
public static final java.lang.String	VERTEX_SHADER	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset; \nuniform float texelHeightOffset; \n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepLeftTextureCoordinate;\nvarying vec2 twoStepsLeftTextureCoordinate;\nvarying vec2 oneStepRightTextureCoordinate;\nvarying vec2 twoStepsRightTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 firstOffset = vec2(1.5 * texelWidthOffset, 1.5 * texelHeightOffset);\nvec2 secondOffset = vec2(3.5 * texelWidthOffset, 3.5 * texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepLeftTextureCoordinate = inputTextureCoordinate - firstOffset;\ntwoStepsLeftTextureCoordinate = inputTextureCoordinate - secondOffset;\noneStepRightTextureCoordinate = inputTextureCoordinate + firstOffset;\ntwoStepsRightTextureCoordinate = inputTextureCoordinate + secondOffset;\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageBrightnessFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	BRIGHTNESS_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform lowp float brightness;\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = vec4((textureColor.rgb + vec3(brightness)), textureColor.w);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageBulgeDistortionFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	BULGE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nuniform highp float aspectRatio;\nuniform highp vec2 center;\nuniform highp float radius;\nuniform highp float scale;\n\nvoid main()\n{\nhighp vec2 textureCoordinateToUse = vec2(textureCoordinate.x, (textureCoordinate.y * aspectRatio + 0.5 - 0.5 * aspectRatio));\nhighp float dist = distance(center, textureCoordinateToUse);\ntextureCoordinateToUse = textureCoordinate;\n\nif (dist < radius)\n{\ntextureCoordinateToUse -= center;\nhighp float percent = 1.0 - ((radius - dist) / radius) * scale;\npercent = percent * percent;\n\ntextureCoordinateToUse = textureCoordinateToUse * percent;\ntextureCoordinateToUse += center;\n}\n\ngl_FragColor = texture2D(inputImageTexture, textureCoordinateToUse ); \n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageCGAColorspaceFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	CGACOLORSPACE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nhighp vec2 sampleDivisor = vec2(1.0 / 200.0, 1.0 / 320.0);\n//highp vec4 colorDivisor = vec4(colorDepth);\n\nhighp vec2 samplePos = textureCoordinate - mod(textureCoordinate, sampleDivisor);\nhighp vec4 color = texture2D(inputImageTexture, samplePos );\n\n//gl_FragColor = texture2D(inputImageTexture, samplePos );\nmediump vec4 colorCyan = vec4(85.0 / 255.0, 1.0, 1.0, 1.0);\nmediump vec4 colorMagenta = vec4(1.0, 85.0 / 255.0, 1.0, 1.0);\nmediump vec4 colorWhite = vec4(1.0, 1.0, 1.0, 1.0);\nmediump vec4 colorBlack = vec4(0.0, 0.0, 0.0, 1.0);\n\nmediump vec4 endColor;\nhighp float blackDistance = distance(color, colorBlack);\nhighp float whiteDistance = distance(color, colorWhite);\nhighp float magentaDistance = distance(color, colorMagenta);\nhighp float cyanDistance = distance(color, colorCyan);\n\nmediump vec4 finalColor;\n\nhighp float colorDistance = min(magentaDistance, cyanDistance);\ncolorDistance = min(colorDistance, whiteDistance);\ncolorDistance = min(colorDistance, blackDistance); \n\nif (colorDistance == blackDistance) {\nfinalColor = colorBlack;\n} else if (colorDistance == whiteDistance) {\nfinalColor = colorWhite;\n} else if (colorDistance == cyanDistance) {\nfinalColor = colorCyan;\n} else {\nfinalColor = colorMagenta;\n}\n\ngl_FragColor = finalColor;\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageChromaKeyBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	CHROMA_KEY_BLEND_FRAGMENT_SHADER	" precision highp float;\n \n varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform float thresholdSensitivity;\n uniform float smoothing;\n uniform vec3 colorToReplace;\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n \n float maskY = 0.2989 * colorToReplace.r + 0.5866 * colorToReplace.g + 0.1145 * colorToReplace.b;\n float maskCr = 0.7132 * (colorToReplace.r - maskY);\n float maskCb = 0.5647 * (colorToReplace.b - maskY);\n \n float Y = 0.2989 * textureColor.r + 0.5866 * textureColor.g + 0.1145 * textureColor.b;\n float Cr = 0.7132 * (textureColor.r - Y);\n float Cb = 0.5647 * (textureColor.b - Y);\n \n float blendValue = 1.0 - smoothstep(thresholdSensitivity, thresholdSensitivity + smoothing, distance(vec2(Cr, Cb), vec2(maskCr, maskCb)));\n gl_FragColor = mix(textureColor, textureColor2, blendValue);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageColorBalanceFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	GPU_IMAGE_COLOR_BALANCE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\nuniform sampler2D inputImageTexture;\nuniform lowp vec3 shadowsShift;\nuniform lowp vec3 midtonesShift;\nuniform lowp vec3 highlightsShift;\nuniform int preserveLuminosity;\nlowp vec3 RGBToHSL(lowp vec3 color)\n{\nlowp vec3 hsl; // init to 0 to avoid warnings ? (and reverse if + remove first part)\nlowp float fmin = min(min(color.r, color.g), color.b); //Min. value of RGB\nlowp float fmax = max(max(color.r, color.g), color.b); //Max. value of RGB\nlowp float delta = fmax - fmin; //Delta RGB value\nhsl.z = (fmax + fmin) / 2.0; // Luminance\nif (delta == 0.0)\t\t//This is a gray, no chroma...\n{\n hsl.x = 0.0;\t// Hue\n hsl.y = 0.0;\t// Saturation\n}\nelse //Chromatic data...\n{\n if (hsl.z < 0.5)\n hsl.y = delta / (fmax + fmin); // Saturation\n else\n hsl.y = delta / (2.0 - fmax - fmin); // Saturation\n\n lowp float deltaR = (((fmax - color.r) / 6.0) + (delta / 2.0)) / delta;\n lowp float deltaG = (((fmax - color.g) / 6.0) + (delta / 2.0)) / delta;\n lowp float deltaB = (((fmax - color.b) / 6.0) + (delta / 2.0)) / delta;\n\n if (color.r == fmax )\n hsl.x = deltaB - deltaG; // Hue\n else if (color.g == fmax)\n hsl.x = (1.0 / 3.0) + deltaR - deltaB; // Hue\n else if (color.b == fmax)\n hsl.x = (2.0 / 3.0) + deltaG - deltaR; // Hue\n if (hsl.x < 0.0)\n hsl.x += 1.0; // Hue\n else if (hsl.x > 1.0)\n hsl.x -= 1.0; // Hue\n}\n\nreturn hsl;\n}\nlowp float HueToRGB(lowp float f1, lowp float f2, lowp float hue)\n{\n if (hue < 0.0)\n hue += 1.0;\n else if (hue > 1.0)\n hue -= 1.0;\n lowp float res;\n if ((6.0 * hue) < 1.0)\n res = f1 + (f2 - f1) * 6.0 * hue;\n else if ((2.0 * hue) < 1.0)\n res = f2;\n else if ((3.0 * hue) < 2.0)\n res = f1 + (f2 - f1) * ((2.0 / 3.0) - hue) * 6.0;\n else\n res = f1;\n return res;\n}\nlowp vec3 HSLToRGB(lowp vec3 hsl)\n{\n lowp vec3 rgb;\n if (hsl.y == 0.0)\n rgb = vec3(hsl.z); // Luminance\n else\n {\n lowp float f2;\n if (hsl.z < 0.5)\n f2 = hsl.z * (1.0 + hsl.y);\n else\n f2 = (hsl.z + hsl.y) - (hsl.y * hsl.z);\n lowp float f1 = 2.0 * hsl.z - f2;\n rgb.r = HueToRGB(f1, f2, hsl.x + (1.0/3.0));\n rgb.g = HueToRGB(f1, f2, hsl.x);\n rgb.b= HueToRGB(f1, f2, hsl.x - (1.0/3.0));\n }\n return rgb;\n }\nlowp float RGBToL(lowp vec3 color)\n{\n lowp float fmin = min(min(color.r, color.g), color.b); //Min. value of RGB\n lowp float fmax = max(max(color.r, color.g), color.b); //Max. value of RGB\n return (fmax + fmin) / 2.0; // Luminance\n}\nvoid main()\n{\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n // Alternative way:\n //lowp vec3 lightness = RGBToL(textureColor.rgb);\n lowp vec3 lightness = textureColor.rgb;\n const lowp float a = 0.25;\n const lowp float b = 0.333;\n const lowp float scale = 0.7;\n lowp vec3 shadows = shadowsShift * (clamp((lightness - b) / -a + 0.5, 0.0, 1.0) * scale);\n lowp vec3 midtones = midtonesShift * (clamp((lightness - b) / a + 0.5, 0.0, 1.0) *\n clamp((lightness + b - 1.0) / -a + 0.5, 0.0, 1.0) * scale);\n lowp vec3 highlights = highlightsShift * (clamp((lightness + b - 1.0) / a + 0.5, 0.0, 1.0) * scale);\n mediump vec3 newColor = textureColor.rgb + shadows + midtones + highlights;\n newColor = clamp(newColor, 0.0, 1.0);\n if (preserveLuminosity != 0) {\n lowp vec3 newHSL = RGBToHSL(newColor);\n lowp float oldLum = RGBToL(textureColor.rgb);\n textureColor.rgb = HSLToRGB(vec3(newHSL.x, newHSL.y, oldLum));\n gl_FragColor = textureColor;\n } else {\n gl_FragColor = vec4(newColor.rgb, textureColor.w);\n }\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageColorBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	COLOR_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n highp float lum(lowp vec3 c) {\n return dot(c, vec3(0.3, 0.59, 0.11));\n }\n \n lowp vec3 clipcolor(lowp vec3 c) {\n highp float l = lum(c);\n lowp float n = min(min(c.r, c.g), c.b);\n lowp float x = max(max(c.r, c.g), c.b);\n \n if (n < 0.0) {\n c.r = l + ((c.r - l) * l) / (l - n);\n c.g = l + ((c.g - l) * l) / (l - n);\n c.b = l + ((c.b - l) * l) / (l - n);\n }\n if (x > 1.0) {\n c.r = l + ((c.r - l) * (1.0 - l)) / (x - l);\n c.g = l + ((c.g - l) * (1.0 - l)) / (x - l);\n c.b = l + ((c.b - l) * (1.0 - l)) / (x - l);\n }\n \n return c;\n }\n\n lowp vec3 setlum(lowp vec3 c, highp float l) {\n highp float d = l - lum(c);\n c = c + vec3(d);\n return clipcolor(c);\n }\n \n void main()\n {\n highp vec4 baseColor = texture2D(inputImageTexture, textureCoordinate);\n highp vec4 overlayColor = texture2D(inputImageTexture2, textureCoordinate2);\n\n gl_FragColor = vec4(baseColor.rgb * (1.0 - overlayColor.a) + setlum(overlayColor.rgb, lum(baseColor.rgb)) * overlayColor.a, baseColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageColorBurnBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	COLOR_BURN_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n mediump vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n mediump vec4 whiteColor = vec4(1.0);\n gl_FragColor = whiteColor - (whiteColor - textureColor) / textureColor2;\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageColorDodgeBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	COLOR_DODGE_BLEND_FRAGMENT_SHADER	"precision mediump float;\n \n varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n vec4 base = texture2D(inputImageTexture, textureCoordinate);\n vec4 overlay = texture2D(inputImageTexture2, textureCoordinate2);\n \n vec3 baseOverlayAlphaProduct = vec3(overlay.a * base.a);\n vec3 rightHandProduct = overlay.rgb * (1.0 - base.a) + base.rgb * (1.0 - overlay.a);\n \n vec3 firstBlendColor = baseOverlayAlphaProduct + rightHandProduct;\n vec3 overlayRGB = clamp((overlay.rgb / clamp(overlay.a, 0.01, 1.0)) * step(0.0, overlay.a), 0.0, 0.99);\n \n vec3 secondBlendColor = (base.rgb * overlay.a) / (1.0 - overlayRGB) + rightHandProduct;\n \n vec3 colorChoice = step((overlay.rgb * base.a + base.rgb * overlay.a), baseOverlayAlphaProduct);\n \n gl_FragColor = vec4(mix(firstBlendColor, secondBlendColor, colorChoice), 1.0);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageColorInvertFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	COLOR_INVERT_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = vec4((1.0 - textureColor.rgb), textureColor.w);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageColorMatrixFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	COLOR_MATRIX_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nuniform lowp mat4 colorMatrix;\nuniform lowp float intensity;\n\nvoid main()\n{\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 outputColor = textureColor * colorMatrix;\n \n gl_FragColor = (intensity * outputColor) + ((1.0 - intensity) * textureColor);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageContrastFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	CONTRAST_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform lowp float contrast;\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = vec4(((textureColor.rgb - vec3(0.5)) * contrast + vec3(0.5)), textureColor.w);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageCrosshatchFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	CROSSHATCH_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\nuniform sampler2D inputImageTexture;\nuniform highp float crossHatchSpacing;\nuniform highp float lineWidth;\nconst highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\nvoid main()\n{\nhighp float luminance = dot(texture2D(inputImageTexture, textureCoordinate).rgb, W);\nlowp vec4 colorToDisplay = vec4(1.0, 1.0, 1.0, 1.0);\nif (luminance < 1.00)\n{\nif (mod(textureCoordinate.x + textureCoordinate.y, crossHatchSpacing) <= lineWidth)\n{\ncolorToDisplay = vec4(0.0, 0.0, 0.0, 1.0);\n}\n}\nif (luminance < 0.75)\n{\nif (mod(textureCoordinate.x - textureCoordinate.y, crossHatchSpacing) <= lineWidth)\n{\ncolorToDisplay = vec4(0.0, 0.0, 0.0, 1.0);\n}\n}\nif (luminance < 0.50)\n{\nif (mod(textureCoordinate.x + textureCoordinate.y - (crossHatchSpacing / 2.0), crossHatchSpacing) <= lineWidth)\n{\ncolorToDisplay = vec4(0.0, 0.0, 0.0, 1.0);\n}\n}\nif (luminance < 0.3)\n{\nif (mod(textureCoordinate.x - textureCoordinate.y - (crossHatchSpacing / 2.0), crossHatchSpacing) <= lineWidth)\n{\ncolorToDisplay = vec4(0.0, 0.0, 0.0, 1.0);\n}\n}\ngl_FragColor = colorToDisplay;\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageDarkenBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	DARKEN_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n lowp vec4 base = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 overlayer = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = vec4(min(overlayer.rgb * base.a, base.rgb * overlayer.a) + overlayer.rgb * (1.0 - base.a) + base.rgb * (1.0 - overlayer.a), 1.0);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageDifferenceBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	DIFFERENCE_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n mediump vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n gl_FragColor = vec4(abs(textureColor2.rgb - textureColor.rgb), textureColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageDilationFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	FRAGMENT_SHADER_1	"precision lowp float;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nfloat centerIntensity = texture2D(inputImageTexture, centerTextureCoordinate).r;\nfloat oneStepPositiveIntensity = texture2D(inputImageTexture, oneStepPositiveTextureCoordinate).r;\nfloat oneStepNegativeIntensity = texture2D(inputImageTexture, oneStepNegativeTextureCoordinate).r;\n\nlowp float maxValue = max(centerIntensity, oneStepPositiveIntensity);\nmaxValue = max(maxValue, oneStepNegativeIntensity);\n\ngl_FragColor = vec4(vec3(maxValue), 1.0);\n}\n"
public static final java.lang.String	FRAGMENT_SHADER_2	"precision lowp float;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nfloat centerIntensity = texture2D(inputImageTexture, centerTextureCoordinate).r;\nfloat oneStepPositiveIntensity = texture2D(inputImageTexture, oneStepPositiveTextureCoordinate).r;\nfloat oneStepNegativeIntensity = texture2D(inputImageTexture, oneStepNegativeTextureCoordinate).r;\nfloat twoStepsPositiveIntensity = texture2D(inputImageTexture, twoStepsPositiveTextureCoordinate).r;\nfloat twoStepsNegativeIntensity = texture2D(inputImageTexture, twoStepsNegativeTextureCoordinate).r;\n\nlowp float maxValue = max(centerIntensity, oneStepPositiveIntensity);\nmaxValue = max(maxValue, oneStepNegativeIntensity);\nmaxValue = max(maxValue, twoStepsPositiveIntensity);\nmaxValue = max(maxValue, twoStepsNegativeIntensity);\n\ngl_FragColor = vec4(vec3(maxValue), 1.0);\n}\n"
public static final java.lang.String	FRAGMENT_SHADER_3	"precision lowp float;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\nvarying vec2 threeStepsPositiveTextureCoordinate;\nvarying vec2 threeStepsNegativeTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nfloat centerIntensity = texture2D(inputImageTexture, centerTextureCoordinate).r;\nfloat oneStepPositiveIntensity = texture2D(inputImageTexture, oneStepPositiveTextureCoordinate).r;\nfloat oneStepNegativeIntensity = texture2D(inputImageTexture, oneStepNegativeTextureCoordinate).r;\nfloat twoStepsPositiveIntensity = texture2D(inputImageTexture, twoStepsPositiveTextureCoordinate).r;\nfloat twoStepsNegativeIntensity = texture2D(inputImageTexture, twoStepsNegativeTextureCoordinate).r;\nfloat threeStepsPositiveIntensity = texture2D(inputImageTexture, threeStepsPositiveTextureCoordinate).r;\nfloat threeStepsNegativeIntensity = texture2D(inputImageTexture, threeStepsNegativeTextureCoordinate).r;\n\nlowp float maxValue = max(centerIntensity, oneStepPositiveIntensity);\nmaxValue = max(maxValue, oneStepNegativeIntensity);\nmaxValue = max(maxValue, twoStepsPositiveIntensity);\nmaxValue = max(maxValue, twoStepsNegativeIntensity);\nmaxValue = max(maxValue, threeStepsPositiveIntensity);\nmaxValue = max(maxValue, threeStepsNegativeIntensity);\n\ngl_FragColor = vec4(vec3(maxValue), 1.0);\n}\n"
public static final java.lang.String	FRAGMENT_SHADER_4	"precision lowp float;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\nvarying vec2 threeStepsPositiveTextureCoordinate;\nvarying vec2 threeStepsNegativeTextureCoordinate;\nvarying vec2 fourStepsPositiveTextureCoordinate;\nvarying vec2 fourStepsNegativeTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nfloat centerIntensity = texture2D(inputImageTexture, centerTextureCoordinate).r;\nfloat oneStepPositiveIntensity = texture2D(inputImageTexture, oneStepPositiveTextureCoordinate).r;\nfloat oneStepNegativeIntensity = texture2D(inputImageTexture, oneStepNegativeTextureCoordinate).r;\nfloat twoStepsPositiveIntensity = texture2D(inputImageTexture, twoStepsPositiveTextureCoordinate).r;\nfloat twoStepsNegativeIntensity = texture2D(inputImageTexture, twoStepsNegativeTextureCoordinate).r;\nfloat threeStepsPositiveIntensity = texture2D(inputImageTexture, threeStepsPositiveTextureCoordinate).r;\nfloat threeStepsNegativeIntensity = texture2D(inputImageTexture, threeStepsNegativeTextureCoordinate).r;\nfloat fourStepsPositiveIntensity = texture2D(inputImageTexture, fourStepsPositiveTextureCoordinate).r;\nfloat fourStepsNegativeIntensity = texture2D(inputImageTexture, fourStepsNegativeTextureCoordinate).r;\n\nlowp float maxValue = max(centerIntensity, oneStepPositiveIntensity);\nmaxValue = max(maxValue, oneStepNegativeIntensity);\nmaxValue = max(maxValue, twoStepsPositiveIntensity);\nmaxValue = max(maxValue, twoStepsNegativeIntensity);\nmaxValue = max(maxValue, threeStepsPositiveIntensity);\nmaxValue = max(maxValue, threeStepsNegativeIntensity);\nmaxValue = max(maxValue, fourStepsPositiveIntensity);\nmaxValue = max(maxValue, fourStepsNegativeIntensity);\n\ngl_FragColor = vec4(vec3(maxValue), 1.0);\n}\n"
public static final java.lang.String	VERTEX_SHADER_1	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset; \nuniform float texelHeightOffset; \n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 offset = vec2(texelWidthOffset, texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepNegativeTextureCoordinate = inputTextureCoordinate - offset;\noneStepPositiveTextureCoordinate = inputTextureCoordinate + offset;\n}\n"
public static final java.lang.String	VERTEX_SHADER_2	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset;\nuniform float texelHeightOffset;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 offset = vec2(texelWidthOffset, texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepNegativeTextureCoordinate = inputTextureCoordinate - offset;\noneStepPositiveTextureCoordinate = inputTextureCoordinate + offset;\ntwoStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 2.0);\ntwoStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 2.0);\n}\n"
public static final java.lang.String	VERTEX_SHADER_3	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset;\nuniform float texelHeightOffset;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\nvarying vec2 threeStepsPositiveTextureCoordinate;\nvarying vec2 threeStepsNegativeTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 offset = vec2(texelWidthOffset, texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepNegativeTextureCoordinate = inputTextureCoordinate - offset;\noneStepPositiveTextureCoordinate = inputTextureCoordinate + offset;\ntwoStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 2.0);\ntwoStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 2.0);\nthreeStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 3.0);\nthreeStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 3.0);\n}\n"
public static final java.lang.String	VERTEX_SHADER_4	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset;\nuniform float texelHeightOffset;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\nvarying vec2 threeStepsPositiveTextureCoordinate;\nvarying vec2 threeStepsNegativeTextureCoordinate;\nvarying vec2 fourStepsPositiveTextureCoordinate;\nvarying vec2 fourStepsNegativeTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 offset = vec2(texelWidthOffset, texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepNegativeTextureCoordinate = inputTextureCoordinate - offset;\noneStepPositiveTextureCoordinate = inputTextureCoordinate + offset;\ntwoStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 2.0);\ntwoStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 2.0);\nthreeStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 3.0);\nthreeStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 3.0);\nfourStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 4.0);\nfourStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 4.0);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageDirectionalSobelEdgeDetectionFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	DIRECTIONAL_SOBEL_EDGE_DETECTION_FRAGMENT_SHADER	"precision mediump float;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\n float bottomLeftIntensity = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;\n float topRightIntensity = texture2D(inputImageTexture, topRightTextureCoordinate).r;\n float topLeftIntensity = texture2D(inputImageTexture, topLeftTextureCoordinate).r;\n float bottomRightIntensity = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;\n float leftIntensity = texture2D(inputImageTexture, leftTextureCoordinate).r;\n float rightIntensity = texture2D(inputImageTexture, rightTextureCoordinate).r;\n float bottomIntensity = texture2D(inputImageTexture, bottomTextureCoordinate).r;\n float topIntensity = texture2D(inputImageTexture, topTextureCoordinate).r;\n\n vec2 gradientDirection;\n gradientDirection.x = -bottomLeftIntensity - 2.0 * leftIntensity - topLeftIntensity + bottomRightIntensity + 2.0 * rightIntensity + topRightIntensity;\n gradientDirection.y = -topLeftIntensity - 2.0 * topIntensity - topRightIntensity + bottomLeftIntensity + 2.0 * bottomIntensity + bottomRightIntensity;\n\n float gradientMagnitude = length(gradientDirection);\n vec2 normalizedDirection = normalize(gradientDirection);\n normalizedDirection = sign(normalizedDirection) * floor(abs(normalizedDirection) + 0.617316); // Offset by 1-sin(pi/8) to set to 0 if near axis, 1 if away\n normalizedDirection = (normalizedDirection + 1.0) * 0.5; // Place -1.0 - 1.0 within 0 - 1.0\n\n gl_FragColor = vec4(gradientMagnitude, normalizedDirection.x, normalizedDirection.y, 1.0);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageDissolveBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	DISSOLVE_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n uniform lowp float mixturePercent;\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = mix(textureColor, textureColor2, mixturePercent);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageDivideBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	DIVIDE_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n mediump vec4 base = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 overlay = texture2D(inputImageTexture2, textureCoordinate2);\n \n mediump float ra;\n if (overlay.a == 0.0 || ((base.r / overlay.r) > (base.a / overlay.a)))\n ra = overlay.a * base.a + overlay.r * (1.0 - base.a) + base.r * (1.0 - overlay.a);\n else\n ra = (base.r * overlay.a * overlay.a) / overlay.r + overlay.r * (1.0 - base.a) + base.r * (1.0 - overlay.a);\n \n\n mediump float ga;\n if (overlay.a == 0.0 || ((base.g / overlay.g) > (base.a / overlay.a)))\n ga = overlay.a * base.a + overlay.g * (1.0 - base.a) + base.g * (1.0 - overlay.a);\n else\n ga = (base.g * overlay.a * overlay.a) / overlay.g + overlay.g * (1.0 - base.a) + base.g * (1.0 - overlay.a);\n\n \n mediump float ba;\n if (overlay.a == 0.0 || ((base.b / overlay.b) > (base.a / overlay.a)))\n ba = overlay.a * base.a + overlay.b * (1.0 - base.a) + base.b * (1.0 - overlay.a);\n else\n ba = (base.b * overlay.a * overlay.a) / overlay.b + overlay.b * (1.0 - base.a) + base.b * (1.0 - overlay.a);\n\n mediump float a = overlay.a + base.a - overlay.a * base.a;\n \n gl_FragColor = vec4(ra, ga, ba, a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageExclusionBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	EXCLUSION_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n mediump vec4 base = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 overlay = texture2D(inputImageTexture2, textureCoordinate2);\n \n // Dca = (Sca.Da + Dca.Sa - 2.Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)\n \n gl_FragColor = vec4((overlay.rgb * base.a + base.rgb * overlay.a - 2.0 * overlay.rgb * base.rgb) + overlay.rgb * (1.0 - base.a) + base.rgb * (1.0 - overlay.a), base.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageExposureFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	EXPOSURE_FRAGMENT_SHADER	" varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform highp float exposure;\n \n void main()\n {\n highp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = vec4(textureColor.rgb * pow(2.0, exposure), textureColor.w);\n } "

jp.co.cyberagent.android.gpuimage.filter.GPUImageFalseColorFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	FALSECOLOR_FRAGMENT_SHADER	"precision lowp float;\n\nvarying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\nuniform float intensity;\nuniform vec3 firstColor;\nuniform vec3 secondColor;\n\nconst mediump vec3 luminanceWeighting = vec3(0.2125, 0.7154, 0.0721);\n\nvoid main()\n{\nlowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\nfloat luminance = dot(textureColor.rgb, luminanceWeighting);\n\ngl_FragColor = vec4( mix(firstColor.rgb, secondColor.rgb, luminance), textureColor.a);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	NO_FILTER_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n \nuniform sampler2D inputImageTexture;\n \nvoid main()\n{\n gl_FragColor = texture2D(inputImageTexture, textureCoordinate);\n}"
public static final java.lang.String	NO_FILTER_VERTEX_SHADER	"attribute vec4 position;\nattribute vec4 inputTextureCoordinate;\n \nvarying vec2 textureCoordinate;\n \nvoid main()\n{\n gl_Position = position;\n textureCoordinate = inputTextureCoordinate.xy;\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageGammaFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	GAMMA_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform lowp float gamma;\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = vec4(pow(textureColor.rgb, vec3(gamma)), textureColor.w);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageGaussianBlurFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	FRAGMENT_SHADER	"uniform sampler2D inputImageTexture;\n\nconst lowp int GAUSSIAN_SAMPLES = 9;\n\nvarying highp vec2 textureCoordinate;\nvarying highp vec2 blurCoordinates[GAUSSIAN_SAMPLES];\n\nvoid main()\n{\n\tlowp vec3 sum = vec3(0.0);\n lowp vec4 fragColor=texture2D(inputImageTexture,textureCoordinate);\n\t\n sum += texture2D(inputImageTexture, blurCoordinates[0]).rgb * 0.05;\n sum += texture2D(inputImageTexture, blurCoordinates[1]).rgb * 0.09;\n sum += texture2D(inputImageTexture, blurCoordinates[2]).rgb * 0.12;\n sum += texture2D(inputImageTexture, blurCoordinates[3]).rgb * 0.15;\n sum += texture2D(inputImageTexture, blurCoordinates[4]).rgb * 0.18;\n sum += texture2D(inputImageTexture, blurCoordinates[5]).rgb * 0.15;\n sum += texture2D(inputImageTexture, blurCoordinates[6]).rgb * 0.12;\n sum += texture2D(inputImageTexture, blurCoordinates[7]).rgb * 0.09;\n sum += texture2D(inputImageTexture, blurCoordinates[8]).rgb * 0.05;\n\n\tgl_FragColor = vec4(sum,fragColor.a);\n}"
public static final java.lang.String	VERTEX_SHADER	"attribute vec4 position;\nattribute vec4 inputTextureCoordinate;\n\nconst int GAUSSIAN_SAMPLES = 9;\n\nuniform float texelWidthOffset;\nuniform float texelHeightOffset;\n\nvarying vec2 textureCoordinate;\nvarying vec2 blurCoordinates[GAUSSIAN_SAMPLES];\n\nvoid main()\n{\n\tgl_Position = position;\n\ttextureCoordinate = inputTextureCoordinate.xy;\n\t\n\t// Calculate the positions for the blur\n\tint multiplier = 0;\n\tvec2 blurStep;\n vec2 singleStepOffset = vec2(texelHeightOffset, texelWidthOffset);\n \n\tfor (int i = 0; i < GAUSSIAN_SAMPLES; i++)\n {\n\t\tmultiplier = (i - ((GAUSSIAN_SAMPLES - 1) / 2));\n // Blur in x (horizontal)\n blurStep = float(multiplier) * singleStepOffset;\n\t\tblurCoordinates[i] = inputTextureCoordinate.xy + blurStep;\n\t}\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageGlassSphereFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SPHERE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nuniform highp vec2 center;\nuniform highp float radius;\nuniform highp float aspectRatio;\nuniform highp float refractiveIndex;\n// uniform vec3 lightPosition;\nconst highp vec3 lightPosition = vec3(-0.5, 0.5, 1.0);\nconst highp vec3 ambientLightPosition = vec3(0.0, 0.0, 1.0);\n\nvoid main()\n{\nhighp vec2 textureCoordinateToUse = vec2(textureCoordinate.x, (textureCoordinate.y * aspectRatio + 0.5 - 0.5 * aspectRatio));\nhighp float distanceFromCenter = distance(center, textureCoordinateToUse);\nlowp float checkForPresenceWithinSphere = step(distanceFromCenter, radius);\n\ndistanceFromCenter = distanceFromCenter / radius;\n\nhighp float normalizedDepth = radius * sqrt(1.0 - distanceFromCenter * distanceFromCenter);\nhighp vec3 sphereNormal = normalize(vec3(textureCoordinateToUse - center, normalizedDepth));\n\nhighp vec3 refractedVector = 2.0 * refract(vec3(0.0, 0.0, -1.0), sphereNormal, refractiveIndex);\nrefractedVector.xy = -refractedVector.xy;\n\nhighp vec3 finalSphereColor = texture2D(inputImageTexture, (refractedVector.xy + 1.0) * 0.5).rgb;\n\n// Grazing angle lighting\nhighp float lightingIntensity = 2.5 * (1.0 - pow(clamp(dot(ambientLightPosition, sphereNormal), 0.0, 1.0), 0.25));\nfinalSphereColor += lightingIntensity;\n\n// Specular lighting\nlightingIntensity = clamp(dot(normalize(lightPosition), sphereNormal), 0.0, 1.0);\nlightingIntensity = pow(lightingIntensity, 15.0);\nfinalSphereColor += vec3(0.8, 0.8, 0.8) * lightingIntensity;\n\ngl_FragColor = vec4(finalSphereColor, 1.0) * checkForPresenceWithinSphere;\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageGrayscaleFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	GRAYSCALE_FRAGMENT_SHADER	"precision highp float;\n\nvarying vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nconst highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\n\nvoid main()\n{\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n float luminance = dot(textureColor.rgb, W);\n\n gl_FragColor = vec4(vec3(luminance), textureColor.a);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageHalftoneFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	HALFTONE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\nuniform sampler2D inputImageTexture;\nuniform highp float fractionalWidthOfPixel;\nuniform highp float aspectRatio;\nconst highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\nvoid main()\n{\n highp vec2 sampleDivisor = vec2(fractionalWidthOfPixel, fractionalWidthOfPixel / aspectRatio);\n highp vec2 samplePos = textureCoordinate - mod(textureCoordinate, sampleDivisor) + 0.5 * sampleDivisor;\n highp vec2 textureCoordinateToUse = vec2(textureCoordinate.x, (textureCoordinate.y * aspectRatio + 0.5 - 0.5 * aspectRatio));\n highp vec2 adjustedSamplePos = vec2(samplePos.x, (samplePos.y * aspectRatio + 0.5 - 0.5 * aspectRatio));\n highp float distanceFromSamplePoint = distance(adjustedSamplePos, textureCoordinateToUse);\n lowp vec3 sampledColor = texture2D(inputImageTexture, samplePos).rgb;\n highp float dotScaling = 1.0 - dot(sampledColor, W);\n lowp float checkForPresenceWithinDot = 1.0 - step(distanceFromSamplePoint, (fractionalWidthOfPixel * 0.5) * dotScaling);\n gl_FragColor = vec4(vec3(checkForPresenceWithinDot), 1.0);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageHardLightBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	HARD_LIGHT_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n\n const highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\n\n void main()\n {\n mediump vec4 base = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 overlay = texture2D(inputImageTexture2, textureCoordinate2);\n\n highp float ra;\n if (2.0 * overlay.r < overlay.a) {\n ra = 2.0 * overlay.r * base.r + overlay.r * (1.0 - base.a) + base.r * (1.0 - overlay.a);\n } else {\n ra = overlay.a * base.a - 2.0 * (base.a - base.r) * (overlay.a - overlay.r) + overlay.r * (1.0 - base.a) + base.r * (1.0 - overlay.a);\n }\n \n highp float ga;\n if (2.0 * overlay.g < overlay.a) {\n ga = 2.0 * overlay.g * base.g + overlay.g * (1.0 - base.a) + base.g * (1.0 - overlay.a);\n } else {\n ga = overlay.a * base.a - 2.0 * (base.a - base.g) * (overlay.a - overlay.g) + overlay.g * (1.0 - base.a) + base.g * (1.0 - overlay.a);\n }\n \n highp float ba;\n if (2.0 * overlay.b < overlay.a) {\n ba = 2.0 * overlay.b * base.b + overlay.b * (1.0 - base.a) + base.b * (1.0 - overlay.a);\n } else {\n ba = overlay.a * base.a - 2.0 * (base.a - base.b) * (overlay.a - overlay.b) + overlay.b * (1.0 - base.a) + base.b * (1.0 - overlay.a);\n }\n \n gl_FragColor = vec4(ra, ga, ba, 1.0);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageHazeFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	HAZE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nuniform lowp float distance;\nuniform highp float slope;\n\nvoid main()\n{\n\t//todo reconsider precision modifiers\t \n\t highp vec4 color = vec4(1.0);//todo reimplement as a parameter\n\n\t highp float d = textureCoordinate.y * slope + distance; \n\n\t highp vec4 c = texture2D(inputImageTexture, textureCoordinate) ; // consider using unpremultiply\n\n\t c = (c - d * color) / (1.0 -d);\n\n\t gl_FragColor = c; //consider using premultiply(c);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageHighlightShadowFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	HIGHLIGHT_SHADOW_FRAGMENT_SHADER	" uniform sampler2D inputImageTexture;\n varying highp vec2 textureCoordinate;\n \n uniform lowp float shadows;\n uniform lowp float highlights;\n \n const mediump vec3 luminanceWeighting = vec3(0.3, 0.3, 0.3);\n \n void main()\n {\n \tlowp vec4 source = texture2D(inputImageTexture, textureCoordinate);\n \tmediump float luminance = dot(source.rgb, luminanceWeighting);\n \n \tmediump float shadow = clamp((pow(luminance, 1.0/(shadows+1.0)) + (-0.76)*pow(luminance, 2.0/(shadows+1.0))) - luminance, 0.0, 1.0);\n \tmediump float highlight = clamp((1.0 - (pow(1.0-luminance, 1.0/(2.0-highlights)) + (-0.8)*pow(1.0-luminance, 2.0/(2.0-highlights)))) - luminance, -1.0, 0.0);\n \tlowp vec3 result = vec3(0.0, 0.0, 0.0) + ((luminance + shadow + highlight) - 0.0) * ((source.rgb - vec3(0.0, 0.0, 0.0))/(luminance - 0.0));\n \n \tgl_FragColor = vec4(result.rgb, source.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageHueBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	HUE_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n highp float lum(lowp vec3 c) {\n return dot(c, vec3(0.3, 0.59, 0.11));\n }\n \n lowp vec3 clipcolor(lowp vec3 c) {\n highp float l = lum(c);\n lowp float n = min(min(c.r, c.g), c.b);\n lowp float x = max(max(c.r, c.g), c.b);\n \n if (n < 0.0) {\n c.r = l + ((c.r - l) * l) / (l - n);\n c.g = l + ((c.g - l) * l) / (l - n);\n c.b = l + ((c.b - l) * l) / (l - n);\n }\n if (x > 1.0) {\n c.r = l + ((c.r - l) * (1.0 - l)) / (x - l);\n c.g = l + ((c.g - l) * (1.0 - l)) / (x - l);\n c.b = l + ((c.b - l) * (1.0 - l)) / (x - l);\n }\n \n return c;\n }\n \n lowp vec3 setlum(lowp vec3 c, highp float l) {\n highp float d = l - lum(c);\n c = c + vec3(d);\n return clipcolor(c);\n }\n \n highp float sat(lowp vec3 c) {\n lowp float n = min(min(c.r, c.g), c.b);\n lowp float x = max(max(c.r, c.g), c.b);\n return x - n;\n }\n \n lowp float mid(lowp float cmin, lowp float cmid, lowp float cmax, highp float s) {\n return ((cmid - cmin) * s) / (cmax - cmin);\n }\n \n lowp vec3 setsat(lowp vec3 c, highp float s) {\n if (c.r > c.g) {\n if (c.r > c.b) {\n if (c.g > c.b) {\n /* g is mid, b is min */\n c.g = mid(c.b, c.g, c.r, s);\n c.b = 0.0;\n } else {\n /* b is mid, g is min */\n c.b = mid(c.g, c.b, c.r, s);\n c.g = 0.0;\n }\n c.r = s;\n } else {\n /* b is max, r is mid, g is min */\n c.r = mid(c.g, c.r, c.b, s);\n c.b = s;\n c.r = 0.0;\n }\n } else if (c.r > c.b) {\n /* g is max, r is mid, b is min */\n c.r = mid(c.b, c.r, c.g, s);\n c.g = s;\n c.b = 0.0;\n } else if (c.g > c.b) {\n /* g is max, b is mid, r is min */\n c.b = mid(c.r, c.b, c.g, s);\n c.g = s;\n c.r = 0.0;\n } else if (c.b > c.g) {\n /* b is max, g is mid, r is min */\n c.g = mid(c.r, c.g, c.b, s);\n c.b = s;\n c.r = 0.0;\n } else {\n c = vec3(0.0);\n }\n return c;\n }\n \n void main()\n {\n highp vec4 baseColor = texture2D(inputImageTexture, textureCoordinate);\n highp vec4 overlayColor = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = vec4(baseColor.rgb * (1.0 - overlayColor.a) + setlum(setsat(overlayColor.rgb, sat(baseColor.rgb)), lum(baseColor.rgb)) * overlayColor.a, baseColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageHueFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	HUE_FRAGMENT_SHADER	"precision highp float;\nvarying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\nuniform mediump float hueAdjust;\nconst highp vec4 kRGBToYPrime = vec4 (0.299, 0.587, 0.114, 0.0);\nconst highp vec4 kRGBToI = vec4 (0.595716, -0.274453, -0.321263, 0.0);\nconst highp vec4 kRGBToQ = vec4 (0.211456, -0.522591, 0.31135, 0.0);\n\nconst highp vec4 kYIQToR = vec4 (1.0, 0.9563, 0.6210, 0.0);\nconst highp vec4 kYIQToG = vec4 (1.0, -0.2721, -0.6474, 0.0);\nconst highp vec4 kYIQToB = vec4 (1.0, -1.1070, 1.7046, 0.0);\n\nvoid main ()\n{\n // Sample the input pixel\n highp vec4 color = texture2D(inputImageTexture, textureCoordinate);\n\n // Convert to YIQ\n highp float YPrime = dot (color, kRGBToYPrime);\n highp float I = dot (color, kRGBToI);\n highp float Q = dot (color, kRGBToQ);\n\n // Calculate the hue and chroma\n highp float hue = atan (Q, I);\n highp float chroma = sqrt (I * I + Q * Q);\n\n // Make the user\'s adjustments\n hue += (-hueAdjust); //why negative rotation?\n\n // Convert back to YIQ\n Q = chroma * sin (hue);\n I = chroma * cos (hue);\n\n // Convert back to RGB\n highp vec4 yIQ = vec4 (YPrime, I, Q, 0.0);\n color.r = dot (yIQ, kYIQToR);\n color.g = dot (yIQ, kYIQToG);\n color.b = dot (yIQ, kYIQToB);\n\n // Save the result\n gl_FragColor = color;\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageKuwaharaFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	KUWAHARA_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\nuniform sampler2D inputImageTexture;\nuniform int radius;\n\nprecision highp float;\n\nconst vec2 src_size = vec2 (1.0 / 768.0, 1.0 / 1024.0);\n\nvoid main (void) \n{\nvec2 uv = textureCoordinate;\nfloat n = float((radius + 1) * (radius + 1));\nint i; int j;\nvec3 m0 = vec3(0.0); vec3 m1 = vec3(0.0); vec3 m2 = vec3(0.0); vec3 m3 = vec3(0.0);\nvec3 s0 = vec3(0.0); vec3 s1 = vec3(0.0); vec3 s2 = vec3(0.0); vec3 s3 = vec3(0.0);\nvec3 c;\n\nfor (j = -radius; j <= 0; ++j) {\nfor (i = -radius; i <= 0; ++i) {\nc = texture2D(inputImageTexture, uv + vec2(i,j) * src_size).rgb;\nm0 += c;\ns0 += c * c;\n}\n}\n\nfor (j = -radius; j <= 0; ++j) {\nfor (i = 0; i <= radius; ++i) {\nc = texture2D(inputImageTexture, uv + vec2(i,j) * src_size).rgb;\nm1 += c;\ns1 += c * c;\n}\n}\n\nfor (j = 0; j <= radius; ++j) {\nfor (i = 0; i <= radius; ++i) {\nc = texture2D(inputImageTexture, uv + vec2(i,j) * src_size).rgb;\nm2 += c;\ns2 += c * c;\n}\n}\n\nfor (j = 0; j <= radius; ++j) {\nfor (i = -radius; i <= 0; ++i) {\nc = texture2D(inputImageTexture, uv + vec2(i,j) * src_size).rgb;\nm3 += c;\ns3 += c * c;\n}\n}\n\n\nfloat min_sigma2 = 1e+2;\nm0 /= n;\ns0 = abs(s0 / n - m0 * m0);\n\nfloat sigma2 = s0.r + s0.g + s0.b;\nif (sigma2 < min_sigma2) {\nmin_sigma2 = sigma2;\ngl_FragColor = vec4(m0, 1.0);\n}\n\nm1 /= n;\ns1 = abs(s1 / n - m1 * m1);\n\nsigma2 = s1.r + s1.g + s1.b;\nif (sigma2 < min_sigma2) {\nmin_sigma2 = sigma2;\ngl_FragColor = vec4(m1, 1.0);\n}\n\nm2 /= n;\ns2 = abs(s2 / n - m2 * m2);\n\nsigma2 = s2.r + s2.g + s2.b;\nif (sigma2 < min_sigma2) {\nmin_sigma2 = sigma2;\ngl_FragColor = vec4(m2, 1.0);\n}\n\nm3 /= n;\ns3 = abs(s3 / n - m3 * m3);\n\nsigma2 = s3.r + s3.g + s3.b;\nif (sigma2 < min_sigma2) {\nmin_sigma2 = sigma2;\ngl_FragColor = vec4(m3, 1.0);\n}\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageLaplacianFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	LAPLACIAN_FRAGMENT_SHADER	"precision highp float;\n\nuniform sampler2D inputImageTexture;\n\nuniform mediump mat3 convolutionMatrix;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nvoid main()\n{\nmediump vec3 bottomColor = texture2D(inputImageTexture, bottomTextureCoordinate).rgb;\nmediump vec3 bottomLeftColor = texture2D(inputImageTexture, bottomLeftTextureCoordinate).rgb;\nmediump vec3 bottomRightColor = texture2D(inputImageTexture, bottomRightTextureCoordinate).rgb;\nmediump vec4 centerColor = texture2D(inputImageTexture, textureCoordinate);\nmediump vec3 leftColor = texture2D(inputImageTexture, leftTextureCoordinate).rgb;\nmediump vec3 rightColor = texture2D(inputImageTexture, rightTextureCoordinate).rgb;\nmediump vec3 topColor = texture2D(inputImageTexture, topTextureCoordinate).rgb;\nmediump vec3 topRightColor = texture2D(inputImageTexture, topRightTextureCoordinate).rgb;\nmediump vec3 topLeftColor = texture2D(inputImageTexture, topLeftTextureCoordinate).rgb;\n\nmediump vec3 resultColor = topLeftColor * convolutionMatrix[0][0] + topColor * convolutionMatrix[0][1] + topRightColor * convolutionMatrix[0][2];\nresultColor += leftColor * convolutionMatrix[1][0] + centerColor.rgb * convolutionMatrix[1][1] + rightColor * convolutionMatrix[1][2];\nresultColor += bottomLeftColor * convolutionMatrix[2][0] + bottomColor * convolutionMatrix[2][1] + bottomRightColor * convolutionMatrix[2][2];\n\n// Normalize the results to allow for negative gradients in the 0.0-1.0 colorspace\nresultColor = resultColor + 0.5;\n\ngl_FragColor = vec4(resultColor, centerColor.a);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageLevelsFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	LEVELS_FRAGMET_SHADER	" varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform mediump vec3 levelMinimum;\n uniform mediump vec3 levelMiddle;\n uniform mediump vec3 levelMaximum;\n uniform mediump vec3 minOutput;\n uniform mediump vec3 maxOutput;\n \n void main()\n {\n mediump vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = vec4( mix(minOutput, maxOutput, pow(min(max(textureColor.rgb -levelMinimum, vec3(0.0)) / (levelMaximum - levelMinimum ), vec3(1.0)), 1.0 /levelMiddle)) , textureColor.a);\n }\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageLightenBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	LIGHTEN_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = max(textureColor, textureColor2);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageLinearBurnBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	LINEAR_BURN_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n mediump vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = vec4(clamp(textureColor.rgb + textureColor2.rgb - vec3(1.0), vec3(0.0), vec3(1.0)), textureColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageLookupFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	LOOKUP_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2; // TODO: This is not used\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2; // lookup texture\n \n uniform lowp float intensity;\n \n void main()\n {\n highp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n highp float blueColor = textureColor.b * 63.0;\n \n highp vec2 quad1;\n quad1.y = floor(floor(blueColor) / 8.0);\n quad1.x = floor(blueColor) - (quad1.y * 8.0);\n \n highp vec2 quad2;\n quad2.y = floor(ceil(blueColor) / 8.0);\n quad2.x = ceil(blueColor) - (quad2.y * 8.0);\n \n highp vec2 texPos1;\n texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);\n texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);\n \n highp vec2 texPos2;\n texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);\n texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);\n \n lowp vec4 newColor1 = texture2D(inputImageTexture2, texPos1);\n lowp vec4 newColor2 = texture2D(inputImageTexture2, texPos2);\n \n lowp vec4 newColor = mix(newColor1, newColor2, fract(blueColor));\n gl_FragColor = mix(textureColor, vec4(newColor.rgb, textureColor.w), intensity);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageLuminanceFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	LUMINANCE_FRAGMENT_SHADER	"precision highp float;\n\nvarying vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\n// Values from \"Graphics Shaders: Theory and Practice\" by Bailey and Cunningham\nconst highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\n\nvoid main()\n{\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n float luminance = dot(textureColor.rgb, W);\n \n gl_FragColor = vec4(vec3(luminance), textureColor.a);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageLuminanceThresholdFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	LUMINANCE_THRESHOLD_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\nuniform highp float threshold;\n\nconst highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\n\nvoid main()\n{\n highp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n highp float luminance = dot(textureColor.rgb, W);\n highp float thresholdResult = step(threshold, luminance);\n \n gl_FragColor = vec4(vec3(thresholdResult), textureColor.w);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageLuminosityBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	LUMINOSITY_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n highp float lum(lowp vec3 c) {\n return dot(c, vec3(0.3, 0.59, 0.11));\n }\n \n lowp vec3 clipcolor(lowp vec3 c) {\n highp float l = lum(c);\n lowp float n = min(min(c.r, c.g), c.b);\n lowp float x = max(max(c.r, c.g), c.b);\n \n if (n < 0.0) {\n c.r = l + ((c.r - l) * l) / (l - n);\n c.g = l + ((c.g - l) * l) / (l - n);\n c.b = l + ((c.b - l) * l) / (l - n);\n }\n if (x > 1.0) {\n c.r = l + ((c.r - l) * (1.0 - l)) / (x - l);\n c.g = l + ((c.g - l) * (1.0 - l)) / (x - l);\n c.b = l + ((c.b - l) * (1.0 - l)) / (x - l);\n }\n \n return c;\n }\n \n lowp vec3 setlum(lowp vec3 c, highp float l) {\n highp float d = l - lum(c);\n c = c + vec3(d);\n return clipcolor(c);\n }\n \n void main()\n {\n highp vec4 baseColor = texture2D(inputImageTexture, textureCoordinate);\n highp vec4 overlayColor = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = vec4(baseColor.rgb * (1.0 - overlayColor.a) + setlum(baseColor.rgb, lum(overlayColor.rgb)) * overlayColor.a, baseColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageMonochromeFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	MONOCHROME_FRAGMENT_SHADER	" precision lowp float;\n \n varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform float intensity;\n uniform vec3 filterColor;\n \n const mediump vec3 luminanceWeighting = vec3(0.2125, 0.7154, 0.0721);\n \n void main()\n {\n \t//desat, then apply overlay blend\n \tlowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \tfloat luminance = dot(textureColor.rgb, luminanceWeighting);\n \t\n \tlowp vec4 desat = vec4(vec3(luminance), 1.0);\n \t\n \t//overlay\n \tlowp vec4 outputColor = vec4(\n (desat.r < 0.5 ? (2.0 * desat.r * filterColor.r) : (1.0 - 2.0 * (1.0 - desat.r) * (1.0 - filterColor.r))),\n (desat.g < 0.5 ? (2.0 * desat.g * filterColor.g) : (1.0 - 2.0 * (1.0 - desat.g) * (1.0 - filterColor.g))),\n (desat.b < 0.5 ? (2.0 * desat.b * filterColor.b) : (1.0 - 2.0 * (1.0 - desat.b) * (1.0 - filterColor.b))),\n 1.0\n );\n \t\n \t//which is better, or are they equal?\n \tgl_FragColor = vec4( mix(textureColor.rgb, outputColor.rgb, intensity), textureColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageMultiplyBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	MULTIPLY_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n lowp vec4 base = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 overlayer = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = overlayer * base + overlayer * (1.0 - base.a) + base * (1.0 - overlayer.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageNonMaximumSuppressionFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	NMS_FRAGMENT_SHADER	"uniform sampler2D inputImageTexture;\n\nvarying highp vec2 textureCoordinate;\nvarying highp vec2 leftTextureCoordinate;\nvarying highp vec2 rightTextureCoordinate;\n\nvarying highp vec2 topTextureCoordinate;\nvarying highp vec2 topLeftTextureCoordinate;\nvarying highp vec2 topRightTextureCoordinate;\n\nvarying highp vec2 bottomTextureCoordinate;\nvarying highp vec2 bottomLeftTextureCoordinate;\nvarying highp vec2 bottomRightTextureCoordinate;\n\nvoid main()\n{\nlowp float bottomColor = texture2D(inputImageTexture, bottomTextureCoordinate).r;\nlowp float bottomLeftColor = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;\nlowp float bottomRightColor = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;\nlowp vec4 centerColor = texture2D(inputImageTexture, textureCoordinate);\nlowp float leftColor = texture2D(inputImageTexture, leftTextureCoordinate).r;\nlowp float rightColor = texture2D(inputImageTexture, rightTextureCoordinate).r;\nlowp float topColor = texture2D(inputImageTexture, topTextureCoordinate).r;\nlowp float topRightColor = texture2D(inputImageTexture, topRightTextureCoordinate).r;\nlowp float topLeftColor = texture2D(inputImageTexture, topLeftTextureCoordinate).r;\n\n// Use a tiebreaker for pixels to the left and immediately above this one\nlowp float multiplier = 1.0 - step(centerColor.r, topColor);\nmultiplier = multiplier * 1.0 - step(centerColor.r, topLeftColor);\nmultiplier = multiplier * 1.0 - step(centerColor.r, leftColor);\nmultiplier = multiplier * 1.0 - step(centerColor.r, bottomLeftColor);\n\nlowp float maxValue = max(centerColor.r, bottomColor);\nmaxValue = max(maxValue, bottomRightColor);\nmaxValue = max(maxValue, rightColor);\nmaxValue = max(maxValue, topRightColor);\n\ngl_FragColor = vec4((centerColor.rgb * step(maxValue, centerColor.r) * multiplier), 1.0);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageNormalBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	NORMAL_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n lowp vec4 c2 = texture2D(inputImageTexture, textureCoordinate);\n\t lowp vec4 c1 = texture2D(inputImageTexture2, textureCoordinate2);\n \n lowp vec4 outputColor;\n \n outputColor.r = c1.r + c2.r * c2.a * (1.0 - c1.a);\n\n outputColor.g = c1.g + c2.g * c2.a * (1.0 - c1.a);\n \n outputColor.b = c1.b + c2.b * c2.a * (1.0 - c1.a);\n \n outputColor.a = c1.a + c2.a * (1.0 - c1.a);\n \n gl_FragColor = outputColor;\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageOpacityFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	OPACITY_FRAGMENT_SHADER	" varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform lowp float opacity;\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = vec4(textureColor.rgb, textureColor.a * opacity);\n }\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageOverlayBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	OVERLAY_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n mediump vec4 base = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 overlay = texture2D(inputImageTexture2, textureCoordinate2);\n \n mediump float ra;\n if (2.0 * base.r < base.a) {\n ra = 2.0 * overlay.r * base.r + overlay.r * (1.0 - base.a) + base.r * (1.0 - overlay.a);\n } else {\n ra = overlay.a * base.a - 2.0 * (base.a - base.r) * (overlay.a - overlay.r) + overlay.r * (1.0 - base.a) + base.r * (1.0 - overlay.a);\n }\n \n mediump float ga;\n if (2.0 * base.g < base.a) {\n ga = 2.0 * overlay.g * base.g + overlay.g * (1.0 - base.a) + base.g * (1.0 - overlay.a);\n } else {\n ga = overlay.a * base.a - 2.0 * (base.a - base.g) * (overlay.a - overlay.g) + overlay.g * (1.0 - base.a) + base.g * (1.0 - overlay.a);\n }\n \n mediump float ba;\n if (2.0 * base.b < base.a) {\n ba = 2.0 * overlay.b * base.b + overlay.b * (1.0 - base.a) + base.b * (1.0 - overlay.a);\n } else {\n ba = overlay.a * base.a - 2.0 * (base.a - base.b) * (overlay.a - overlay.b) + overlay.b * (1.0 - base.a) + base.b * (1.0 - overlay.a);\n }\n \n gl_FragColor = vec4(ra, ga, ba, 1.0);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImagePixelationFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	PIXELATION_FRAGMENT_SHADER	"precision highp float;\nvarying vec2 textureCoordinate;\nuniform float imageWidthFactor;\nuniform float imageHeightFactor;\nuniform sampler2D inputImageTexture;\nuniform float pixel;\nvoid main()\n{\n vec2 uv = textureCoordinate.xy;\n float dx = pixel * imageWidthFactor;\n float dy = pixel * imageHeightFactor;\n vec2 coord = vec2(dx * floor(uv.x / dx), dy * floor(uv.y / dy));\n vec3 tc = texture2D(inputImageTexture, coord).xyz;\n gl_FragColor = vec4(tc, 1.0);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImagePosterizeFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	POSTERIZE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\nuniform highp float colorLevels;\n\nvoid main()\n{\n highp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = floor((textureColor * colorLevels) + vec4(0.5)) / colorLevels;\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageRGBDilationFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	FRAGMENT_SHADER_1	"precision highp float;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nlowp vec4 centerIntensity = texture2D(inputImageTexture, centerTextureCoordinate);\nlowp vec4 oneStepPositiveIntensity = texture2D(inputImageTexture, oneStepPositiveTextureCoordinate);\nlowp vec4 oneStepNegativeIntensity = texture2D(inputImageTexture, oneStepNegativeTextureCoordinate);\n\nlowp vec4 maxValue = max(centerIntensity, oneStepPositiveIntensity);\n\ngl_FragColor = max(maxValue, oneStepNegativeIntensity);\n}\n"
public static final java.lang.String	FRAGMENT_SHADER_2	"precision highp float;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nlowp vec4 centerIntensity = texture2D(inputImageTexture, centerTextureCoordinate);\nlowp vec4 oneStepPositiveIntensity = texture2D(inputImageTexture, oneStepPositiveTextureCoordinate);\nlowp vec4 oneStepNegativeIntensity = texture2D(inputImageTexture, oneStepNegativeTextureCoordinate);\nlowp vec4 twoStepsPositiveIntensity = texture2D(inputImageTexture, twoStepsPositiveTextureCoordinate);\nlowp vec4 twoStepsNegativeIntensity = texture2D(inputImageTexture, twoStepsNegativeTextureCoordinate);\n\nlowp vec4 maxValue = max(centerIntensity, oneStepPositiveIntensity);\nmaxValue = max(maxValue, oneStepNegativeIntensity);\nmaxValue = max(maxValue, twoStepsPositiveIntensity);\nmaxValue = max(maxValue, twoStepsNegativeIntensity);\n\ngl_FragColor = max(maxValue, twoStepsNegativeIntensity);\n}\n"
public static final java.lang.String	FRAGMENT_SHADER_3	"precision highp float;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\nvarying vec2 threeStepsPositiveTextureCoordinate;\nvarying vec2 threeStepsNegativeTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nlowp vec4 centerIntensity = texture2D(inputImageTexture, centerTextureCoordinate);\nlowp vec4 oneStepPositiveIntensity = texture2D(inputImageTexture, oneStepPositiveTextureCoordinate);\nlowp vec4 oneStepNegativeIntensity = texture2D(inputImageTexture, oneStepNegativeTextureCoordinate);\nlowp vec4 twoStepsPositiveIntensity = texture2D(inputImageTexture, twoStepsPositiveTextureCoordinate);\nlowp vec4 twoStepsNegativeIntensity = texture2D(inputImageTexture, twoStepsNegativeTextureCoordinate);\nlowp vec4 threeStepsPositiveIntensity = texture2D(inputImageTexture, threeStepsPositiveTextureCoordinate);\nlowp vec4 threeStepsNegativeIntensity = texture2D(inputImageTexture, threeStepsNegativeTextureCoordinate);\n\nlowp vec4 maxValue = max(centerIntensity, oneStepPositiveIntensity);\nmaxValue = max(maxValue, oneStepNegativeIntensity);\nmaxValue = max(maxValue, twoStepsPositiveIntensity);\nmaxValue = max(maxValue, twoStepsNegativeIntensity);\nmaxValue = max(maxValue, threeStepsPositiveIntensity);\n\ngl_FragColor = max(maxValue, threeStepsNegativeIntensity);\n}\n"
public static final java.lang.String	FRAGMENT_SHADER_4	"precision highp float;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\nvarying vec2 threeStepsPositiveTextureCoordinate;\nvarying vec2 threeStepsNegativeTextureCoordinate;\nvarying vec2 fourStepsPositiveTextureCoordinate;\nvarying vec2 fourStepsNegativeTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nlowp vec4 centerIntensity = texture2D(inputImageTexture, centerTextureCoordinate);\nlowp vec4 oneStepPositiveIntensity = texture2D(inputImageTexture, oneStepPositiveTextureCoordinate);\nlowp vec4 oneStepNegativeIntensity = texture2D(inputImageTexture, oneStepNegativeTextureCoordinate);\nlowp vec4 twoStepsPositiveIntensity = texture2D(inputImageTexture, twoStepsPositiveTextureCoordinate);\nlowp vec4 twoStepsNegativeIntensity = texture2D(inputImageTexture, twoStepsNegativeTextureCoordinate);\nlowp vec4 threeStepsPositiveIntensity = texture2D(inputImageTexture, threeStepsPositiveTextureCoordinate);\nlowp vec4 threeStepsNegativeIntensity = texture2D(inputImageTexture, threeStepsNegativeTextureCoordinate);\nlowp vec4 fourStepsPositiveIntensity = texture2D(inputImageTexture, fourStepsPositiveTextureCoordinate);\nlowp vec4 fourStepsNegativeIntensity = texture2D(inputImageTexture, fourStepsNegativeTextureCoordinate);\n\nlowp vec4 maxValue = max(centerIntensity, oneStepPositiveIntensity);\nmaxValue = max(maxValue, oneStepNegativeIntensity);\nmaxValue = max(maxValue, twoStepsPositiveIntensity);\nmaxValue = max(maxValue, twoStepsNegativeIntensity);\nmaxValue = max(maxValue, threeStepsPositiveIntensity);\nmaxValue = max(maxValue, threeStepsNegativeIntensity);\nmaxValue = max(maxValue, fourStepsPositiveIntensity);\n\ngl_FragColor = max(maxValue, fourStepsNegativeIntensity);\n}\n"
public static final java.lang.String	VERTEX_SHADER_1	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset; \nuniform float texelHeightOffset; \n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 offset = vec2(texelWidthOffset, texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepNegativeTextureCoordinate = inputTextureCoordinate - offset;\noneStepPositiveTextureCoordinate = inputTextureCoordinate + offset;\n}\n"
public static final java.lang.String	VERTEX_SHADER_2	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset;\nuniform float texelHeightOffset;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 offset = vec2(texelWidthOffset, texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepNegativeTextureCoordinate = inputTextureCoordinate - offset;\noneStepPositiveTextureCoordinate = inputTextureCoordinate + offset;\ntwoStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 2.0);\ntwoStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 2.0);\n}\n"
public static final java.lang.String	VERTEX_SHADER_3	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset;\nuniform float texelHeightOffset;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\nvarying vec2 threeStepsPositiveTextureCoordinate;\nvarying vec2 threeStepsNegativeTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 offset = vec2(texelWidthOffset, texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepNegativeTextureCoordinate = inputTextureCoordinate - offset;\noneStepPositiveTextureCoordinate = inputTextureCoordinate + offset;\ntwoStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 2.0);\ntwoStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 2.0);\nthreeStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 3.0);\nthreeStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 3.0);\n}\n"
public static final java.lang.String	VERTEX_SHADER_4	"attribute vec4 position;\nattribute vec2 inputTextureCoordinate;\n\nuniform float texelWidthOffset;\nuniform float texelHeightOffset;\n\nvarying vec2 centerTextureCoordinate;\nvarying vec2 oneStepPositiveTextureCoordinate;\nvarying vec2 oneStepNegativeTextureCoordinate;\nvarying vec2 twoStepsPositiveTextureCoordinate;\nvarying vec2 twoStepsNegativeTextureCoordinate;\nvarying vec2 threeStepsPositiveTextureCoordinate;\nvarying vec2 threeStepsNegativeTextureCoordinate;\nvarying vec2 fourStepsPositiveTextureCoordinate;\nvarying vec2 fourStepsNegativeTextureCoordinate;\n\nvoid main()\n{\ngl_Position = position;\n\nvec2 offset = vec2(texelWidthOffset, texelHeightOffset);\n\ncenterTextureCoordinate = inputTextureCoordinate;\noneStepNegativeTextureCoordinate = inputTextureCoordinate - offset;\noneStepPositiveTextureCoordinate = inputTextureCoordinate + offset;\ntwoStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 2.0);\ntwoStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 2.0);\nthreeStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 3.0);\nthreeStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 3.0);\nfourStepsNegativeTextureCoordinate = inputTextureCoordinate - (offset * 4.0);\nfourStepsPositiveTextureCoordinate = inputTextureCoordinate + (offset * 4.0);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageRGBFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	RGB_FRAGMENT_SHADER	" varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform highp float red;\n uniform highp float green;\n uniform highp float blue;\n \n void main()\n {\n highp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n \n gl_FragColor = vec4(textureColor.r * red, textureColor.g * green, textureColor.b * blue, 1.0);\n }\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSaturationBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SATURATION_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n highp float lum(lowp vec3 c) {\n return dot(c, vec3(0.3, 0.59, 0.11));\n }\n \n lowp vec3 clipcolor(lowp vec3 c) {\n highp float l = lum(c);\n lowp float n = min(min(c.r, c.g), c.b);\n lowp float x = max(max(c.r, c.g), c.b);\n \n if (n < 0.0) {\n c.r = l + ((c.r - l) * l) / (l - n);\n c.g = l + ((c.g - l) * l) / (l - n);\n c.b = l + ((c.b - l) * l) / (l - n);\n }\n if (x > 1.0) {\n c.r = l + ((c.r - l) * (1.0 - l)) / (x - l);\n c.g = l + ((c.g - l) * (1.0 - l)) / (x - l);\n c.b = l + ((c.b - l) * (1.0 - l)) / (x - l);\n }\n \n return c;\n }\n \n lowp vec3 setlum(lowp vec3 c, highp float l) {\n highp float d = l - lum(c);\n c = c + vec3(d);\n return clipcolor(c);\n }\n \n highp float sat(lowp vec3 c) {\n lowp float n = min(min(c.r, c.g), c.b);\n lowp float x = max(max(c.r, c.g), c.b);\n return x - n;\n }\n \n lowp float mid(lowp float cmin, lowp float cmid, lowp float cmax, highp float s) {\n return ((cmid - cmin) * s) / (cmax - cmin);\n }\n \n lowp vec3 setsat(lowp vec3 c, highp float s) {\n if (c.r > c.g) {\n if (c.r > c.b) {\n if (c.g > c.b) {\n /* g is mid, b is min */\n c.g = mid(c.b, c.g, c.r, s);\n c.b = 0.0;\n } else {\n /* b is mid, g is min */\n c.b = mid(c.g, c.b, c.r, s);\n c.g = 0.0;\n }\n c.r = s;\n } else {\n /* b is max, r is mid, g is min */\n c.r = mid(c.g, c.r, c.b, s);\n c.b = s;\n c.r = 0.0;\n }\n } else if (c.r > c.b) {\n /* g is max, r is mid, b is min */\n c.r = mid(c.b, c.r, c.g, s);\n c.g = s;\n c.b = 0.0;\n } else if (c.g > c.b) {\n /* g is max, b is mid, r is min */\n c.b = mid(c.r, c.b, c.g, s);\n c.g = s;\n c.r = 0.0;\n } else if (c.b > c.g) {\n /* b is max, g is mid, r is min */\n c.g = mid(c.r, c.g, c.b, s);\n c.b = s;\n c.r = 0.0;\n } else {\n c = vec3(0.0);\n }\n return c;\n }\n \n void main()\n {\n highp vec4 baseColor = texture2D(inputImageTexture, textureCoordinate);\n highp vec4 overlayColor = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = vec4(baseColor.rgb * (1.0 - overlayColor.a) + setlum(setsat(baseColor.rgb, sat(overlayColor.rgb)), lum(baseColor.rgb)) * overlayColor.a, baseColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSaturationFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SATURATION_FRAGMENT_SHADER	" varying highp vec2 textureCoordinate;\n \n uniform sampler2D inputImageTexture;\n uniform lowp float saturation;\n \n // Values from \"Graphics Shaders: Theory and Practice\" by Bailey and Cunningham\n const mediump vec3 luminanceWeighting = vec3(0.2125, 0.7154, 0.0721);\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n lowp float luminance = dot(textureColor.rgb, luminanceWeighting);\n lowp vec3 greyScaleColor = vec3(luminance);\n \n gl_FragColor = vec4(mix(greyScaleColor, textureColor.rgb, saturation), textureColor.w);\n \n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageScreenBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SCREEN_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n mediump vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n mediump vec4 whiteColor = vec4(1.0);\n gl_FragColor = whiteColor - ((whiteColor - textureColor2) * (whiteColor - textureColor));\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSharpenFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SHARPEN_FRAGMENT_SHADER	"precision highp float;\n\nvarying highp vec2 textureCoordinate;\nvarying highp vec2 leftTextureCoordinate;\nvarying highp vec2 rightTextureCoordinate; \nvarying highp vec2 topTextureCoordinate;\nvarying highp vec2 bottomTextureCoordinate;\n\nvarying highp float centerMultiplier;\nvarying highp float edgeMultiplier;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\n mediump vec3 textureColor = texture2D(inputImageTexture, textureCoordinate).rgb;\n mediump vec3 leftTextureColor = texture2D(inputImageTexture, leftTextureCoordinate).rgb;\n mediump vec3 rightTextureColor = texture2D(inputImageTexture, rightTextureCoordinate).rgb;\n mediump vec3 topTextureColor = texture2D(inputImageTexture, topTextureCoordinate).rgb;\n mediump vec3 bottomTextureColor = texture2D(inputImageTexture, bottomTextureCoordinate).rgb;\n\n gl_FragColor = vec4((textureColor * centerMultiplier - (leftTextureColor * edgeMultiplier + rightTextureColor * edgeMultiplier + topTextureColor * edgeMultiplier + bottomTextureColor * edgeMultiplier)), texture2D(inputImageTexture, bottomTextureCoordinate).w);\n}"
public static final java.lang.String	SHARPEN_VERTEX_SHADER	"attribute vec4 position;\nattribute vec4 inputTextureCoordinate;\n\nuniform float imageWidthFactor; \nuniform float imageHeightFactor; \nuniform float sharpness;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate; \nvarying vec2 topTextureCoordinate;\nvarying vec2 bottomTextureCoordinate;\n\nvarying float centerMultiplier;\nvarying float edgeMultiplier;\n\nvoid main()\n{\n gl_Position = position;\n \n mediump vec2 widthStep = vec2(imageWidthFactor, 0.0);\n mediump vec2 heightStep = vec2(0.0, imageHeightFactor);\n \n textureCoordinate = inputTextureCoordinate.xy;\n leftTextureCoordinate = inputTextureCoordinate.xy - widthStep;\n rightTextureCoordinate = inputTextureCoordinate.xy + widthStep;\n topTextureCoordinate = inputTextureCoordinate.xy + heightStep; \n bottomTextureCoordinate = inputTextureCoordinate.xy - heightStep;\n \n centerMultiplier = 1.0 + 4.0 * sharpness;\n edgeMultiplier = sharpness;\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSketchFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SKETCH_FRAGMENT_SHADER	"precision mediump float;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nfloat bottomLeftIntensity = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;\nfloat topRightIntensity = texture2D(inputImageTexture, topRightTextureCoordinate).r;\nfloat topLeftIntensity = texture2D(inputImageTexture, topLeftTextureCoordinate).r;\nfloat bottomRightIntensity = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;\nfloat leftIntensity = texture2D(inputImageTexture, leftTextureCoordinate).r;\nfloat rightIntensity = texture2D(inputImageTexture, rightTextureCoordinate).r;\nfloat bottomIntensity = texture2D(inputImageTexture, bottomTextureCoordinate).r;\nfloat topIntensity = texture2D(inputImageTexture, topTextureCoordinate).r;\nfloat h = -topLeftIntensity - 2.0 * topIntensity - topRightIntensity + bottomLeftIntensity + 2.0 * bottomIntensity + bottomRightIntensity;\nfloat v = -bottomLeftIntensity - 2.0 * leftIntensity - topLeftIntensity + bottomRightIntensity + 2.0 * rightIntensity + topRightIntensity;\n\nfloat mag = 1.0 - length(vec2(h, v));\n\ngl_FragColor = vec4(vec3(mag), 1.0);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSobelEdgeDetectionFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SOBEL_EDGE_DETECTION	"precision mediump float;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\n float bottomLeftIntensity = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;\n float topRightIntensity = texture2D(inputImageTexture, topRightTextureCoordinate).r;\n float topLeftIntensity = texture2D(inputImageTexture, topLeftTextureCoordinate).r;\n float bottomRightIntensity = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;\n float leftIntensity = texture2D(inputImageTexture, leftTextureCoordinate).r;\n float rightIntensity = texture2D(inputImageTexture, rightTextureCoordinate).r;\n float bottomIntensity = texture2D(inputImageTexture, bottomTextureCoordinate).r;\n float topIntensity = texture2D(inputImageTexture, topTextureCoordinate).r;\n float h = -topLeftIntensity - 2.0 * topIntensity - topRightIntensity + bottomLeftIntensity + 2.0 * bottomIntensity + bottomRightIntensity;\n float v = -bottomLeftIntensity - 2.0 * leftIntensity - topLeftIntensity + bottomRightIntensity + 2.0 * rightIntensity + topRightIntensity;\n\n float mag = length(vec2(h, v));\n\n gl_FragColor = vec4(vec3(mag), 1.0);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSobelThresholdFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SOBEL_THRESHOLD_EDGE_DETECTION	"precision mediump float;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\nuniform lowp float threshold;\n\nconst highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\n\nvoid main()\n{\n float bottomLeftIntensity = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;\n float topRightIntensity = texture2D(inputImageTexture, topRightTextureCoordinate).r;\n float topLeftIntensity = texture2D(inputImageTexture, topLeftTextureCoordinate).r;\n float bottomRightIntensity = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;\n float leftIntensity = texture2D(inputImageTexture, leftTextureCoordinate).r;\n float rightIntensity = texture2D(inputImageTexture, rightTextureCoordinate).r;\n float bottomIntensity = texture2D(inputImageTexture, bottomTextureCoordinate).r;\n float topIntensity = texture2D(inputImageTexture, topTextureCoordinate).r;\n float h = -topLeftIntensity - 2.0 * topIntensity - topRightIntensity + bottomLeftIntensity + 2.0 * bottomIntensity + bottomRightIntensity;\n float v = -bottomLeftIntensity - 2.0 * leftIntensity - topLeftIntensity + bottomRightIntensity + 2.0 * rightIntensity + topRightIntensity;\n\n float mag = 1.0 - length(vec2(h, v));\n mag = step(threshold, mag);\n\n gl_FragColor = vec4(vec3(mag), 1.0);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSoftLightBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SOFT_LIGHT_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n mediump vec4 base = texture2D(inputImageTexture, textureCoordinate);\n mediump vec4 overlay = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = base * (overlay.a * (base / base.a) + (2.0 * overlay * (1.0 - (base / base.a)))) + overlay * (1.0 - base.a) + base * (1.0 - overlay.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSolarizeFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SOLATIZE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\nuniform highp float threshold;\n\nconst highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\n\nvoid main()\n{\n highp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n highp float luminance = dot(textureColor.rgb, W);\n highp float thresholdResult = step(luminance, threshold);\n highp vec3 finalColor = abs(thresholdResult - textureColor.rgb);\n \n gl_FragColor = vec4(finalColor, textureColor.w);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSourceOverBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SOURCE_OVER_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n \n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n \n gl_FragColor = mix(textureColor, textureColor2, textureColor2.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSphereRefractionFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SPHERE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nuniform highp vec2 center;\nuniform highp float radius;\nuniform highp float aspectRatio;\nuniform highp float refractiveIndex;\n\nvoid main()\n{\nhighp vec2 textureCoordinateToUse = vec2(textureCoordinate.x, (textureCoordinate.y * aspectRatio + 0.5 - 0.5 * aspectRatio));\nhighp float distanceFromCenter = distance(center, textureCoordinateToUse);\nlowp float checkForPresenceWithinSphere = step(distanceFromCenter, radius);\n\ndistanceFromCenter = distanceFromCenter / radius;\n\nhighp float normalizedDepth = radius * sqrt(1.0 - distanceFromCenter * distanceFromCenter);\nhighp vec3 sphereNormal = normalize(vec3(textureCoordinateToUse - center, normalizedDepth));\n\nhighp vec3 refractedVector = refract(vec3(0.0, 0.0, -1.0), sphereNormal, refractiveIndex);\n\ngl_FragColor = texture2D(inputImageTexture, (refractedVector.xy + 1.0) * 0.5) * checkForPresenceWithinSphere; \n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSubtractBlendFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SUBTRACT_BLEND_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n varying highp vec2 textureCoordinate2;\n\n uniform sampler2D inputImageTexture;\n uniform sampler2D inputImageTexture2;\n \n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n lowp vec4 textureColor2 = texture2D(inputImageTexture2, textureCoordinate2);\n\n gl_FragColor = vec4(textureColor.rgb - textureColor2.rgb, textureColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageSwirlFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	SWIRL_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nuniform highp vec2 center;\nuniform highp float radius;\nuniform highp float angle;\n\nvoid main()\n{\nhighp vec2 textureCoordinateToUse = textureCoordinate;\nhighp float dist = distance(center, textureCoordinate);\nif (dist < radius)\n{\ntextureCoordinateToUse -= center;\nhighp float percent = (radius - dist) / radius;\nhighp float theta = percent * percent * angle * 8.0;\nhighp float s = sin(theta);\nhighp float c = cos(theta);\ntextureCoordinateToUse = vec2(dot(textureCoordinateToUse, vec2(c, -s)), dot(textureCoordinateToUse, vec2(s, c)));\ntextureCoordinateToUse += center;\n}\n\ngl_FragColor = texture2D(inputImageTexture, textureCoordinateToUse );\n\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageToneCurveFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	TONE_CURVE_FRAGMENT_SHADER	" varying highp vec2 textureCoordinate;\n uniform sampler2D inputImageTexture;\n uniform sampler2D toneCurveTexture;\n\n void main()\n {\n lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n lowp float redCurveValue = texture2D(toneCurveTexture, vec2(textureColor.r, 0.0)).r;\n lowp float greenCurveValue = texture2D(toneCurveTexture, vec2(textureColor.g, 0.0)).g;\n lowp float blueCurveValue = texture2D(toneCurveTexture, vec2(textureColor.b, 0.0)).b;\n\n gl_FragColor = vec4(redCurveValue, greenCurveValue, blueCurveValue, textureColor.a);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageToonFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	TOON_FRAGMENT_SHADER	"precision highp float;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nuniform highp float intensity;\nuniform highp float threshold;\nuniform highp float quantizationLevels;\n\nconst highp vec3 W = vec3(0.2125, 0.7154, 0.0721);\n\nvoid main()\n{\nvec4 textureColor = texture2D(inputImageTexture, textureCoordinate);\n\nfloat bottomLeftIntensity = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;\nfloat topRightIntensity = texture2D(inputImageTexture, topRightTextureCoordinate).r;\nfloat topLeftIntensity = texture2D(inputImageTexture, topLeftTextureCoordinate).r;\nfloat bottomRightIntensity = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;\nfloat leftIntensity = texture2D(inputImageTexture, leftTextureCoordinate).r;\nfloat rightIntensity = texture2D(inputImageTexture, rightTextureCoordinate).r;\nfloat bottomIntensity = texture2D(inputImageTexture, bottomTextureCoordinate).r;\nfloat topIntensity = texture2D(inputImageTexture, topTextureCoordinate).r;\nfloat h = -topLeftIntensity - 2.0 * topIntensity - topRightIntensity + bottomLeftIntensity + 2.0 * bottomIntensity + bottomRightIntensity;\nfloat v = -bottomLeftIntensity - 2.0 * leftIntensity - topLeftIntensity + bottomRightIntensity + 2.0 * rightIntensity + topRightIntensity;\n\nfloat mag = length(vec2(h, v));\n\nvec3 posterizedImageColor = floor((textureColor.rgb * quantizationLevels) + 0.5) / quantizationLevels;\n\nfloat thresholdTest = 1.0 - step(threshold, mag);\n\ngl_FragColor = vec4(posterizedImageColor * thresholdTest, textureColor.a);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageTransformFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	TRANSFORM_VERTEX_SHADER	"attribute vec4 position;\n attribute vec4 inputTextureCoordinate;\n \n uniform mat4 transformMatrix;\n uniform mat4 orthographicMatrix;\n \n varying vec2 textureCoordinate;\n \n void main()\n {\n gl_Position = transformMatrix * vec4(position.xyz, 1.0) * orthographicMatrix;\n textureCoordinate = inputTextureCoordinate.xy;\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageVibranceFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	VIBRANCE_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\nuniform lowp float vibrance;\n\nvoid main() {\n lowp vec4 color = texture2D(inputImageTexture, textureCoordinate);\n lowp float average = (color.r + color.g + color.b) / 3.0;\n lowp float mx = max(color.r, max(color.g, color.b));\n lowp float amt = (mx - average) * (-vibrance * 3.0);\n color.rgb = mix(color.rgb, vec3(mx), amt);\n gl_FragColor = color;\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageVignetteFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	VIGNETTING_FRAGMENT_SHADER	" uniform sampler2D inputImageTexture;\n varying highp vec2 textureCoordinate;\n \n uniform lowp vec2 vignetteCenter;\n uniform lowp vec3 vignetteColor;\n uniform highp float vignetteStart;\n uniform highp float vignetteEnd;\n \n void main()\n {\n /*\n lowp vec3 rgb = texture2D(inputImageTexture, textureCoordinate).rgb;\n lowp float d = distance(textureCoordinate, vec2(0.5,0.5));\n rgb *= (1.0 - smoothstep(vignetteStart, vignetteEnd, d));\n gl_FragColor = vec4(vec3(rgb),1.0);\n */\n \n lowp vec3 rgb = texture2D(inputImageTexture, textureCoordinate).rgb;\n lowp float d = distance(textureCoordinate, vec2(vignetteCenter.x, vignetteCenter.y));\n lowp float percent = smoothstep(vignetteStart, vignetteEnd, d);\n gl_FragColor = vec4(mix(rgb.x, vignetteColor.x, percent), mix(rgb.y, vignetteColor.y, percent), mix(rgb.z, vignetteColor.z, percent), 1.0);\n }"

jp.co.cyberagent.android.gpuimage.filter.GPUImageWeakPixelInclusionFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	WEAKPIXEL_FRAGMENT_SHADER	"precision lowp float;\n\nvarying vec2 textureCoordinate;\nvarying vec2 leftTextureCoordinate;\nvarying vec2 rightTextureCoordinate;\n\nvarying vec2 topTextureCoordinate;\nvarying vec2 topLeftTextureCoordinate;\nvarying vec2 topRightTextureCoordinate;\n\nvarying vec2 bottomTextureCoordinate;\nvarying vec2 bottomLeftTextureCoordinate;\nvarying vec2 bottomRightTextureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nvoid main()\n{\nfloat bottomLeftIntensity = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;\nfloat topRightIntensity = texture2D(inputImageTexture, topRightTextureCoordinate).r;\nfloat topLeftIntensity = texture2D(inputImageTexture, topLeftTextureCoordinate).r;\nfloat bottomRightIntensity = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;\nfloat leftIntensity = texture2D(inputImageTexture, leftTextureCoordinate).r;\nfloat rightIntensity = texture2D(inputImageTexture, rightTextureCoordinate).r;\nfloat bottomIntensity = texture2D(inputImageTexture, bottomTextureCoordinate).r;\nfloat topIntensity = texture2D(inputImageTexture, topTextureCoordinate).r;\nfloat centerIntensity = texture2D(inputImageTexture, textureCoordinate).r;\n\nfloat pixelIntensitySum = bottomLeftIntensity + topRightIntensity + topLeftIntensity + bottomRightIntensity + leftIntensity + rightIntensity + bottomIntensity + topIntensity + centerIntensity;\nfloat sumTest = step(1.5, pixelIntensitySum);\nfloat pixelTest = step(0.01, centerIntensity);\n\ngl_FragColor = vec4(vec3(sumTest * pixelTest), 1.0);\n}\n"

jp.co.cyberagent.android.gpuimage.filter.GPUImageWhiteBalanceFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	WHITE_BALANCE_FRAGMENT_SHADER	"uniform sampler2D inputImageTexture;\nvarying highp vec2 textureCoordinate;\n \nuniform lowp float temperature;\nuniform lowp float tint;\n\nconst lowp vec3 warmFilter = vec3(0.93, 0.54, 0.0);\n\nconst mediump mat3 RGBtoYIQ = mat3(0.299, 0.587, 0.114, 0.596, -0.274, -0.322, 0.212, -0.523, 0.311);\nconst mediump mat3 YIQtoRGB = mat3(1.0, 0.956, 0.621, 1.0, -0.272, -0.647, 1.0, -1.105, 1.702);\n\nvoid main()\n{\n\tlowp vec4 source = texture2D(inputImageTexture, textureCoordinate);\n\t\n\tmediump vec3 yiq = RGBtoYIQ * source.rgb; //adjusting tint\n\tyiq.b = clamp(yiq.b + tint*0.5226*0.1, -0.5226, 0.5226);\n\tlowp vec3 rgb = YIQtoRGB * yiq;\n\n\tlowp vec3 processed = vec3(\n\t\t(rgb.r < 0.5 ? (2.0 * rgb.r * warmFilter.r) : (1.0 - 2.0 * (1.0 - rgb.r) * (1.0 - warmFilter.r))), //adjusting temperature\n\t\t(rgb.g < 0.5 ? (2.0 * rgb.g * warmFilter.g) : (1.0 - 2.0 * (1.0 - rgb.g) * (1.0 - warmFilter.g))), \n\t\t(rgb.b < 0.5 ? (2.0 * rgb.b * warmFilter.b) : (1.0 - 2.0 * (1.0 - rgb.b) * (1.0 - warmFilter.b))));\n\n\tgl_FragColor = vec4(mix(rgb, processed, temperature), source.a);\n}"

jp.co.cyberagent.android.gpuimage.filter.GPUImageZoomBlurFilter

Modifier and Type	Constant Field	Value
public static final java.lang.String	ZOOM_BLUR_FRAGMENT_SHADER	"varying highp vec2 textureCoordinate;\n\nuniform sampler2D inputImageTexture;\n\nuniform highp vec2 blurCenter;\nuniform highp float blurSize;\n\nvoid main()\n{\n // TODO: Do a more intelligent scaling based on resolution here\n highp vec2 samplingOffset = 1.0/100.0 * (blurCenter - textureCoordinate) * blurSize;\n \n lowp vec4 fragmentColor = texture2D(inputImageTexture, textureCoordinate) * 0.18;\n fragmentColor += texture2D(inputImageTexture, textureCoordinate + samplingOffset) * 0.15;\n fragmentColor += texture2D(inputImageTexture, textureCoordinate + (2.0 * samplingOffset)) * 0.12;\n fragmentColor += texture2D(inputImageTexture, textureCoordinate + (3.0 * samplingOffset)) * 0.09;\n fragmentColor += texture2D(inputImageTexture, textureCoordinate + (4.0 * samplingOffset)) * 0.05;\n fragmentColor += texture2D(inputImageTexture, textureCoordinate - samplingOffset) * 0.15;\n fragmentColor += texture2D(inputImageTexture, textureCoordinate - (2.0 * samplingOffset)) * 0.12;\n fragmentColor += texture2D(inputImageTexture, textureCoordinate - (3.0 * samplingOffset)) * 0.09;\n fragmentColor += texture2D(inputImageTexture, textureCoordinate - (4.0 * samplingOffset)) * 0.05;\n \n gl_FragColor = fragmentColor;\n}\n"

jp.co.cyberagent.android.gpuimage.util.OpenGlUtils

Modifier and Type	Constant Field	Value
public static final int	NO_TEXTURE	-1