// Center of tree
void centerBranch(int depth) {
int terminatingBranch = 0;
if (depth == 0) {
translateBy(0, 5 * (1.0 / scaleFactor), 0);
terminatingLeaf();
return;
} // if
if (depth == 1) {
terminatingBranch = TERM;
} // if
translateBy(0, 6 * (depth * 1.0 / scaleFactor), 0);
drawBranch(CENTER, depth);
// Left branch
pushMatrix();
turnLeft();
translateBy(0, 6 * (depth * 1.0 / scaleFactor), 0);
drawBranch(LEFT | terminatingBranch, depth);
leftBranch(depth - 1);
popMatrix();
// 3D left branch
pushMatrix();
rotateBy(90, 0, 1, 0);
rotateBy(15, 0, 0, 1);
translateBy(1, 0, 0);
turnLeft();
translateBy(0, 6 * (depth * 1.0 / scaleFactor), 0);
drawBranch(LEFT | terminatingBranch, depth);
leftBranch(depth - 1);
popMatrix();
translateBy(0, 6 * (depth * 1.0 / scaleFactor), 0);
drawBranch(CENTER, depth);
// Right branch
pushMatrix();
turnRight();
translateBy(0, 6 * (depth * 1.0 / scaleFactor), 0);
drawBranch(RIGHT | terminatingBranch, depth);
rightBranch(depth - 1);
popMatrix();
// 3D right branch
pushMatrix();
rotateBy(90, 0, 1, 0);
rotateBy(-15, 0, 0, 1);
translateBy(-1, 0, 0);
turnRight();
translateBy(0, 6 * (depth * 1.0 / scaleFactor), 0);
drawBranch(RIGHT | terminatingBranch, depth);
rightBranch(depth - 1);
popMatrix();
translateBy(0, 6 * (depth * 1.0 / scaleFactor), 0);
drawBranch(CENTER | TERM, depth);
centerBranch(depth - 1);
} // centerBranch
void ofMatrixStack::popView(){
if(!viewMatrixStack.empty()){
viewMatrix = viewMatrixStack.top();
viewMatrixStack.pop();
}
if(!orientationStack.empty()){
pair<ofOrientation,bool> orientationFlip = orientationStack.top();
setOrientation(orientationFlip.first,orientationFlip.second);
orientationStack.pop();
}
if( viewportHistory.size() ){
currentViewport = viewportHistory.top();
viewportHistory.pop();
}
ofMatrixMode currentMode = currentMatrixMode;
matrixMode(OF_MATRIX_PROJECTION);
popMatrix();
matrixMode(OF_MATRIX_MODELVIEW);
popMatrix();
matrixMode(currentMode);
}
//////////////////////////////////////////////////////////////////////////
// postUpdate
//virtual
void ScnCanvasComponent::postUpdate( BcF32 Tick )
{
if( Clear_ )
{
popMatrix();
popMatrix();
}
}
void Scene::render(Renderer* renderer)
{
auto director = Director::getInstance();
Camera* defaultCamera = nullptr;
const auto& transform = getNodeToParentTransform();
for (const auto& camera : getCameras())
{
if (!camera->isVisible())
continue;
Camera::_visitingCamera = camera;
if (Camera::_visitingCamera->getCameraFlag() == CameraFlag::DEFAULT)
{
defaultCamera = Camera::_visitingCamera;
}
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
camera->apply();
//clear background with max depth
camera->clearBackground();
//visit the scene
visit(renderer, transform, 0);
#if CC_USE_NAVMESH
if (_navMesh && _navMeshDebugCamera == camera)
{
_navMesh->debugDraw(renderer);
}
#endif
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
#if CC_USE_3D_PHYSICS && CC_ENABLE_BULLET_INTEGRATION
if (_physics3DWorld && _physics3DWorld->isDebugDrawEnabled())
{
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, _physics3dDebugCamera != nullptr ? _physics3dDebugCamera->getViewProjectionMatrix() : defaultCamera->getViewProjectionMatrix());
_physics3DWorld->debugDraw(renderer);
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
#endif
Camera::_visitingCamera = nullptr;
experimental::FrameBuffer::applyDefaultFBO();
}
QENGINE_API void renderFullscreenTexturedQuad(bool invertV, unsigned int texID)
{
if(texID <= 0)
return;
int isDepthEnabled = isZTestEnabled();
// float minV, maxV;
// minV = 0.0f; maxV = 1.0f;
// if (invertV)
// {
// minV = 1.0f; maxV = 0.0f;
// }
disableZTest();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
mat4f ID;
ID.loadIdentity();
pushMatrix(MATRIX_MODEL, ID);
pushMatrix(MATRIX_VIEW, ID);
pushMatrix(MATRIX_PROJECTION, ID);
float a = 1.0f;
float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
g_pTexturedEffect->Bind();
g_pTexturedEffect->BindTexture("s0", texID);
g_pTexturedEffect->BindBool("invert", invertV);
g_pTexturedEffect->BindFloat("globalColor", color, 4);
g_pTexturedEffect->BindStateMatrix("MVP", MATRIX_MODEL | MATRIX_VIEW | MATRIX_PROJECTION);
bindBuffer(g_fullscreenQuad);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
bindDefaultBuffer();
g_pTexturedEffect->EvictTextures();
g_pTexturedEffect->Unbind();
glDisable(GL_BLEND);
popMatrix(MATRIX_MODEL);
popMatrix(MATRIX_VIEW);
popMatrix(MATRIX_PROJECTION);
if(isDepthEnabled)
enableZTest();
}
void GameOver::draw(struct MyMesh* mesh, VSShaderLib& shader, GLint& pvm_uniformId, GLint& vm_uniformId, GLint& normal_uniformId, GLint& texMode_uniformId, int *objId){
*objId=11;
GLint loc;
// send the material
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.ambient");
glUniform4fv(loc, 1, mesh[*objId].mat.ambient);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.diffuse");
glUniform4fv(loc, 1, mesh[*objId].mat.diffuse);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.specular");
glUniform4fv(loc, 1, mesh[*objId].mat.specular);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.shininess");
glUniform1f(loc,mesh[*objId].mat.shininess);
pushMatrix(MODEL);
translate(MODEL, -7.5f, 0.0f, 15.0f);
scale(MODEL, 15.0f, 0.0f, 30.0f);
rotate(MODEL, 90.0, 0.0f, 0.0f, 1.0f);
rotate(MODEL, 180.0, 1.0f, 0.0f, 0.0f);
// send matrices to OGL
computeDerivedMatrix(PROJ_VIEW_MODEL);
glUniformMatrix4fv(vm_uniformId, 1, GL_FALSE, mCompMatrix[VIEW_MODEL]);
glUniformMatrix4fv(pvm_uniformId, 1, GL_FALSE, mCompMatrix[PROJ_VIEW_MODEL]);
computeNormalMatrix3x3();
glUniformMatrix3fv(normal_uniformId, 1, GL_FALSE, mNormal3x3);
// Render mesh
glUniform1i(texMode_uniformId, 4); // apenas o texel
glBindVertexArray(mesh[*objId].vao);
glDrawElements(mesh[*objId].type,mesh[*objId].numIndexes, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
popMatrix(MODEL);
}
void Graphics::drawWallTile(const int32_t x, const int32_t y, const Facing side, const uint32_t modelID) {
glUniform1i(texUniform, 0);
pushMatrix();
loadIdentity();
translate(x * 16.0f, 0.0f, y * 16.0f);
switch(side) {
case Facing::SOUTH:
rotate(toRadians(270), 0.0f, 1.0f, 0.0f);
break;
case Facing::WEST:
rotate(toRadians(180), 0.0f, 1.0f, 0.0f);
break;
case Facing::NORTH:
rotate(toRadians(90), 0.0f, 1.0f, 0.0f);
break;
case Facing::EAST:
rotate(toRadians(0), 0.0f, 1.0f, 0.0f);
break;
default:
break;
}
if (wallMesh) {
wallMesh->draw();
}
popMatrix();
}
void GLNode::onDraw(Mat4 &transform, uint32_t flags)
{
JSContext *cx = ScriptingCore::getInstance()->getGlobalContext();
js_type_class_t *typeClass = js_get_type_from_native<cocos2d::GLNode>(this);
JS::RootedObject jsObj(cx, jsb_ref_get_or_create_jsobject(cx, this, typeClass, "cocos2d::GLNode"));
if (jsObj.get())
{
bool found = false;
JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET
JS_HasProperty(cx, jsObj, "draw", &found);
if (found) {
auto director = Director::getInstance();
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW, transform);
JS::RootedValue rval(cx);
JS::RootedValue fval(cx);
JS_GetProperty(cx, jsObj, "draw", &fval);
JS_CallFunctionValue(cx, jsObj, fval, JS::HandleValueArray::empty(), &rval);
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
}
}
}
void Scene::render(Renderer* renderer)
{
auto director = Director::getInstance();
Camera* defaultCamera = nullptr;
const auto& transform = getNodeToParentTransform();
if (_cameraOrderDirty)
{
stable_sort(_cameras.begin(), _cameras.end(), camera_cmp);
_cameraOrderDirty = false;
}
for (const auto& camera : _cameras)
{
if (!camera->isVisible())
continue;
Camera::_visitingCamera = camera;
if (Camera::_visitingCamera->getCameraFlag() == CameraFlag::DEFAULT)
{
defaultCamera = Camera::_visitingCamera;
}
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
//visit the scene
visit(renderer, transform, 0);
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
Camera::_visitingCamera = nullptr;
}
void CSprite::Render(vec3f camPos)
{
vec4f pos[4];
float h2 = height * 0.5f;
float w2 = width * 0.5f;
pos[0].set(center.x - w2, center.y - h2, center.z, 1.0f);
pos[1].set(center.x + w2, center.y - h2, center.z, 1.0f);
pos[2].set(center.x + w2, center.y + h2, center.z, 1.0f);
pos[3].set(center.x - w2, center.y + h2, center.z, 1.0f);
vec3f look = camPos - center;
look.normalize();
vec3f up(0.0f, 1.0f, 0.0f);
vec3f right = up.crossProd(look);
up = look.crossProd(right);
mat4f m, t, nt, f, R;
R.loadZRotation(angle);
m.m[0] = right.x; m.m[4] = up.x; m.m[8] = look.x; m.m[12] = 0.0f;
m.m[1] = right.y; m.m[5] = up.y; m.m[9] = look.y; m.m[13] = 0.0f;
m.m[2] = right.z; m.m[6] = up.z; m.m[10] = look.z; m.m[14] = 0.0f;
m.m[3] = 0.0f; m.m[7] = 0.0f; m.m[11] = 0.0f; m.m[15] = 1.0f;
m *= R;
nt.loadTranslation(-center.x, -center.y, -center.z);
t.loadTranslation(center.x, center.y, center.z);
float verts[20] = { pos[0].x, pos[0].y, pos[0].z, 0.0f, 0.0f,
pos[1].x, pos[1].y, pos[1].z, 1.0f, 0.0f,
pos[2].x, pos[2].y, pos[2].z, 1.0f, 1.0f,
pos[3].x, pos[3].y, pos[3].z, 0.0f, 1.0f };
mat4_mul_mat4(m.m, nt.m, f.m);
mat4_mul_mat4(t.m, f.m, m.m);
pushMatrix(MATRIX_MODEL, m);
unsigned int indices[6] = { 0, 1, 2, 0, 2, 3 };
float color[4] = {r, g, b, a};
g_pTexturedEffect->Bind();
bool invert = false;
g_pTexturedEffect->BindBool("invert", invert);
g_pTexturedEffect->BindFloat("globalColor", color, 4);
g_pTexturedEffect->BindStateMatrix("MVP", MATRIX_MODEL | MATRIX_VIEW | MATRIX_PROJECTION);
g_pTexturedEffect->BindTexture("s0", texID);
glEnableVertexAttribArray(LOC_POSITION);
glEnableVertexAttribArray(LOC_TEXCOORD0);
glVertexAttribPointer(LOC_POSITION, 3, GL_FLOAT, GL_FALSE, 20, verts);
glVertexAttribPointer(LOC_TEXCOORD0, 2, GL_FLOAT, GL_TRUE, 20, (float*)&verts[3]);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, indices);
glDisableVertexAttribArray(LOC_POSITION);
glDisableVertexAttribArray(LOC_TEXCOORD0);
g_pTexturedEffect->EvictTextures();
g_pTexturedEffect->Unbind();
popMatrix(MATRIX_MODEL);
}
void ofxMatrixTransformImageRef::draw ( )
{
pushMatrix( ) ;
ofSetColor ( 255 , 255 , 255 , getOFAlpha() ) ;
if ( image != NULL && image->bAllocated() )
image->draw ( image->width * -_anchor.x , image->height * -_anchor.y ) ;
popMatrix( ) ;
}
void ofCairoRenderer::draw(vector<ofPoint> & vertexData, ofPrimitiveMode drawMode){
if(vertexData.size()==0) return;
pushMatrix();
cairo_matrix_init_identity(getCairoMatrix());
cairo_new_path(cr);
//if(indices.getNumIndices()){
int i = 1;
ofVec3f v = transform(vertexData[0]);
ofVec3f v2;
cairo_move_to(cr,v.x,v.y);
if(drawMode==OF_PRIMITIVE_TRIANGLE_STRIP){
v = transform(vertexData[1]);
cairo_line_to(cr,v.x,v.y);
v = transform(vertexData[2]);
cairo_line_to(cr,v.x,v.y);
i=2;
}
for(; i<(int)vertexData.size(); i++){
v = transform(vertexData[i]);
switch(drawMode){
case(OF_PRIMITIVE_TRIANGLES):
if((i+1)%3==0){
cairo_line_to(cr,v.x,v.y);
v2 = transform(vertexData[i-2]);
cairo_line_to(cr,v2.x,v2.y);
cairo_move_to(cr,v.x,v.y);
}else if((i+3)%3==0){
cairo_move_to(cr,v.x,v.y);
}else{
cairo_line_to(cr,v.x,v.y);
}
break;
case(OF_PRIMITIVE_TRIANGLE_STRIP):
v2 = transform(vertexData[i-2]);
cairo_line_to(cr,v.x,v.y);
cairo_line_to(cr,v2.x,v2.y);
cairo_move_to(cr,v.x,v.y);
break;
case(OF_PRIMITIVE_TRIANGLE_FAN):
/*triangles.addIndex((GLuint)0);
triangles.addIndex((GLuint)1);
triangles.addIndex((GLuint)2);
for(int i = 2; i < primitive.getNumVertices()-1;i++){
triangles.addIndex((GLuint)0);
triangles.addIndex((GLuint)i);
triangles.addIndex((GLuint)i+1);
}*/
break;
default:break;
}
}
cairo_move_to(cr,vertexData[vertexData.size()-1].x,vertexData[vertexData.size()-1].y);
cairo_stroke( cr );
popMatrix();
}
void Graphics::drawQuad(float x, float y, float w, float h) {
glUniform1i(texUniform, 0);
pushMatrix();
loadIdentity();
translate(x, y, 0);
popMatrix();
}
void SpinArm::display() {
strokeWeight(1);
stroke(0);
pushMatrix();
translate(x, y);
angle += speed;
rotate(angle);
line(0, 0, 165, 0);
popMatrix();
}
void Camera::computeDepthRanges(const osg::Node *graph, std::vector<std::pair<double, double> > &ranges)
{
if (!graph || dynamic_cast<const osg::Camera*>(graph))
return;
bool bPopMatrix = false;
const PositionAttitudeTransform *ptrans = dynamic_cast<const PositionAttitudeTransform*>(graph);
if (ptrans)
{
const osg::Matrixd mat = Matrixd::translate(-ptrans->getPivotPoint())
* Matrixd::rotate(ptrans->getAttitude())
* Matrixd::scale(ptrans->getScale())
* Matrixd::translate(ptrans->getPosition());
pushMatrix(mat);
bPopMatrix = true;
}
const MatrixTransform *mtrans = dynamic_cast<const MatrixTransform*>(graph);
if (mtrans)
{
pushMatrix(mtrans->getMatrix());
bPopMatrix = true;
}
const Switch* sgroup = dynamic_cast<const Switch*>(graph);
if (sgroup)
{
for(unsigned int i = 0, nb = sgroup->getNumChildren() ; i < nb ; ++i)
if (sgroup->getValue(i))
computeDepthRanges(sgroup->getChild(i), ranges);
}
else
{
const Group* group = dynamic_cast<const Group*>(graph);
if (group)
{
for(unsigned int i = 0, nb = group->getNumChildren() ; i < nb ; ++i)
computeDepthRanges(group->getChild(i), ranges);
}
}
const Geode *geode = dynamic_cast<const Geode*>(graph);
if (geode)
{
const osg::BoundingSphered &bound = computeBoundsOf(graph);
const double r = bound.radius();
const Vec3d view_center = bound.center() * qMatrix.back();
const double zmin = -view_center.z() - r;
const double zmax = -view_center.z() + r;
ranges.push_back(std::make_pair(zmin, zmax));
}
if (bPopMatrix)
popMatrix();
}
void Particles::render(GLint texture, struct MyMesh mesh, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId, VSShaderLib shader, float angle)
{
float particle_color[4];
// draw fireworks particles
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture);
glDisable(GL_DEPTH_TEST); /* não interessa o z-buffer: as partículas podem ser desenhadas umas por cima das outras sem problemas de ordenação */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
for (int i = 0; i < MAX_PARTICULAS; i++)
{
if (particula[i].life > 0.0f) /* só desenha as que ainda estão vivas */
{
/* A vida da partícula representa o canal alpha da cor. Como o blend está activo a cor final é a soma da cor rgb do fragmento multiplicada pelo
alpha com a cor do pixel destino */
particle_color[0] = particula[i].r;
particle_color[1] = particula[i].g;
particle_color[2] = particula[i].b;
particle_color[3] = particula[i].life;
// send the material - diffuse color modulated with texture
GLint loc = glGetUniformLocation(shader.getProgramIndex(), "mat.diffuse");
glUniform4fv(loc, 1, particle_color);
pushMatrix(MODEL);
translate(MODEL, particula[i].x, particula[i].y, particula[i].z);
rotate(MODEL, angle, 0, 1, 0);
scale(MODEL, 0.3, 0.3, 0.3);
//rotate(MODEL, 180, 0, 0, 1);
// send matrices to OGL
computeDerivedMatrix(PROJ_VIEW_MODEL);
glUniformMatrix4fv(vm_uniformId, 1, GL_FALSE, mCompMatrix[VIEW_MODEL]);
glUniformMatrix4fv(pvm_uniformId, 1, GL_FALSE, mCompMatrix[PROJ_VIEW_MODEL]);
computeNormalMatrix3x3();
glUniformMatrix3fv(normal_uniformId, 1, GL_FALSE, mNormal3x3);
glBindVertexArray(mesh.vao);
glDrawElements(mesh.type, mesh.numIndexes, GL_UNSIGNED_INT, 0);
popMatrix(MODEL);
}
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
glEnable(GL_DEPTH_TEST);
}
void Fonts::renderStrokeString(float x, float y, float z, void *font,char *string){
char *c;
pushMatrix(MODEL);
translate(MODEL, x, y, z);
for (c=string; *c != '\0'; c++) {
glutStrokeCharacter(font, *c);
}
popMatrix(MODEL);
}
void Wall::drawCube(COLOR cubeCell){
COLOR cubeColor = wallColors[cubeCell.X][cubeCell.Y][cubeCell.Z];
pushMatrix();
clearColor(cubeColor.R, cubeColor.G, cubeColor.B);
translate(cubeCell.X * deltaVector.X + startCorner.X,
cubeCell.Y * deltaVector.Y + startCorner.Y,
cubeCell.Z * deltaVector.Z + startCorner.Z);
scale(deltaVector.X, deltaVector.Y, deltaVector.Z);
cube(1);
popMatrix();
}
void Table::draw(VSShaderLib shader, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId)
{
loadMesh(_meshes.at(0), shader);
pushMatrix(MODEL);
translate(MODEL, _position.getX(), _position.getY(), _position.getZ());
scale(MODEL, 9.0f, 0.0000001f, 9.0f);
renderMesh(_meshes.at(0), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
}
void Pause::draw(VSShaderLib shader, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId)
{
GameObject::drawTextures();
loadMesh(_meshes.at(0), shader);
pushMatrix(MODEL);
translate(MODEL, _position.getX(), _position.getY(), _position.getZ());
scale(MODEL, 5.0f, 5.0f, 1.0f);
renderMesh(_meshes.at(0), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
}
void Cup::draw(VSShaderLib shader, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId)
{
pushMatrix(MODEL);
translate(MODEL, _position.getX(), _position.getY(), _position.getZ());
loadMesh(_meshes.at(0), shader);
pushMatrix(MODEL);
scale(MODEL,0.5f, 10.0f, 0.5f);
renderMesh(_meshes.at(0), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
loadMesh(_meshes.at(1), shader);
pushMatrix(MODEL);
translate(MODEL, 0.0,-0.5,0.0);
scale(MODEL, 0.5f, 0.01f, 0.5f);
renderMesh(_meshes.at(1), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
popMatrix(MODEL);
}
////
/// \brief GlFrame::render
/// Rendering function to be called at each frame
///
void GlFrame::render()
{
m_timeSinceLastFrame = timeInterval(m_currentTime, Clock::now());
m_currentTime = Clock::now();
applyCameraTransformations();
// Rendu des objets
pushMatrix();
//useShader("color");
//g_Basis->draw();
for(unsigned int i=0; i<m_systems.size(); i++){
pushMatrix();
//translate(i, 0, 0);
m_systems[i]->draw();
popMatrix();
}
popMatrix();
}
void Graphics::drawCeilingTile(const int32_t x, const int32_t y, const uint32_t modelID) {
glUniform1i(texUniform, 0);
pushMatrix();
loadIdentity();
translate(x * 16.0f, 0.0f, y * 16.0f);
if (ceilingMesh) {
ceilingMesh->draw();
}
popMatrix();
}
void VertexCollectionVisitor::apply(osg::Transform& transform)
{
osg::Matrix matrix;
if (!_matrixStack.empty()) matrix = _matrixStack.back();
transform.computeLocalToWorldMatrix(matrix,this);
pushMatrix(matrix);
traverse(transform);
popMatrix();
}
void blockColoured(float x, float y, float z){
pushMatrix();
translate(x, y, z);
translate(-0.5, -3.0, 0.0);
pushMatrix();
addRectangle(vertex(0.0, 1.5, -0.5), vertex(0.0, -1.5, -0.5), 127<<8);
translate(1.0, 0.0, 0.0);
addRectangle(vertex(0.0, -1.5, -0.5), vertex(0.0, 1.5, -0.5), 127<<8);
translate(-0.5, 0.0, -0.5);
addRectangle(vertex(0.5, 1.5, 0.0), vertex(0.5, -1.5, 0.0), 127<<8);
translate(0.0, 0.0, 1.0);
addRectangle(vertex(0.5, -1.5, 0.0), vertex(0.5, 1.5, 0.0), 127<<8);
popMatrix();
translate(0.0, 3.0, 0.0);
pushMatrix();
addRectangle(vertex(0.0, 1.5, -0.5), vertex(0.0, -1.5, -0.5), 127<<16);
translate(1.0, 0.0, 0.0);
addRectangle(vertex(0.0, -1.5, -0.5), vertex(0.0, 1.5, -0.5), 127<<16);
translate(-0.5, 0.0, -0.5);
addRectangle(vertex(0.5, 1.5, 0.0), vertex(0.5, -1.5, 0.0), 127<<16);
translate(0.0, 0.0, 1.0);
addRectangle(vertex(0.5, -1.5, 0.0), vertex(0.5, 1.5, 0.0), 127<<16);
popMatrix();
translate(0.0, 3.0, 0.0);
pushMatrix();
addRectangle(vertex(0.0, 1.5, -0.5), vertex(0.0, -1.5, -0.5), 127);
translate(1.0, 0.0, 0.0);
addRectangle(vertex(0.0, -1.5, -0.5), vertex(0.0, 1.5, -0.5), 127);
translate(-0.5, 0.0, -0.5);
addRectangle(vertex(0.5, 1.5, 0.0), vertex(0.5, -1.5, 0.0), 127);
translate(0.0, 0.0, 1.0);
addRectangle(vertex(0.5, -1.5, 0.0), vertex(0.5, 1.5, 0.0), 127);
popMatrix();
translate(0.5, 1.5, 0.0);
addRectangle(vertex(-0.5, 0.0, -0.5), vertex(-0.5, 0.0, 0.5), 127);
translate(0.0, -9.0, 0.0);
addRectangle(vertex(-0.5, 0.0, 0.5), vertex(-0.5, 0.0, -0.5), 127<<8);
popMatrix();
}
void Scene::render(Renderer* renderer)
{
auto director = Director::getInstance();
Camera* defaultCamera = nullptr;
const auto& transform = getNodeToParentTransform();
for (const auto& camera : _cameras)
{
Camera::_visitingCamera = camera;
if (Camera::_visitingCamera->getCameraFlag() == CameraFlag::DEFAULT)
{
defaultCamera = Camera::_visitingCamera;
continue;
}
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
//visit the scene
visit(renderer, transform, 0);
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
//draw with default camera
if (defaultCamera)
{
Camera::_visitingCamera = defaultCamera;
director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION, Camera::_visitingCamera->getViewProjectionMatrix());
//visit the scene
visit(renderer, transform, 0);
renderer->render();
director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);
}
Camera::_visitingCamera = nullptr;
}
QENGINE_API void renderFullscreenQuad(float r, float g, float b, float a)
{
float verts[28] = { -1.0f, -1.0f, 1.0f, r, g, b, a,
1.0f, -1.0f, 1.0f, r, g, b, a,
1.0f, 1.0f, 1.0f, r, g, b, a,
-1.0f, 1.0f, 1.0f, r, g, b, a };
uint32_t indices[6] = { 0, 1, 2, 0, 2, 3 };
int isDepthEnabled = isZTestEnabled();
disableZTest();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
mat4f id;
id.loadIdentity();
pushMatrix(MATRIX_PROJECTION, id);
pushMatrix(MATRIX_VIEW, id);
g_pColoredEffect->Bind();
g_pColoredEffect->BindStateMatrix("MVP", MATRIX_MODEL | MATRIX_VIEW | MATRIX_PROJECTION);
glEnableVertexAttribArray(LOC_POSITION);
glEnableVertexAttribArray(LOC_COLOR);
glVertexAttribPointer(LOC_POSITION, 3, GL_FLOAT, GL_FALSE, 28, verts);
glVertexAttribPointer(LOC_COLOR, 4, GL_FLOAT, GL_TRUE, 28, (float*)&verts[3]);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, indices);
glDisableVertexAttribArray(LOC_POSITION);
glDisableVertexAttribArray(LOC_COLOR);
g_pColoredEffect->Unbind();
if(isDepthEnabled)
enableZTest();
glDisable(GL_BLEND);
popMatrix(MATRIX_PROJECTION);
popMatrix(MATRIX_VIEW);
}
void Broccoli::draw(VSShaderLib shader, GLint pvm_uniformId, GLint vm_uniformId, GLint normal_uniformId)
{
GameObject::drawTextures();
loadMesh(_meshes.at(0), shader);
pushMatrix(MODEL);
translate(MODEL, _position.getX(), _position.getY(), _position.getZ());
rotate(MODEL, _angle, _dir.getX(), _dir.getY(), _dir.getZ());
translate(MODEL, -0.5, 0, 0);
scale(MODEL, 1.0f, 1.0f, 0.0001f);
renderMesh(_meshes.at(0), pvm_uniformId, vm_uniformId, normal_uniformId);
popMatrix(MODEL);
}
// Draws 3 leaves around the end of a branch.. once upon a time
void terminatingLeaf(void) {
if (!drawLeaves) {
return;
} // if
if ( (rand() % 100) < 2) {
drawFruit();
} else {
pushMatrix();
rotateBy( (rand() % 90), 0, 0, 1);
rotateBy( -(rand() % 10), 0, 1, 0);
drawLeaf();
popMatrix();
} // if-else
} // terminatingLeaf
void ComputeCylinderVisitor::apply( osg::Transform & transform )
{
osg::Matrix matrix;
if( !stack.empty() )
{
matrix = stack.back();
}
transform.computeLocalToWorldMatrix( matrix, this );
pushMatrix( matrix );
traverse( transform );
popMatrix();
}
