/** * 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); }