OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 The Android Open Source Project | 2 * Copyright 2012 The Android Open Source Project |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkLightingImageFilter.h" | 8 #include "SkLightingImageFilter.h" |
9 #include "SkBitmap.h" | 9 #include "SkBitmap.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
11 #include "SkDevice.h" | 11 #include "SkDevice.h" |
12 #include "SkPoint3.h" | 12 #include "SkPoint3.h" |
13 #include "SkReadBuffer.h" | 13 #include "SkReadBuffer.h" |
14 #include "SkTypes.h" | 14 #include "SkTypes.h" |
15 #include "SkWriteBuffer.h" | 15 #include "SkWriteBuffer.h" |
16 | 16 |
17 #if SK_SUPPORT_GPU | 17 #if SK_SUPPORT_GPU |
18 #include "GrContext.h" | 18 #include "GrContext.h" |
19 #include "GrDrawContext.h" | 19 #include "GrDrawContext.h" |
20 #include "GrFragmentProcessor.h" | 20 #include "GrFragmentProcessor.h" |
21 #include "GrInvariantOutput.h" | 21 #include "GrInvariantOutput.h" |
22 #include "GrPaint.h" | 22 #include "GrPaint.h" |
23 #include "effects/GrSingleTextureEffect.h" | 23 #include "effects/GrSingleTextureEffect.h" |
24 #include "gl/GrGLFragmentProcessor.h" | 24 #include "gl/GrGLFragmentProcessor.h" |
25 #include "gl/builders/GrGLProgramBuilder.h" | 25 #include "glsl/GrGLSLFragmentShaderBuilder.h" |
| 26 #include "glsl/GrGLSLProgramBuilder.h" |
26 #include "glsl/GrGLSLProgramDataManager.h" | 27 #include "glsl/GrGLSLProgramDataManager.h" |
27 | 28 |
28 class GrGLDiffuseLightingEffect; | 29 class GrGLDiffuseLightingEffect; |
29 class GrGLSpecularLightingEffect; | 30 class GrGLSpecularLightingEffect; |
30 | 31 |
31 // For brevity | 32 // For brevity |
32 typedef GrGLSLProgramDataManager::UniformHandle UniformHandle; | 33 typedef GrGLSLProgramDataManager::UniformHandle UniformHandle; |
33 #endif | 34 #endif |
34 | 35 |
35 namespace { | 36 namespace { |
(...skipping 1571 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1607 this->initClassID<GrDiffuseLightingEffect>(); | 1608 this->initClassID<GrDiffuseLightingEffect>(); |
1608 } | 1609 } |
1609 | 1610 |
1610 bool GrDiffuseLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const
{ | 1611 bool GrDiffuseLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const
{ |
1611 const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>(); | 1612 const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>(); |
1612 return INHERITED::onIsEqual(sBase) && | 1613 return INHERITED::onIsEqual(sBase) && |
1613 this->kd() == s.kd(); | 1614 this->kd() == s.kd(); |
1614 } | 1615 } |
1615 | 1616 |
1616 void GrDiffuseLightingEffect::onGetGLProcessorKey(const GrGLSLCaps& caps, | 1617 void GrDiffuseLightingEffect::onGetGLProcessorKey(const GrGLSLCaps& caps, |
1617 GrProcessorKeyBuilder* b) const
{ | 1618 GrProcessorKeyBuilder* b) cons
t { |
1618 GrGLDiffuseLightingEffect::GenKey(*this, caps, b); | 1619 GrGLDiffuseLightingEffect::GenKey(*this, caps, b); |
1619 } | 1620 } |
1620 | 1621 |
1621 GrGLFragmentProcessor* GrDiffuseLightingEffect::onCreateGLInstance() const { | 1622 GrGLFragmentProcessor* GrDiffuseLightingEffect::onCreateGLInstance() const { |
1622 return new GrGLDiffuseLightingEffect(*this); | 1623 return new GrGLDiffuseLightingEffect(*this); |
1623 } | 1624 } |
1624 | 1625 |
1625 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect); | 1626 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect); |
1626 | 1627 |
1627 const GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(GrProcessorTestDa
ta* d) { | 1628 const GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(GrProcessorTestDa
ta* d) { |
(...skipping 16 matching lines...) Expand all Loading... |
1644 const GrLightingEffect& m = fp.cast<GrLightingEffect>(); | 1645 const GrLightingEffect& m = fp.cast<GrLightingEffect>(); |
1645 fLight = m.light()->createGLLight(); | 1646 fLight = m.light()->createGLLight(); |
1646 fBoundaryMode = m.boundaryMode(); | 1647 fBoundaryMode = m.boundaryMode(); |
1647 } | 1648 } |
1648 | 1649 |
1649 GrGLLightingEffect::~GrGLLightingEffect() { | 1650 GrGLLightingEffect::~GrGLLightingEffect() { |
1650 delete fLight; | 1651 delete fLight; |
1651 } | 1652 } |
1652 | 1653 |
1653 void GrGLLightingEffect::emitCode(EmitArgs& args) { | 1654 void GrGLLightingEffect::emitCode(EmitArgs& args) { |
1654 fImageIncrementUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment
_Visibility, | 1655 fImageIncrementUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragme
nt_Visibility, |
1655 kVec2f_GrSLType, kDefault_GrSLPrec
ision, | 1656 kVec2f_GrSLType, kDefault_GrSLPrec
ision, |
1656 "ImageIncrement"); | 1657 "ImageIncrement"); |
1657 fSurfaceScaleUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_V
isibility, | 1658 fSurfaceScaleUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment
_Visibility, |
1658 kFloat_GrSLType, kDefault_GrSLPrecisi
on, | 1659 kFloat_GrSLType, kDefault_GrSLPrecisi
on, |
1659 "SurfaceScale"); | 1660 "SurfaceScale"); |
1660 fLight->emitLightColorUniform(args.fBuilder); | 1661 fLight->emitLightColorUniform(args.fBuilder); |
1661 SkString lightFunc; | 1662 SkString lightFunc; |
1662 this->emitLightFunc(args.fBuilder, &lightFunc); | 1663 this->emitLightFunc(args.fBuilder, &lightFunc); |
1663 static const GrGLSLShaderVar gSobelArgs[] = { | 1664 static const GrGLSLShaderVar gSobelArgs[] = { |
1664 GrGLSLShaderVar("a", kFloat_GrSLType), | 1665 GrGLSLShaderVar("a", kFloat_GrSLType), |
1665 GrGLSLShaderVar("b", kFloat_GrSLType), | 1666 GrGLSLShaderVar("b", kFloat_GrSLType), |
1666 GrGLSLShaderVar("c", kFloat_GrSLType), | 1667 GrGLSLShaderVar("c", kFloat_GrSLType), |
1667 GrGLSLShaderVar("d", kFloat_GrSLType), | 1668 GrGLSLShaderVar("d", kFloat_GrSLType), |
1668 GrGLSLShaderVar("e", kFloat_GrSLType), | 1669 GrGLSLShaderVar("e", kFloat_GrSLType), |
1669 GrGLSLShaderVar("f", kFloat_GrSLType), | 1670 GrGLSLShaderVar("f", kFloat_GrSLType), |
1670 GrGLSLShaderVar("scale", kFloat_GrSLType), | 1671 GrGLSLShaderVar("scale", kFloat_GrSLType), |
1671 }; | 1672 }; |
1672 SkString sobelFuncName; | 1673 SkString sobelFuncName; |
1673 GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder(); | 1674 GrGLSLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder()
; |
1674 SkString coords2D = fsBuilder->ensureFSCoords2D(args.fCoords, 0); | 1675 SkString coords2D = fsBuilder->ensureFSCoords2D(args.fCoords, 0); |
1675 | 1676 |
1676 fsBuilder->emitFunction(kFloat_GrSLType, | 1677 fsBuilder->emitFunction(kFloat_GrSLType, |
1677 "sobel", | 1678 "sobel", |
1678 SK_ARRAY_COUNT(gSobelArgs), | 1679 SK_ARRAY_COUNT(gSobelArgs), |
1679 gSobelArgs, | 1680 gSobelArgs, |
1680 "\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scal
e;\n", | 1681 "\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scal
e;\n", |
1681 &sobelFuncName); | 1682 &sobelFuncName); |
1682 static const GrGLSLShaderVar gPointToNormalArgs[] = { | 1683 static const GrGLSLShaderVar gPointToNormalArgs[] = { |
1683 GrGLSLShaderVar("x", kFloat_GrSLType), | 1684 GrGLSLShaderVar("x", kFloat_GrSLType), |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1758 /////////////////////////////////////////////////////////////////////////////// | 1759 /////////////////////////////////////////////////////////////////////////////// |
1759 | 1760 |
1760 /////////////////////////////////////////////////////////////////////////////// | 1761 /////////////////////////////////////////////////////////////////////////////// |
1761 | 1762 |
1762 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrProcessor& proc) | 1763 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrProcessor& proc) |
1763 : INHERITED(proc) { | 1764 : INHERITED(proc) { |
1764 } | 1765 } |
1765 | 1766 |
1766 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLSLFPBuilder* builder, SkString
* funcName) { | 1767 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLSLFPBuilder* builder, SkString
* funcName) { |
1767 const char* kd; | 1768 const char* kd; |
1768 fKDUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1769 fKDUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility, |
1769 kFloat_GrSLType, kDefault_GrSLPrecision, | 1770 kFloat_GrSLType, kDefault_GrSLPrecision, |
1770 "KD", &kd); | 1771 "KD", &kd); |
1771 | 1772 |
1772 static const GrGLSLShaderVar gLightArgs[] = { | 1773 static const GrGLSLShaderVar gLightArgs[] = { |
1773 GrGLSLShaderVar("normal", kVec3f_GrSLType), | 1774 GrGLSLShaderVar("normal", kVec3f_GrSLType), |
1774 GrGLSLShaderVar("surfaceToLight", kVec3f_GrSLType), | 1775 GrGLSLShaderVar("surfaceToLight", kVec3f_GrSLType), |
1775 GrGLSLShaderVar("lightColor", kVec3f_GrSLType) | 1776 GrGLSLShaderVar("lightColor", kVec3f_GrSLType) |
1776 }; | 1777 }; |
1777 SkString lightBody; | 1778 SkString lightBody; |
1778 lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n"
, kd); | 1779 lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n"
, kd); |
(...skipping 29 matching lines...) Expand all Loading... |
1808 } | 1809 } |
1809 | 1810 |
1810 bool GrSpecularLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const
{ | 1811 bool GrSpecularLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const
{ |
1811 const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>(); | 1812 const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>(); |
1812 return INHERITED::onIsEqual(sBase) && | 1813 return INHERITED::onIsEqual(sBase) && |
1813 this->ks() == s.ks() && | 1814 this->ks() == s.ks() && |
1814 this->shininess() == s.shininess(); | 1815 this->shininess() == s.shininess(); |
1815 } | 1816 } |
1816 | 1817 |
1817 void GrSpecularLightingEffect::onGetGLProcessorKey(const GrGLSLCaps& caps, | 1818 void GrSpecularLightingEffect::onGetGLProcessorKey(const GrGLSLCaps& caps, |
1818 GrProcessorKeyBuilder* b) const
{ | 1819 GrProcessorKeyBuilder* b) con
st { |
1819 GrGLSpecularLightingEffect::GenKey(*this, caps, b); | 1820 GrGLSpecularLightingEffect::GenKey(*this, caps, b); |
1820 } | 1821 } |
1821 | 1822 |
1822 GrGLFragmentProcessor* GrSpecularLightingEffect::onCreateGLInstance() const { | 1823 GrGLFragmentProcessor* GrSpecularLightingEffect::onCreateGLInstance() const { |
1823 return new GrGLSpecularLightingEffect(*this); | 1824 return new GrGLSpecularLightingEffect(*this); |
1824 } | 1825 } |
1825 | 1826 |
1826 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect); | 1827 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect); |
1827 | 1828 |
1828 const GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(GrProcessorTestD
ata* d) { | 1829 const GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(GrProcessorTestD
ata* d) { |
(...skipping 13 matching lines...) Expand all Loading... |
1842 /////////////////////////////////////////////////////////////////////////////// | 1843 /////////////////////////////////////////////////////////////////////////////// |
1843 | 1844 |
1844 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrProcessor& proc) | 1845 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrProcessor& proc) |
1845 : INHERITED(proc) { | 1846 : INHERITED(proc) { |
1846 } | 1847 } |
1847 | 1848 |
1848 void GrGLSpecularLightingEffect::emitLightFunc(GrGLSLFPBuilder* builder, SkStrin
g* funcName) { | 1849 void GrGLSpecularLightingEffect::emitLightFunc(GrGLSLFPBuilder* builder, SkStrin
g* funcName) { |
1849 const char* ks; | 1850 const char* ks; |
1850 const char* shininess; | 1851 const char* shininess; |
1851 | 1852 |
1852 fKSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1853 fKSUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility, |
1853 kFloat_GrSLType, kDefault_GrSLPrecision, "KS",
&ks); | 1854 kFloat_GrSLType, kDefault_GrSLPrecision, "KS",
&ks); |
1854 fShininessUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, | 1855 fShininessUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibili
ty, |
1855 kFloat_GrSLType, | 1856 kFloat_GrSLType, |
1856 kDefault_GrSLPrecision, | 1857 kDefault_GrSLPrecision, |
1857 "Shininess", | 1858 "Shininess", |
1858 &shininess); | 1859 &shininess); |
1859 | 1860 |
1860 static const GrGLSLShaderVar gLightArgs[] = { | 1861 static const GrGLSLShaderVar gLightArgs[] = { |
1861 GrGLSLShaderVar("normal", kVec3f_GrSLType), | 1862 GrGLSLShaderVar("normal", kVec3f_GrSLType), |
1862 GrGLSLShaderVar("surfaceToLight", kVec3f_GrSLType), | 1863 GrGLSLShaderVar("surfaceToLight", kVec3f_GrSLType), |
1863 GrGLSLShaderVar("lightColor", kVec3f_GrSLType) | 1864 GrGLSLShaderVar("lightColor", kVec3f_GrSLType) |
1864 }; | 1865 }; |
(...skipping 13 matching lines...) Expand all Loading... |
1878 void GrGLSpecularLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman
, | 1879 void GrGLSpecularLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman
, |
1879 const GrProcessor& effect) { | 1880 const GrProcessor& effect) { |
1880 INHERITED::onSetData(pdman, effect); | 1881 INHERITED::onSetData(pdman, effect); |
1881 const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>
(); | 1882 const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>
(); |
1882 pdman.set1f(fKSUni, spec.ks()); | 1883 pdman.set1f(fKSUni, spec.ks()); |
1883 pdman.set1f(fShininessUni, spec.shininess()); | 1884 pdman.set1f(fShininessUni, spec.shininess()); |
1884 } | 1885 } |
1885 | 1886 |
1886 /////////////////////////////////////////////////////////////////////////////// | 1887 /////////////////////////////////////////////////////////////////////////////// |
1887 void GrGLLight::emitLightColorUniform(GrGLSLFPBuilder* builder) { | 1888 void GrGLLight::emitLightColorUniform(GrGLSLFPBuilder* builder) { |
1888 fColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1889 fColorUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility, |
1889 kVec3f_GrSLType, kDefault_GrSLPrecision, | 1890 kVec3f_GrSLType, kDefault_GrSLPrecision, |
1890 "LightColor"); | 1891 "LightColor"); |
1891 } | 1892 } |
1892 | 1893 |
1893 void GrGLLight::emitLightColor(GrGLSLFPBuilder* builder, const char *surfaceToLi
ght) { | 1894 void GrGLLight::emitLightColor(GrGLSLFPBuilder* builder, const char *surfaceToLi
ght) { |
1894 builder->getFragmentShaderBuilder()->codeAppend(builder->getUniformCStr(this
->lightColorUni())); | 1895 builder->getFragmentShaderBuilder()->codeAppend(builder->getUniformCStr(this
->lightColorUni())); |
1895 } | 1896 } |
1896 | 1897 |
1897 void GrGLLight::setData(const GrGLSLProgramDataManager& pdman, | 1898 void GrGLLight::setData(const GrGLSLProgramDataManager& pdman, |
1898 const SkImageFilterLight* light) const { | 1899 const SkImageFilterLight* light) const { |
1899 setUniformPoint3(pdman, fColorUni, | 1900 setUniformPoint3(pdman, fColorUni, |
1900 light->color().makeScale(SkScalarInvert(SkIntToScalar(255))
)); | 1901 light->color().makeScale(SkScalarInvert(SkIntToScalar(255))
)); |
1901 } | 1902 } |
1902 | 1903 |
1903 /////////////////////////////////////////////////////////////////////////////// | 1904 /////////////////////////////////////////////////////////////////////////////// |
1904 | 1905 |
1905 void GrGLDistantLight::setData(const GrGLSLProgramDataManager& pdman, | 1906 void GrGLDistantLight::setData(const GrGLSLProgramDataManager& pdman, |
1906 const SkImageFilterLight* light) const { | 1907 const SkImageFilterLight* light) const { |
1907 INHERITED::setData(pdman, light); | 1908 INHERITED::setData(pdman, light); |
1908 SkASSERT(light->type() == SkImageFilterLight::kDistant_LightType); | 1909 SkASSERT(light->type() == SkImageFilterLight::kDistant_LightType); |
1909 const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(ligh
t); | 1910 const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(ligh
t); |
1910 setUniformNormal3(pdman, fDirectionUni, distantLight->direction()); | 1911 setUniformNormal3(pdman, fDirectionUni, distantLight->direction()); |
1911 } | 1912 } |
1912 | 1913 |
1913 void GrGLDistantLight::emitSurfaceToLight(GrGLSLFPBuilder* builder, const char*
z) { | 1914 void GrGLDistantLight::emitSurfaceToLight(GrGLSLFPBuilder* builder, const char*
z) { |
1914 const char* dir; | 1915 const char* dir; |
1915 fDirectionUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, | 1916 fDirectionUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibili
ty, |
1916 kVec3f_GrSLType, kDefault_GrSLPrecision, | 1917 kVec3f_GrSLType, kDefault_GrSLPrecision, |
1917 "LightDirection", &dir); | 1918 "LightDirection", &dir); |
1918 builder->getFragmentShaderBuilder()->codeAppend(dir); | 1919 builder->getFragmentShaderBuilder()->codeAppend(dir); |
1919 } | 1920 } |
1920 | 1921 |
1921 /////////////////////////////////////////////////////////////////////////////// | 1922 /////////////////////////////////////////////////////////////////////////////// |
1922 | 1923 |
1923 void GrGLPointLight::setData(const GrGLSLProgramDataManager& pdman, | 1924 void GrGLPointLight::setData(const GrGLSLProgramDataManager& pdman, |
1924 const SkImageFilterLight* light) const { | 1925 const SkImageFilterLight* light) const { |
1925 INHERITED::setData(pdman, light); | 1926 INHERITED::setData(pdman, light); |
1926 SkASSERT(light->type() == SkImageFilterLight::kPoint_LightType); | 1927 SkASSERT(light->type() == SkImageFilterLight::kPoint_LightType); |
1927 const SkPointLight* pointLight = static_cast<const SkPointLight*>(light); | 1928 const SkPointLight* pointLight = static_cast<const SkPointLight*>(light); |
1928 setUniformPoint3(pdman, fLocationUni, pointLight->location()); | 1929 setUniformPoint3(pdman, fLocationUni, pointLight->location()); |
1929 } | 1930 } |
1930 | 1931 |
1931 void GrGLPointLight::emitSurfaceToLight(GrGLSLFPBuilder* builder, const char* z)
{ | 1932 void GrGLPointLight::emitSurfaceToLight(GrGLSLFPBuilder* builder, const char* z)
{ |
1932 const char* loc; | 1933 const char* loc; |
1933 fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1934 fLocationUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibilit
y, |
1934 kVec3f_GrSLType, kDefault_GrSLPrecision, | 1935 kVec3f_GrSLType, kDefault_GrSLPrecision, |
1935 "LightLocation", &loc); | 1936 "LightLocation", &loc); |
1936 GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 1937 GrGLSLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
1937 fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))", | 1938 fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))", |
1938 loc, fsBuilder->fragmentPosition(), z); | 1939 loc, fsBuilder->fragmentPosition(), z); |
1939 } | 1940 } |
1940 | 1941 |
1941 /////////////////////////////////////////////////////////////////////////////// | 1942 /////////////////////////////////////////////////////////////////////////////// |
1942 | 1943 |
1943 void GrGLSpotLight::setData(const GrGLSLProgramDataManager& pdman, | 1944 void GrGLSpotLight::setData(const GrGLSLProgramDataManager& pdman, |
1944 const SkImageFilterLight* light) const { | 1945 const SkImageFilterLight* light) const { |
1945 INHERITED::setData(pdman, light); | 1946 INHERITED::setData(pdman, light); |
1946 SkASSERT(light->type() == SkImageFilterLight::kSpot_LightType); | 1947 SkASSERT(light->type() == SkImageFilterLight::kSpot_LightType); |
1947 const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light); | 1948 const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light); |
1948 setUniformPoint3(pdman, fLocationUni, spotLight->location()); | 1949 setUniformPoint3(pdman, fLocationUni, spotLight->location()); |
1949 pdman.set1f(fExponentUni, spotLight->specularExponent()); | 1950 pdman.set1f(fExponentUni, spotLight->specularExponent()); |
1950 pdman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle()); | 1951 pdman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle()); |
1951 pdman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle()); | 1952 pdman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle()); |
1952 pdman.set1f(fConeScaleUni, spotLight->coneScale()); | 1953 pdman.set1f(fConeScaleUni, spotLight->coneScale()); |
1953 setUniformNormal3(pdman, fSUni, spotLight->s()); | 1954 setUniformNormal3(pdman, fSUni, spotLight->s()); |
1954 } | 1955 } |
1955 | 1956 |
1956 void GrGLSpotLight::emitSurfaceToLight(GrGLSLFPBuilder* builder, const char* z)
{ | 1957 void GrGLSpotLight::emitSurfaceToLight(GrGLSLFPBuilder* builder, const char* z)
{ |
1957 const char* location; | 1958 const char* location; |
1958 fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1959 fLocationUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibilit
y, |
1959 kVec3f_GrSLType, kDefault_GrSLPrecision, | 1960 kVec3f_GrSLType, kDefault_GrSLPrecision, |
1960 "LightLocation", &location); | 1961 "LightLocation", &location); |
1961 | 1962 |
1962 GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 1963 GrGLSLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
1963 fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))", | 1964 fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))", |
1964 location, fsBuilder->fragmentPosition(), z); | 1965 location, fsBuilder->fragmentPosition(), z); |
1965 } | 1966 } |
1966 | 1967 |
1967 void GrGLSpotLight::emitLightColor(GrGLSLFPBuilder* builder, | 1968 void GrGLSpotLight::emitLightColor(GrGLSLFPBuilder* builder, |
1968 const char *surfaceToLight) { | 1969 const char *surfaceToLight) { |
1969 | 1970 |
1970 const char* color = builder->getUniformCStr(this->lightColorUni()); // creat
ed by parent class. | 1971 const char* color = builder->getUniformCStr(this->lightColorUni()); // creat
ed by parent class. |
1971 | 1972 |
1972 const char* exponent; | 1973 const char* exponent; |
1973 const char* cosInner; | 1974 const char* cosInner; |
1974 const char* cosOuter; | 1975 const char* cosOuter; |
1975 const char* coneScale; | 1976 const char* coneScale; |
1976 const char* s; | 1977 const char* s; |
1977 fExponentUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1978 fExponentUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibilit
y, |
1978 kFloat_GrSLType, kDefault_GrSLPrecision, | 1979 kFloat_GrSLType, kDefault_GrSLPrecision, |
1979 "Exponent", &exponent); | 1980 "Exponent", &exponent); |
1980 fCosInnerConeAngleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Vi
sibility, | 1981 fCosInnerConeAngleUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_
Visibility, |
1981 kFloat_GrSLType, kDefault_GrSLPr
ecision, | 1982 kFloat_GrSLType, kDefault_GrSLPr
ecision, |
1982 "CosInnerConeAngle", &cosInner); | 1983 "CosInnerConeAngle", &cosInner); |
1983 fCosOuterConeAngleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Vi
sibility, | 1984 fCosOuterConeAngleUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_
Visibility, |
1984 kFloat_GrSLType, kDefault_GrSLPr
ecision, | 1985 kFloat_GrSLType, kDefault_GrSLPr
ecision, |
1985 "CosOuterConeAngle", &cosOuter); | 1986 "CosOuterConeAngle", &cosOuter); |
1986 fConeScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, | 1987 fConeScaleUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibili
ty, |
1987 kFloat_GrSLType, kDefault_GrSLPrecision, | 1988 kFloat_GrSLType, kDefault_GrSLPrecision, |
1988 "ConeScale", &coneScale); | 1989 "ConeScale", &coneScale); |
1989 fSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1990 fSUni = builder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility, |
1990 kVec3f_GrSLType, kDefault_GrSLPrecision, "S", &s
); | 1991 kVec3f_GrSLType, kDefault_GrSLPrecision, "S", &s
); |
1991 | 1992 |
1992 static const GrGLSLShaderVar gLightColorArgs[] = { | 1993 static const GrGLSLShaderVar gLightColorArgs[] = { |
1993 GrGLSLShaderVar("surfaceToLight", kVec3f_GrSLType) | 1994 GrGLSLShaderVar("surfaceToLight", kVec3f_GrSLType) |
1994 }; | 1995 }; |
1995 SkString lightColorBody; | 1996 SkString lightColorBody; |
1996 lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s); | 1997 lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s); |
1997 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter); | 1998 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter); |
1998 lightColorBody.appendf("\t\treturn vec3(0);\n"); | 1999 lightColorBody.appendf("\t\treturn vec3(0);\n"); |
1999 lightColorBody.appendf("\t}\n"); | 2000 lightColorBody.appendf("\t}\n"); |
2000 lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent); | 2001 lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent); |
2001 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosInner); | 2002 lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosInner); |
2002 lightColorBody.appendf("\t\treturn %s * scale * (cosAngle - %s) * %s;\n", | 2003 lightColorBody.appendf("\t\treturn %s * scale * (cosAngle - %s) * %s;\n", |
2003 color, cosOuter, coneScale); | 2004 color, cosOuter, coneScale); |
2004 lightColorBody.appendf("\t}\n"); | 2005 lightColorBody.appendf("\t}\n"); |
2005 lightColorBody.appendf("\treturn %s;\n", color); | 2006 lightColorBody.appendf("\treturn %s;\n", color); |
2006 GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 2007 GrGLSLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
2007 fsBuilder->emitFunction(kVec3f_GrSLType, | 2008 fsBuilder->emitFunction(kVec3f_GrSLType, |
2008 "lightColor", | 2009 "lightColor", |
2009 SK_ARRAY_COUNT(gLightColorArgs), | 2010 SK_ARRAY_COUNT(gLightColorArgs), |
2010 gLightColorArgs, | 2011 gLightColorArgs, |
2011 lightColorBody.c_str(), | 2012 lightColorBody.c_str(), |
2012 &fLightColorFunc); | 2013 &fLightColorFunc); |
2013 | 2014 |
2014 fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight); | 2015 fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight); |
2015 } | 2016 } |
2016 | 2017 |
2017 #endif | 2018 #endif |
2018 | 2019 |
2019 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter) | 2020 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter) |
2020 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter) | 2021 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter) |
2021 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter) | 2022 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter) |
2022 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 2023 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
OLD | NEW |