/**
* Initialize shaders from files.
*
* @param vert Vertex shader file name.
* @param frag Fragment shader file name.
* @param texture Texture file name.
* @return if succcess, resturn true
*/
bool ShaderTextureNode::init(const std::string &vert, const std::string &frag, Texture2D* texture)
{
#if CC_ENABLE_CACHE_TEXTURE_DATA
auto listener = EventListenerCustom::create(EVENT_COME_TO_FOREGROUND, [this](EventCustom* event){
this->setGLProgramState(nullptr);
loadShaders(_vertFileName, _fragFileName);
});
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
#endif
_texture0 = texture;
_vertFileName = vert;
_fragFileName = frag;
loadShaders(vert, frag);
_time = 0;
_resolution = Vec2(1, 1);
getGLProgramState()->setUniformVec2("resolution", _resolution);
// Pass the texture to the shader
getGLProgramState()->setUniformTexture("u_texture0", _texture0);
scheduleUpdate();
setContentSize(Size(1, 1));
setAnchorPoint(Vec2(0.5f, 0.5f));
return true;
}
void Sprite::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
#if CC_USE_CULLING
// Don't do calculate the culling if the transform was not updated
_insideBounds = (flags & FLAGS_TRANSFORM_DIRTY) ? renderer->checkVisibility(transform, _contentSize) : _insideBounds;
if(_insideBounds)
#endif
{
if (_texture->isReference()) {
auto tm = ensureTexModule();
if (!tm) return;
_quadCommand.init(_globalZOrder, tm->tex->getName(), getGLProgramState(), _blendFunc, &_quad, 1, transform, flags);
} else {
_quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, &_quad, 1, transform, flags);
}
renderer->addCommand(&_quadCommand);
#if CC_SPRITE_DEBUG_DRAW
_debugDrawNode->clear();
Vec2 vertices[4] = {
Vec2( _quad.bl.vertices.x, _quad.bl.vertices.y ),
Vec2( _quad.br.vertices.x, _quad.br.vertices.y ),
Vec2( _quad.tr.vertices.x, _quad.tr.vertices.y ),
Vec2( _quad.tl.vertices.x, _quad.tl.vertices.y ),
};
_debugDrawNode->drawPoly(vertices, 4, true, Color4F(1.0, 1.0, 1.0, 1.0));
#endif //CC_SPRITE_DEBUG_DRAW
}
}
void EffectNormalMapped::setLightColor(const Color4F& color)
{
_lightColor = color;
auto glProgramState = getGLProgramState();
if(glProgramState) getGLProgramState()->setUniformVec3("u_diffuseL", Vec3(_lightColor.r,_lightColor.g,_lightColor.b));
}
virtual void setTarget(EffectSprite* sprite) override
{
auto s = sprite->getTexture()->getContentSizeInPixels();
getGLProgramState()->setUniformVec2("textureResolution", Vec2(s.width, s.height));
s = Director::getInstance()->getWinSize();
getGLProgramState()->setUniformVec2("resolution", Vec2(s.width, s.height));
}
void Sprite3D::setTexture(Texture2D* texture)
{
if(_texture != texture) {
CC_SAFE_RETAIN(texture);
CC_SAFE_RELEASE_NULL(_texture);
_texture = texture;
if (getGLProgramState() && _mesh)
{
GLuint texID = _texture ? _texture->getName() : 0;
_meshCommand.genMaterialID(texID, getGLProgramState(), _mesh, _blend);
}
}
}
void EffectNormalMapped::updateUniforms()
{
if(_pointLight && _sprite)
{
Size winSize=Director::getInstance()->getWinSize();
getGLProgramState()->setUniformFloat("u_kBump", _kBump);
Mat4 mat= _pointLight->getNodeToWorldTransform();
Point lightPosInLocalSpace=PointApplyAffineTransform(Vec2(mat.m[12], mat.m[13]),_sprite->parentToNodeTransform());
getGLProgramState()->setUniformVec4("u_lightPosInLocalSpace", Vec4(lightPosInLocalSpace.x,lightPosInLocalSpace.y,mat.m[14],1));
const Color3B &col = _pointLight->getDisplayedColor();
getGLProgramState()->setUniformVec3("u_diffuseL", Vec3(col.r/255.0f,col.g/255.0f,col.b/255.0f));
}
}
void SpriteBlur::initGLProgram()
{
GLchar * fragSource = (GLchar*)String::createWithContentsOfFile(
FileUtils::getInstance()->fullPathForFilename("Shaders/example_Blur.fsh").c_str())->getCString();
auto program = GLProgram::createWithByteArrays(ccPositionTextureColor_noMVP_vert, fragSource);
auto glProgramState = GLProgramState::getOrCreateWithGLProgram(program);
setGLProgramState(glProgramState);
auto size = getTexture()->getContentSizeInPixels();
getGLProgramState()->setUniformVec2("resolution", size);
getGLProgramState()->setUniformFloat("blurRadius", _blurRadius);
getGLProgramState()->setUniformFloat("sampleNum", 7.0f);
}
/**
* Draw a primitive.
*
* @param transform Transform matrix
* @param flags Flags to draw
*/
void ShaderTextureNode::onDraw(const Mat4 &transform, uint32_t flags)
{
GLfloat vertices[48] = {
-1, -1, 0, 1, 1, 1, 1, 1, // Lower-Left
1, -1, 1, 1, 1, 1, 1, 1, // Lower-Right
1, 1, 1, 0, 1, 1, 1, 1, // Upper-Right
-1, -1, 0, 1, 1, 1, 1, 1, // Lower-Left
1, 1, 1, 0, 1, 1, 1, 1, // Upper-Right
-1, 1, 0, 0, 1, 1, 1, 1, // Upper-Left
};
auto glProgramState = getGLProgramState();
glProgramState->setVertexAttribPointer("a_position", 2, GL_FLOAT, GL_FALSE, 32, vertices);
glProgramState->setVertexAttribPointer("a_texCoord", 2, GL_FLOAT, GL_FALSE, 32, vertices + 2);
glProgramState->setVertexAttribPointer("a_color", 4, GL_FLOAT, GL_FALSE, 32, vertices + 4);
glProgramState->apply(transform);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glDisable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
// Alpha blending
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDrawArrays(GL_TRIANGLES, 0, 6);
// glDisable(GL_BLEND);
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 6);
}
/**
* Update per frames.
*
* @param dt Elapsed time
*/
void ShaderNode::update(float dt)
{
_time += dt;
// Pass the current time (float value)
getGLProgramState()->setUniformFloat("u_time", _time);
}
void LightEffect::prepareForRender(Sprite *sprite, Texture2D *normalmap)
{
auto gl = getGLProgramState();
gl->setUniformVec2("u_contentSize", sprite->getContentSize());
Point posRelToSprite = PointApplyAffineTransform(Point(_lightPos.x, _lightPos.y), sprite->getWorldToNodeAffineTransform());
gl->setUniformVec3("u_lightPos", Vec3(posRelToSprite.x, posRelToSprite.y, _lightPos.z));
gl->setUniformTexture("u_normals", normalmap);
int opacity = sprite->getOpacity();
SpriteFrame *frame = sprite->getSpriteFrame();
Size untrimmedSize = frame->getOriginalSize();
Size trimmedSize = frame->getRect().size;
Vec2 framePos = frame->getRect().origin;
Size texSize = frame->getTexture()->getContentSize();
// set sprite position in sheet
gl->setUniformVec2("u_spritePosInSheet", Vec2(framePos.x / texSize.width, framePos.y / texSize.height));
gl->setUniformVec2("u_spriteSizeRelToSheet", Vec2(untrimmedSize.width / texSize.width, untrimmedSize.height / texSize.height));
gl->setUniformInt("u_spriteRotated", frame->isRotated());
gl->setUniformFloat("u_spriteOpacity", (float)opacity / 255.0f);
// set offset of trimmed sprite
Vec2 bottomLeft = frame->getOffset() + (untrimmedSize - trimmedSize) / 2;
Vec2 cornerOffset = frame->isRotated() ? Vec2(bottomLeft.y, bottomLeft.x)
: Vec2(bottomLeft.x, untrimmedSize.height - trimmedSize.height - bottomLeft.y);
gl->setUniformVec2("u_spriteOffset", cornerOffset);
}
void EffectNormalMapped::setLightPos(const Vec3& pos)
{
_lightPos = pos;
auto glProgramState = getGLProgramState();
if(glProgramState) glProgramState->setUniformVec4("u_lightPosInLocalSpace", Vec4(_lightPos.x,_lightPos.y,_lightPos.z,1));
}
void MGRBlurSprite::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
#if CC_USE_CULLING
// Don't do calculate the culling if the transform was not updated
_insideBounds = (flags & FLAGS_TRANSFORM_DIRTY) ? renderer->checkVisibility(transform, _contentSize) : _insideBounds;
if(_insideBounds)
#endif
{
_beforeDrawCmd.init(_globalZOrder);
_beforeDrawCmd.func = [=](){
auto shader = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR_BLUR_NO_MVP);
auto programState = GLProgramState::getOrCreateWithGLProgram(shader);
programState->setUniformFloat("urate", _urate);
// このシェーダがコンテキストになっているときにUniformを設定せねば意味がないので、上記のやり方を使う。
// 上記はProgramStateとして値を保存して、シェーダ使用時に使ってくれる
// 下記は、トライアングルコマンド発行時に使われると限らないやり方
//GLint uniformUrate = glGetUniformLocation(getGLProgram()->getProgram(), "urate");
//getGLProgram()->setUniformLocationWith1f(uniformUrate, _urate);
};
renderer->addCommand(&_beforeDrawCmd);
_trianglesCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, _polyInfo.triangles, transform, flags);
renderer->addCommand(&_trianglesCommand);
}
}
// AtlasNode - draw
void AtlasNode::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
_quadCommand.init(_globalZOrder, _textureAtlas->getTexture()->getName(), getGLProgramState(), _blendFunc, _textureAtlas->getQuads(), _quadsToDraw, transform, flags);
renderer->addCommand(&_quadCommand);
}
void Sprite3D::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
GLProgramState* programstate = getGLProgramState();
Color4F color(getDisplayedColor());
color.a = getDisplayedOpacity() / 255.0f;
GLuint textureID = _texture ? _texture->getName() : 0;
_meshCommand.init(_globalZOrder,
textureID,
programstate,
_blend,
_mesh->getVertexBuffer(),
_mesh->getIndexBuffer(),
(GLenum)_mesh->getPrimitiveType(),
(GLenum)_mesh->getIndexFormat(),
_mesh->getIndexCount(),
transform);
_meshCommand.setCullFaceEnabled(true);
_meshCommand.setDepthTestEnabled(true);
if (_skin)
{
_meshCommand.setMatrixPaletteSize((int)_skin->getMatrixPaletteSize());
_meshCommand.setMatrixPalette(_skin->getMatrixPalette());
}
//support tint and fade
_meshCommand.setDisplayColor(Vec4(color.r, color.g, color.b, color.a));
Director::getInstance()->getRenderer()->addCommand(&_meshCommand);
}
void draw(Renderer *renderer, const Mat4 &transform, bool transformUpdated)
{
// Don't do calculate the culling if the transform was not updated
_insideBounds = transformUpdated ? renderer->checkVisibility(transform, _contentSize) : _insideBounds;
if(_insideBounds)
{
// negative effects: order < 0
int idx=0;
for(auto &effect : _effects) {
if(std::get<0>(effect) >=0)
break;
QuadCommand &q = std::get<2>(effect);
q.init(_globalZOrder, _texture->getName(), std::get<1>(effect)->getGLProgramState(), _blendFunc, &_quad, 1, transform);
renderer->addCommand(&q);
idx++;
}
// normal effect: order == 0
_quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, &_quad, 1, transform);
renderer->addCommand(&_quadCommand);
// postive effects: oder >= 0
for(auto it = std::begin(_effects)+idx; it != std::end(_effects); ++it) {
QuadCommand &q = std::get<2>(*it);
q.init(_globalZOrder, _texture->getName(), std::get<1>(*it)->getGLProgramState(), _blendFunc, &_quad, 1, transform);
renderer->addCommand(&q);
idx++;
}
}
}
bool ShaderNode::initWithVertex(const std::string &vert, const std::string &frag)
{
#if CC_ENABLE_CACHE_TEXTURE_DATA
auto listener = EventListenerCustom::create(EVENT_RENDERER_RECREATED, [this](EventCustom* event){
this->setGLProgramState(nullptr);
loadShaderVertex(_vertFileName, _fragFileName);
});
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
#endif
_vertFileName = vert;
_fragFileName = frag;
loadShaderVertex(vert, frag);
_time = 0;
_resolution = Vec2(SIZE_X, SIZE_Y);
getGLProgramState()->setUniformVec2("resolution", _resolution);
scheduleUpdate();
setContentSize(Size(SIZE_X, SIZE_Y));
setAnchorPoint(Vec2(0.5f, 0.5f));
return true;
}
void ShaderNode::setPosition(const Vec2 &newPosition)
{
Node::setPosition(newPosition);
auto position = getPosition();
_center = Vec2(position.x * CC_CONTENT_SCALE_FACTOR(), position.y * CC_CONTENT_SCALE_FACTOR());
getGLProgramState()->setUniformVec2("center", _center);
}
bool SpriteWithHsv::updateMatrix() {
if (HsvProtocol::updateMatrix()) {
getGLProgramState()->setUniformMat4("u_hsv", getHsvMatrix());
return true;
}
return false;
}
/**
* Draws the model
*
* @param transform Transform matrix
* @param flags Flags to draw
*/
void NewParametricShaderNode::onDraw(const Mat4 &transform, uint32_t flags)
{
setCommon3dEnvironment();
auto glProgramState = getGLProgramState();
// Pass the position parameter to the vertex shader's attribute variable
glProgramState->setVertexAttribPointer("a_position",
3, GL_FLOAT, GL_FALSE, 44, _vertices[0].position);
glProgramState->setVertexAttribPointer("a_normal",
3, GL_FLOAT, GL_FALSE, 44, _vertices[0].normal);
glProgramState->setVertexAttribPointer("a_texCoord",
2, GL_FLOAT, GL_FALSE, 44, _vertices[0].texCoord);
glProgramState->setVertexAttribPointer("a_tangent",
3, GL_FLOAT, GL_FALSE, 44, _vertices[0].tangent);
glProgramState->apply(transform);
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
// glCullFace(GL_FRONT);
glEnable(GL_CULL_FACE);
// Alpha blenfing
// glEnable(GL_BLEND);
// glDisable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glBlendFunc(GL_ONE, GL_ONE);
// Draw triangles using indices
glDrawElements(GL_TRIANGLES, _numIndices, GL_UNSIGNED_SHORT, _indices);
// glDisable(GL_BLEND);
// CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 3);
}
void EffectSprite::draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t flags){
#if CC_USE_CULLING
// Don't do calculate the culling if the transform was not updated
_insideBounds = (flags & FLAGS_TRANSFORM_DIRTY) ? renderer->checkVisibility(transform, _contentSize) : _insideBounds;
if(_insideBounds)
#endif
{
// negative effects: order < 0
int idx=0;
for(auto &effect : _effects) {
if(std::get<0>(effect) >=0)
break;
QuadCommand &q = std::get<2>(effect);
q.init(_globalZOrder, _texture->getName(), std::get<1>(effect)->getGLProgramState(), _blendFunc, &_quad, 1, transform);
renderer->addCommand(&q);
idx++;
}
// normal effect: order == 0
_quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, &_quad, 1, transform);
renderer->addCommand(&_quadCommand);
// postive effects: oder >= 0
for(auto it = std::begin(_effects)+idx; it != std::end(_effects); ++it) {
QuadCommand &q = std::get<2>(*it);
q.init(_globalZOrder, _texture->getName(), std::get<1>(*it)->getGLProgramState(), _blendFunc, &_quad, 1, transform);
renderer->addCommand(&q);
idx++;
}
}
}
void GAFSprite::customDraw(cocos2d::Mat4& transform)
{
CCAssert(!_batchNode, "If cocos2d::Sprite is being rendered by CCSpriteBatchNode, cocos2d::Sprite#draw SHOULD NOT be called");
getGLProgramState()->apply(transform);
if (m_useSeparateBlendFunc)
{
glBlendFuncSeparate(m_blendFuncSeparate.src, m_blendFuncSeparate.dst,
m_blendFuncSeparate.srcAlpha, m_blendFuncSeparate.dstAlpha);
}
else
{
cocos2d::GL::blendFunc(_blendFunc.src, _blendFunc.dst);
}
if (m_blendEquation != -1)
{
glBlendEquation(m_blendEquation);
}
if (_texture != NULL)
{
cocos2d::GL::bindTexture2D(_texture->getName());
}
else
{
cocos2d::GL::bindTexture2D(0);
}
//
// Attributes
//
cocos2d::GL::enableVertexAttribs(cocos2d::GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX);
CHECK_GL_ERROR_DEBUG();
#define kQuadSize sizeof(_quad.bl)
long offset = (long)&_quad;
// vertex
int diff = offsetof(cocos2d::V3F_C4B_T2F, vertices);
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));
// texCoods
diff = offsetof(cocos2d::V3F_C4B_T2F, texCoords);
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));
// color
diff = offsetof(cocos2d::V3F_C4B_T2F, colors);
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff));
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
CHECK_GL_ERROR_DEBUG();
//USING_NS_CC;
//CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 4);
//CC_INCREMENT_GL_DRAWS(1);
}
void setMatrixAndColorTransform(const Matrix *m, const ColorTransform *cx)
{
bool changed = m_matrix.SetWithComparing(m);
if (changed) {
cocos2d::Mat4 mat = cocos2d::Mat4(
m->scaleX, m->skew0, 0, m->translateX,
-m->skew1, -m->scaleY, 0, -m->translateY,
0, 0, 1, 0,
0, 0, 0, 1);
setNodeToParentTransform(mat);
}
cocos2d::Node *node = getParent();
const Color &c = cx->multi;
const Color &a = cx->add;
const cocos2d::Color3B &dc = node->getDisplayedColor();
setColor((cocos2d::Color3B){
(GLubyte)(c.red * dc.r),
(GLubyte)(c.green * dc.g),
(GLubyte)(c.blue * dc.b)});
setOpacity(
(GLubyte)((c.alpha + a.alpha) * node->getDisplayedOpacity()));
if (a.red == 0 && a.green == 0 && a.blue == 0) {
if (m_glProgramState != 0 &&
getGLProgramState() != m_glProgramState) {
setGLProgramState(m_glProgramState);
}
} else {
if (m_glProgramState == 0) {
m_glProgramState = getGLProgramState();
m_glProgramState->retain();
cocos2d::LWFResourceCache *cache =
cocos2d::LWFResourceCache::sharedLWFResourceCache();
m_additiveGlProgramState = cocos2d::GLProgramState::create(
m_hasPremultipliedAlpha ? cache->getAddColorPAGLProgram() :
cache->getAddColorGLProgram());
m_additiveGlProgramState->retain();
}
m_additiveGlProgramState->setUniformVec3(
"additiveColor", cocos2d::Vec3(a.red, a.green, a.blue));
if (getGLProgramState() != m_additiveGlProgramState)
setGLProgramState(m_additiveGlProgramState);
}
}
void Skybox::onDraw(const Mat4& transform, uint32_t flags)
{
auto camera = Camera::getVisitingCamera();
Mat4 cameraModelMat = camera->getNodeToWorldTransform();
auto state = getGLProgramState();
state->apply(transform);
Vec4 color(_displayedColor.r / 255.f, _displayedColor.g / 255.f, _displayedColor.b / 255.f, 1.f);
state->setUniformVec4("u_color", color);
cameraModelMat.m[12] = cameraModelMat.m[13] = cameraModelMat.m[14] = 0;
state->setUniformMat4("u_cameraRot", cameraModelMat);
glEnable(GL_DEPTH_TEST);
StateBlock::_defaultState->setDepthTest(true);
glDepthFunc(GL_LEQUAL);
StateBlock::_defaultState->setDepthFunction(DEPTH_LEQUAL);
glEnable(GL_CULL_FACE);
StateBlock::_defaultState->setCullFace(true);
glCullFace(GL_BACK);
StateBlock::_defaultState->setCullFaceSide(CULL_FACE_SIDE_BACK);
glDisable(GL_BLEND);
StateBlock::_defaultState->setBlend(false);
if (Configuration::getInstance()->supportsShareableVAO())
{
GL::bindVAO(_vao);
}
else
{
GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION);
glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(Vec3), nullptr);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer);
}
glDrawElements(GL_TRIANGLES, (GLsizei)36, GL_UNSIGNED_BYTE, nullptr);
if (Configuration::getInstance()->supportsShareableVAO())
{
GL::bindVAO(0);
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, 8);
CHECK_GL_ERROR_DEBUG();
}
void Skin::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
auto mv = Director::getInstance()->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
//TODO: implement z order
_quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, &_quad, 1, mv, flags);
renderer->addCommand(&_quadCommand);
}
void BillBoard::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
//FIXME: frustum culling here
_quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, &_quad, 1, _modelViewTransform, flags);
_quadCommand.setTransparent(true);
_quadCommand.setSkipBatching(true);
renderer->addCommand(&_quadCommand);
}
// AtlasNode - draw
void AtlasNode::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
// x-studio365 spec: ETC1 ALPHA supports. -- TODO
_quadCommand.init(_globalZOrder, _textureAtlas->getTexture()->getName(), getGLProgramState(), _blendFunc, _textureAtlas->getQuads(), _quadsToDraw, transform, flags, _textureAtlas->getTexture()->getAlphaName());
renderer->addCommand(&_quadCommand);
}
void FilledPolygon::setTexturePolygon(const std::vector<Vec2> &texturePolygon, bool determineBounds)
{
CC_SAFE_DELETE_ARRAY(_positionTriangles);
CC_SAFE_DELETE_ARRAY(_textureTriangles);
_determineBounds = determineBounds;
// triangulate polygon using Ratcliff's triangulator
std::vector<Vec2> triangulatedVertices;
Triangulate::Process(texturePolygon, triangulatedVertices);
_verticesCount = (int)triangulatedVertices.size();
_positionTriangles = new Vec2[_verticesCount];
_textureTriangles = new Vec2[_verticesCount];
// determine polygon bounds
if (_determineBounds) {
_origin = Vec2(std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
Vec2 _maxBound = Vec2::ZERO;
for (const Vec2& v : triangulatedVertices){
if(v.x < _origin.x) _origin.x = v.x;
if(v.y < _origin.y) _origin.y = v.y;
if(v.x > _maxBound.x) _maxBound.x = v.x;
if(v.y > _maxBound.y) _maxBound.y = v.y;
}
setContentSize(Size(_maxBound - _origin));
for (int i = 0; i < _verticesCount; i++) {
_positionTriangles[i] = triangulatedVertices.at(i) - _origin;
}
} else {
for (int i = 0; i < _verticesCount; i++) {
_positionTriangles[i] = triangulatedVertices.at(i);
}
}
calculateTextureCoordinates();
// set parameters to shader attributes
getGLProgramState()->setVertexAttribPointer(GLProgram::ATTRIBUTE_NAME_POSITION, 2, GL_FLOAT, GL_FALSE, 0, _positionTriangles);
getGLProgramState()->setVertexAttribPointer(GLProgram::ATTRIBUTE_NAME_TEX_COORD, 2, GL_FLOAT, GL_FALSE, 0, _textureTriangles);
}
void FSprite::UpdateAlphaTexture(const std::string& alpha_file)
{
#ifdef ETC1
#pragma message("getTextureForKey or someth else, texture should be added (cocos should check that anyway but still dont do it) on loading scene, do not add all the time!!")
Texture2D* tex = Director::getInstance()->getTextureCache()->addImage(alpha_file);
current_alpha_file_ = alpha_file;
getGLProgramState()->setUniformTexture("u_texture1", tex);
#endif
}
// overriding draw method
void ParticleSystemQuad::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
//quad command
if(_particleCount > 0)
{
_quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, _quads, _particleCount, transform, flags);
renderer->addCommand(&_quadCommand);
}
}
void BillBoard::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
//FIXME: frustum culling here
flags |= Node::FLAGS_RENDER_AS_3D;
_trianglesCommand.init(0, _texture->getName(), getGLProgramState(), _blendFunc, _polyInfo.triangles, _modelViewTransform, flags);
_trianglesCommand.setTransparent(true);
_trianglesCommand.set3D(true);
renderer->addCommand(&_trianglesCommand);
}
