2014-05-09 06:43:12 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2014 Chukong Technologies Inc.
|
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
|
2014-05-09 09:01:48 +08:00
|
|
|
|
2014-05-09 06:43:12 +08:00
|
|
|
#include "ShaderTest2.h"
|
2013-09-09 17:49:13 +08:00
|
|
|
#include "ShaderTest.h"
|
|
|
|
#include "../testResource.h"
|
|
|
|
#include "cocos2d.h"
|
|
|
|
|
|
|
|
namespace ShaderTest2
|
|
|
|
{
|
|
|
|
static std::function<Layer*()> createFunctions[] =
|
|
|
|
{
|
|
|
|
CL(NormalSpriteTest),
|
|
|
|
CL(GreyScaleSpriteTest),
|
|
|
|
CL(BlurSpriteTest),
|
|
|
|
CL(NoiseSpriteTest),
|
|
|
|
CL(EdgeDetectionSpriteTest),
|
|
|
|
CL(BloomSpriteTest),
|
2013-09-12 10:25:55 +08:00
|
|
|
CL(CelShadingSpriteTest),
|
2014-04-14 11:52:17 +08:00
|
|
|
CL(LensFlareSpriteTest),
|
2014-05-07 02:19:51 +08:00
|
|
|
CL(OutlineShadingSpriteTest),
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static unsigned int TEST_CASE_COUNT = sizeof(ShaderTest2::createFunctions) / sizeof(ShaderTest2::createFunctions[0]);
|
|
|
|
|
|
|
|
static int sceneIdx=-1;
|
|
|
|
Layer* createTest(int index)
|
|
|
|
{
|
|
|
|
auto layer = (createFunctions[index])();;
|
|
|
|
return layer;
|
|
|
|
}
|
|
|
|
|
|
|
|
Layer* nextAction();
|
|
|
|
Layer* backAction();
|
|
|
|
Layer* restartAction();
|
|
|
|
|
|
|
|
Layer* nextAction()
|
|
|
|
{
|
|
|
|
sceneIdx++;
|
|
|
|
sceneIdx = sceneIdx % TEST_CASE_COUNT;
|
|
|
|
|
|
|
|
return createTest(sceneIdx);
|
|
|
|
}
|
|
|
|
|
|
|
|
Layer* backAction()
|
|
|
|
{
|
|
|
|
sceneIdx--;
|
|
|
|
if( sceneIdx < 0 )
|
|
|
|
sceneIdx = TEST_CASE_COUNT -1;
|
|
|
|
|
|
|
|
return createTest(sceneIdx);
|
|
|
|
}
|
|
|
|
|
|
|
|
Layer* restartAction()
|
|
|
|
{
|
|
|
|
return createTest(sceneIdx);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
ShaderTestDemo2::ShaderTestDemo2()
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void ShaderTestDemo2::backCallback(Ref* sender)
|
2013-09-09 17:49:13 +08:00
|
|
|
{
|
2013-11-14 09:36:33 +08:00
|
|
|
auto s = ShaderTestScene2::create();
|
2013-09-09 17:49:13 +08:00
|
|
|
s->addChild( ShaderTest2::backAction() );
|
|
|
|
Director::getInstance()->replaceScene(s);
|
|
|
|
}
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void ShaderTestDemo2::nextCallback(Ref* sender)
|
2013-09-09 17:49:13 +08:00
|
|
|
{
|
2013-11-14 09:36:33 +08:00
|
|
|
auto s = ShaderTestScene2::create();
|
2013-09-09 17:49:13 +08:00
|
|
|
s->addChild( ShaderTest2::nextAction() );
|
|
|
|
Director::getInstance()->replaceScene(s);
|
|
|
|
}
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void ShaderTestDemo2::restartCallback(Ref* sender)
|
2013-09-09 17:49:13 +08:00
|
|
|
{
|
2013-11-14 09:36:33 +08:00
|
|
|
auto s = ShaderTestScene2::create();
|
|
|
|
s->addChild(ShaderTest2::restartAction());
|
2013-09-09 17:49:13 +08:00
|
|
|
Director::getInstance()->replaceScene(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ShaderTestScene2::runThisTest()
|
|
|
|
{
|
|
|
|
auto layer = ShaderTest2::nextAction();
|
|
|
|
addChild(layer);
|
|
|
|
Director::getInstance()->replaceScene(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class spriteType>
|
|
|
|
class ShaderSpriteCreator
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 09:36:33 +08:00
|
|
|
static spriteType* createSprite(const std::string& filename)
|
2013-09-09 17:49:13 +08:00
|
|
|
{
|
2013-11-14 07:55:36 +08:00
|
|
|
spriteType* ret = spriteType::create();
|
2013-11-14 09:36:33 +08:00
|
|
|
ret->setTexture(filename);
|
|
|
|
ret->initShader();
|
|
|
|
ret->setBackgroundNotification();
|
2013-11-14 07:55:36 +08:00
|
|
|
return ret;
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ShaderSprite : public Sprite
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
ShaderSprite();
|
|
|
|
~ShaderSprite();
|
|
|
|
|
2013-11-14 09:36:33 +08:00
|
|
|
virtual void initShader();
|
|
|
|
void setBackgroundNotification();
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void listenBackToForeground(Ref *obj);
|
2013-09-09 17:49:13 +08:00
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual void setCustomUniforms() = 0;
|
2014-05-09 06:43:12 +08:00
|
|
|
|
2013-09-09 17:49:13 +08:00
|
|
|
std::string _fragSourceFile;
|
2014-04-14 11:52:17 +08:00
|
|
|
std::string _vertSourceFile;
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
ShaderSprite::ShaderSprite()
|
2014-04-14 11:52:17 +08:00
|
|
|
:_vertSourceFile("")
|
2013-09-09 17:49:13 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
ShaderSprite::~ShaderSprite()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-11-14 09:36:33 +08:00
|
|
|
void ShaderSprite::setBackgroundNotification()
|
2013-09-09 17:49:13 +08:00
|
|
|
{
|
2013-12-31 10:54:37 +08:00
|
|
|
#if CC_ENABLE_CACHE_TEXTURE_DATA
|
|
|
|
auto listener = EventListenerCustom::create(EVENT_COME_TO_FOREGROUND, [this](EventCustom* event){
|
2014-05-13 10:12:56 +08:00
|
|
|
this->setGLProgramState(nullptr);
|
2013-12-31 10:54:37 +08:00
|
|
|
this->initShader();
|
|
|
|
});
|
|
|
|
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
|
|
|
|
#endif
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
2013-11-14 09:36:33 +08:00
|
|
|
void ShaderSprite::initShader()
|
2013-09-09 17:49:13 +08:00
|
|
|
{
|
2014-04-14 13:48:17 +08:00
|
|
|
auto fileUtiles = FileUtils::getInstance();
|
|
|
|
auto fragmentFilePath = fileUtiles->fullPathForFilename(_fragSourceFile);
|
|
|
|
auto fragSource = fileUtiles->getStringFromFile(fragmentFilePath);
|
|
|
|
std::string vertSource;
|
2014-04-14 11:52:17 +08:00
|
|
|
if (_vertSourceFile.empty()) {
|
2014-05-13 10:12:56 +08:00
|
|
|
vertSource = ccPositionTextureColor_noMVP_vert;
|
2014-04-14 11:52:17 +08:00
|
|
|
}else{
|
2014-04-14 13:48:17 +08:00
|
|
|
std::string vertexFilePath = fileUtiles->fullPathForFilename(_vertSourceFile);
|
|
|
|
vertSource = fileUtiles->getStringFromFile(vertexFilePath);
|
2014-04-14 11:52:17 +08:00
|
|
|
}
|
|
|
|
|
2014-05-13 10:12:56 +08:00
|
|
|
auto glprogram = GLProgram::createWithByteArrays(vertSource.c_str(), fragSource.c_str());
|
|
|
|
auto glprogramState = GLProgramState::getOrCreate(glprogram);
|
|
|
|
this->setGLProgramState(glprogramState);
|
2014-05-09 06:43:12 +08:00
|
|
|
|
|
|
|
setCustomUniforms();
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class NormalSprite : public ShaderSprite, public ShaderSpriteCreator<NormalSprite>
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 07:55:36 +08:00
|
|
|
CREATE_FUNC(NormalSprite);
|
2013-09-09 17:49:13 +08:00
|
|
|
NormalSprite();
|
2014-05-09 06:43:12 +08:00
|
|
|
|
2013-09-09 17:49:13 +08:00
|
|
|
protected:
|
2014-05-09 06:43:12 +08:00
|
|
|
virtual void setCustomUniforms() override;
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
NormalSprite::NormalSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_normal.fsh";
|
|
|
|
}
|
|
|
|
|
|
|
|
void NormalSprite::setCustomUniforms()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
class GreyScaleSprite : public ShaderSprite, public ShaderSpriteCreator<GreyScaleSprite>
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 07:55:36 +08:00
|
|
|
CREATE_FUNC(GreyScaleSprite);
|
2013-09-09 17:49:13 +08:00
|
|
|
GreyScaleSprite();
|
2014-05-09 06:43:12 +08:00
|
|
|
|
2013-09-09 17:49:13 +08:00
|
|
|
protected:
|
2014-05-09 06:43:12 +08:00
|
|
|
virtual void setCustomUniforms() override;
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
GreyScaleSprite::GreyScaleSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_greyScale.fsh";
|
|
|
|
}
|
|
|
|
|
|
|
|
void GreyScaleSprite::setCustomUniforms()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
class BlurSprite : public ShaderSprite, public ShaderSpriteCreator<BlurSprite>
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 07:55:36 +08:00
|
|
|
CREATE_FUNC(BlurSprite);
|
2013-09-09 17:49:13 +08:00
|
|
|
BlurSprite();
|
|
|
|
void setBlurSize(float f);
|
2014-05-09 06:43:12 +08:00
|
|
|
|
2013-09-09 17:49:13 +08:00
|
|
|
protected:
|
2014-05-09 06:43:12 +08:00
|
|
|
virtual void setCustomUniforms() override;
|
|
|
|
|
2014-03-28 20:53:14 +08:00
|
|
|
int _blurRadius;
|
2014-04-15 18:23:40 +08:00
|
|
|
Vector2 _pixelSize;
|
2013-09-09 17:49:13 +08:00
|
|
|
|
2014-03-28 20:53:14 +08:00
|
|
|
int _samplingRadius;
|
|
|
|
float _scale;
|
|
|
|
float _cons;
|
|
|
|
float _weightSum;
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
BlurSprite::BlurSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_Blur.fsh";
|
|
|
|
}
|
|
|
|
|
2014-05-09 06:43:12 +08:00
|
|
|
void BlurSprite::setCustomUniforms()
|
2013-09-09 17:49:13 +08:00
|
|
|
{
|
|
|
|
auto s = getTexture()->getContentSizeInPixels();
|
2014-03-28 20:53:14 +08:00
|
|
|
_blurRadius = 0;
|
2014-04-15 18:23:40 +08:00
|
|
|
_pixelSize = Vector2(1/s.width, 1/s.height);
|
2014-03-28 20:53:14 +08:00
|
|
|
_samplingRadius = 0;
|
2014-03-05 05:51:43 +08:00
|
|
|
|
2014-03-31 10:44:48 +08:00
|
|
|
setBlurSize(3.0f);
|
2013-09-09 17:49:13 +08:00
|
|
|
|
2014-05-09 06:43:12 +08:00
|
|
|
auto programState = getGLProgramState();
|
2014-05-09 09:01:48 +08:00
|
|
|
programState->setUniformVec2("onePixelSize", _pixelSize);
|
|
|
|
programState->setUniformVec4("gaussianCoefficient", Vector4(_samplingRadius, _scale, _cons, _weightSum));
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void BlurSprite::setBlurSize(float f)
|
|
|
|
{
|
2014-03-28 20:53:14 +08:00
|
|
|
if(_blurRadius == (int)f)
|
|
|
|
return;
|
|
|
|
_blurRadius = (int)f;
|
2013-09-09 17:49:13 +08:00
|
|
|
|
2014-03-28 20:53:14 +08:00
|
|
|
_samplingRadius = _blurRadius;
|
|
|
|
if (_samplingRadius > 10)
|
|
|
|
{
|
|
|
|
_samplingRadius = 10;
|
|
|
|
}
|
|
|
|
if (_blurRadius > 0)
|
|
|
|
{
|
|
|
|
float sigma = _blurRadius / 2.0f;
|
|
|
|
_scale = -0.5f / (sigma * sigma);
|
|
|
|
_cons = -1.0f * _scale / 3.141592f;
|
|
|
|
_weightSum = -_cons;
|
|
|
|
|
|
|
|
float weight;
|
|
|
|
int squareX;
|
|
|
|
for(int dx = 0; dx <= _samplingRadius; ++dx)
|
|
|
|
{
|
|
|
|
squareX = dx * dx;
|
|
|
|
weight = _cons * exp(squareX * _scale);
|
|
|
|
_weightSum += 2.0 * weight;
|
|
|
|
for (int dy = 1; dy <= _samplingRadius; ++dy)
|
|
|
|
{
|
|
|
|
weight = _cons * exp((squareX + dy * dy) * _scale);
|
|
|
|
_weightSum += 4.0 * weight;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
log("_blurRadius:%d",_blurRadius);
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class NoiseSprite : public ShaderSprite, public ShaderSpriteCreator<NoiseSprite>
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 07:55:36 +08:00
|
|
|
CREATE_FUNC(NoiseSprite);
|
2013-09-09 17:49:13 +08:00
|
|
|
NoiseSprite();
|
2014-05-09 06:43:12 +08:00
|
|
|
|
2013-09-09 17:49:13 +08:00
|
|
|
protected:
|
2014-05-09 06:43:12 +08:00
|
|
|
virtual void setCustomUniforms() override;
|
|
|
|
|
|
|
|
GLfloat _resolution[2];
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
NoiseSprite::NoiseSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_Noisy.fsh";
|
|
|
|
}
|
|
|
|
|
|
|
|
void NoiseSprite::setCustomUniforms()
|
|
|
|
{
|
|
|
|
_resolution[0] = getTexture()->getContentSizeInPixels().width;
|
|
|
|
_resolution[1] = getTexture()->getContentSizeInPixels().height;
|
2014-05-09 09:01:48 +08:00
|
|
|
getGLProgramState()->setUniformVec2("resolution", Vector2(_resolution[0],_resolution[1]));
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class EdgeDetectionSprite : public ShaderSprite, public ShaderSpriteCreator<EdgeDetectionSprite>
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 07:55:36 +08:00
|
|
|
CREATE_FUNC(EdgeDetectionSprite);
|
2013-09-09 17:49:13 +08:00
|
|
|
EdgeDetectionSprite();
|
|
|
|
|
|
|
|
protected:
|
2014-05-09 06:43:12 +08:00
|
|
|
virtual void setCustomUniforms() override;
|
|
|
|
|
|
|
|
GLfloat _resolution[2];
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
EdgeDetectionSprite::EdgeDetectionSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_edgeDetection.fsh";
|
|
|
|
}
|
|
|
|
|
|
|
|
void EdgeDetectionSprite::setCustomUniforms()
|
|
|
|
{
|
2014-05-09 06:43:12 +08:00
|
|
|
auto programState = getGLProgramState();
|
|
|
|
|
|
|
|
_resolution[0] = getContentSize().width;
|
|
|
|
_resolution[1] = getContentSize().height;
|
|
|
|
|
2014-05-09 09:01:48 +08:00
|
|
|
programState->setUniformVec2("resolution", Vector2(_resolution[0], _resolution[1]));
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
class BloomSprite : public ShaderSprite, public ShaderSpriteCreator<BloomSprite>
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 07:55:36 +08:00
|
|
|
CREATE_FUNC(BloomSprite);
|
2013-09-09 17:49:13 +08:00
|
|
|
BloomSprite();
|
|
|
|
|
|
|
|
protected:
|
2014-05-09 06:43:12 +08:00
|
|
|
virtual void setCustomUniforms() override;
|
|
|
|
|
|
|
|
GLfloat _resolution[2];
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
BloomSprite::BloomSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_bloom.fsh";
|
|
|
|
}
|
|
|
|
|
|
|
|
void BloomSprite::setCustomUniforms()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
class CelShadingSprite : public ShaderSprite, public ShaderSpriteCreator<CelShadingSprite>
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 07:55:36 +08:00
|
|
|
CREATE_FUNC(CelShadingSprite);
|
2013-09-09 17:49:13 +08:00
|
|
|
CelShadingSprite();
|
|
|
|
|
|
|
|
protected:
|
2014-05-09 06:43:12 +08:00
|
|
|
virtual void setCustomUniforms() override;
|
|
|
|
|
|
|
|
GLfloat _resolution[2];
|
2013-09-09 17:49:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
CelShadingSprite::CelShadingSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_celShading.fsh";
|
|
|
|
}
|
|
|
|
|
|
|
|
void CelShadingSprite::setCustomUniforms()
|
|
|
|
{
|
2014-05-09 06:43:12 +08:00
|
|
|
auto programState = getGLProgramState();
|
|
|
|
|
|
|
|
_resolution[0] = getContentSize().width;
|
|
|
|
_resolution[1] = getContentSize().height;
|
|
|
|
|
2014-05-09 09:01:48 +08:00
|
|
|
programState->setUniformVec2("resolution", Vector2(_resolution[0], _resolution[1]));
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
2013-09-12 10:25:55 +08:00
|
|
|
class LensFlareSprite : public ShaderSprite, public ShaderSpriteCreator<LensFlareSprite>
|
|
|
|
{
|
|
|
|
public:
|
2013-11-14 07:55:36 +08:00
|
|
|
CREATE_FUNC(LensFlareSprite);
|
2013-09-12 10:25:55 +08:00
|
|
|
LensFlareSprite();
|
2014-05-09 06:43:12 +08:00
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual void setCustomUniforms() override;
|
|
|
|
|
2013-09-12 10:25:55 +08:00
|
|
|
GLfloat _resolution[2];
|
|
|
|
GLfloat _textureResolution[2];
|
|
|
|
};
|
|
|
|
|
|
|
|
LensFlareSprite::LensFlareSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_lensFlare.fsh";
|
|
|
|
}
|
|
|
|
|
|
|
|
void LensFlareSprite::setCustomUniforms()
|
|
|
|
{
|
2014-05-09 06:43:12 +08:00
|
|
|
auto programState = getGLProgramState();
|
|
|
|
|
2013-09-12 10:25:55 +08:00
|
|
|
_textureResolution[0] = getTexture()->getContentSizeInPixels().width;
|
|
|
|
_textureResolution[1] = getTexture()->getContentSizeInPixels().height;
|
|
|
|
_resolution[0] = getContentSize().width;
|
|
|
|
_resolution[1] = getContentSize().height;
|
2014-05-09 06:43:12 +08:00
|
|
|
|
2014-05-09 09:01:48 +08:00
|
|
|
programState->setUniformVec2("resolution", Vector2(_resolution[0], _resolution[1]));
|
|
|
|
programState->setUniformVec2("textureResolution", Vector2(_textureResolution[0], _textureResolution[1]));
|
2013-09-12 10:25:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-09 17:49:13 +08:00
|
|
|
NormalSpriteTest::NormalSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init())
|
|
|
|
{
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
|
|
|
NormalSprite* sprite = NormalSprite::createSprite("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite->setPosition(Vector2(s.width/2, s.height/2));
|
2013-09-09 17:49:13 +08:00
|
|
|
addChild(sprite);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
GreyScaleSpriteTest::GreyScaleSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init())
|
|
|
|
{
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
|
|
|
GreyScaleSprite* sprite = GreyScaleSprite::createSprite("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite->setPosition(Vector2(s.width * 0.75, s.height/2));
|
2013-09-10 11:45:38 +08:00
|
|
|
auto sprite2 = Sprite::create("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite2->setPosition(Vector2(s.width * 0.25, s.height/2));
|
2013-09-09 17:49:13 +08:00
|
|
|
addChild(sprite);
|
2013-09-10 11:45:38 +08:00
|
|
|
addChild(sprite2);
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
BlurSpriteTest::BlurSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init())
|
|
|
|
{
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
|
|
|
BlurSprite* sprite = BlurSprite::createSprite("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite->setPosition(Vector2(s.width * 0.75, s.height/2));
|
2013-09-10 11:45:38 +08:00
|
|
|
auto sprite2 = Sprite::create("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite2->setPosition(Vector2(s.width * 0.25, s.height/2));
|
2013-09-09 17:49:13 +08:00
|
|
|
addChild(sprite);
|
2013-09-10 11:45:38 +08:00
|
|
|
addChild(sprite2);
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
NoiseSpriteTest::NoiseSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init())
|
|
|
|
{
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
|
|
|
NoiseSprite* sprite = NoiseSprite::createSprite("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite->setPosition(Vector2(s.width * 0.75, s.height/2));
|
2013-09-10 11:45:38 +08:00
|
|
|
auto sprite2 = Sprite::create("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite2->setPosition(Vector2(s.width * 0.25, s.height/2));
|
2013-09-09 17:49:13 +08:00
|
|
|
addChild(sprite);
|
2013-09-10 11:45:38 +08:00
|
|
|
addChild(sprite2);
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EdgeDetectionSpriteTest::EdgeDetectionSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init())
|
|
|
|
{
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
|
|
|
EdgeDetectionSprite* sprite = EdgeDetectionSprite::createSprite("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite->setPosition(Vector2(s.width * 0.75, s.height/2));
|
2013-09-10 11:45:38 +08:00
|
|
|
auto sprite2 = Sprite::create("Images/powered.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite2->setPosition(Vector2(s.width * 0.25, s.height/2));
|
2013-09-09 17:49:13 +08:00
|
|
|
addChild(sprite);
|
2013-09-10 11:45:38 +08:00
|
|
|
addChild(sprite2);
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BloomSpriteTest::BloomSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init())
|
|
|
|
{
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
2013-09-10 11:45:38 +08:00
|
|
|
BloomSprite* sprite = BloomSprite::createSprite("Images/stone.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite->setPosition(Vector2(s.width * 0.75, s.height/2));
|
2013-09-10 11:45:38 +08:00
|
|
|
auto sprite2 = Sprite::create("Images/stone.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite2->setPosition(Vector2(s.width * 0.25, s.height/2));
|
2013-09-09 17:49:13 +08:00
|
|
|
addChild(sprite);
|
2013-09-10 11:45:38 +08:00
|
|
|
addChild(sprite2);
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CelShadingSpriteTest::CelShadingSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init())
|
|
|
|
{
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
2013-09-10 11:45:38 +08:00
|
|
|
CelShadingSprite* sprite = CelShadingSprite::createSprite("Images/stone.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite->setPosition(Vector2(s.width * 0.75, s.height/2));
|
2013-09-10 11:45:38 +08:00
|
|
|
auto sprite2 = Sprite::create("Images/stone.png");
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite2->setPosition(Vector2(s.width * 0.25, s.height/2));
|
2013-09-09 17:49:13 +08:00
|
|
|
addChild(sprite);
|
2013-09-10 11:45:38 +08:00
|
|
|
addChild(sprite2);
|
2013-09-09 17:49:13 +08:00
|
|
|
}
|
|
|
|
}
|
2013-09-12 10:25:55 +08:00
|
|
|
|
|
|
|
LensFlareSpriteTest::LensFlareSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init())
|
|
|
|
{
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
|
|
|
LensFlareSprite* sprite = LensFlareSprite::createSprite("Images/noise.png");
|
|
|
|
Rect rect = Rect::ZERO;
|
|
|
|
rect.size = Size(480,320);
|
2014-04-15 18:23:40 +08:00
|
|
|
sprite->setPosition(Vector2(s.width * 0.5, s.height/2));
|
2013-09-12 10:25:55 +08:00
|
|
|
addChild(sprite);
|
|
|
|
}
|
|
|
|
}
|
2014-04-14 11:52:17 +08:00
|
|
|
|
|
|
|
|
|
|
|
class OutlineSprite : public ShaderSprite, public ShaderSpriteCreator<OutlineSprite>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
CREATE_FUNC(OutlineSprite);
|
|
|
|
OutlineSprite();
|
|
|
|
|
|
|
|
protected:
|
2014-05-09 06:43:12 +08:00
|
|
|
virtual void setCustomUniforms() override;
|
2014-04-14 11:52:17 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
OutlineSprite::OutlineSprite()
|
|
|
|
{
|
|
|
|
_fragSourceFile = "Shaders/example_outline.fsh";
|
2014-05-13 10:12:56 +08:00
|
|
|
_vertSourceFile = ""; //"Shaders/example_outline.vsh";
|
2014-04-14 11:52:17 +08:00
|
|
|
_blendFunc = BlendFunc::ALPHA_PREMULTIPLIED;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OutlineSprite::setCustomUniforms()
|
|
|
|
{
|
2014-05-09 06:43:12 +08:00
|
|
|
Vector3 color(1.0, 0.2, 0.3);
|
2014-04-14 12:03:37 +08:00
|
|
|
GLfloat radius = 0.01;
|
2014-04-14 11:52:17 +08:00
|
|
|
GLfloat threshold = 1.75;
|
2014-05-09 06:43:12 +08:00
|
|
|
|
|
|
|
auto programState = getGLProgramState();
|
|
|
|
|
2014-05-09 09:01:48 +08:00
|
|
|
programState->setUniformVec3("u_outlineColor", color);
|
|
|
|
programState->setUniformFloat("u_radius", radius);
|
|
|
|
programState->setUniformFloat("u_threshold", threshold);
|
2014-04-14 11:52:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
OutlineShadingSpriteTest::OutlineShadingSpriteTest()
|
|
|
|
{
|
|
|
|
if (ShaderTestDemo2::init()) {
|
|
|
|
auto s = Director::getInstance()->getWinSize();
|
|
|
|
OutlineSprite* sprite = OutlineSprite::createSprite("Images/grossini_dance_10.png");
|
2014-05-09 07:04:59 +08:00
|
|
|
sprite->setPosition(Vector2(s.width * 0.75, s.height/2));
|
2014-04-14 11:52:17 +08:00
|
|
|
auto sprite2 = Sprite::create("Images/grossini_dance_10.png");
|
2014-05-09 07:04:59 +08:00
|
|
|
sprite2->setPosition(Vector2(s.width * 0.25, s.height/2));
|
2014-04-14 11:52:17 +08:00
|
|
|
addChild(sprite);
|
|
|
|
addChild(sprite2);
|
|
|
|
}
|
|
|
|
}
|
2014-05-07 02:19:51 +08:00
|
|
|
|