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 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 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 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);
}
//FIXME: unused
void Camera::setPosition(const glm::vec2 vec)
{
glm::vec2 halfScreen((Settings::instance()->screenResolutionWidth) / PIXELS_PER_METER / 2.0f, (Settings::instance()->screenResolutionHeight / PIXELS_PER_METER) / 2.0f);
m_viewMatrix = glm::translate(m_viewMatrix, glm::vec3(halfScreen, 0.0));
m_viewMatrix = glm::scale(m_viewMatrix, glm::vec3(m_scaleFactor));
m_viewMatrix = glm::translate(glm::mat4(), -glm::vec3(vec, 0.0f));
pushMatrix();
}
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 ofMatrixStack::pushView(){
viewportHistory.push(currentViewport);
ofMatrixMode currentMode = currentMatrixMode;
matrixMode(OF_MATRIX_PROJECTION);
pushMatrix();
matrixMode(OF_MATRIX_MODELVIEW);
pushMatrix();
matrixMode(currentMode);
viewMatrixStack.push(viewMatrix);
orientationStack.push(make_pair(orientation,vFlipped));
}
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 GpuHelper::pushProjectionMode2D(ProjectionMode2D pm)
{
// switch to 2D projection
pushMatrix(Matrix4f::Identity(),GL_PROJECTION);
if(pm==PM_Normalized)
{
//glOrtho(-1., 1., -1., 1., 0., 1.);
}
else if(pm==PM_Viewport)
{
GLint vp[4];
glGetIntegerv(GL_VIEWPORT, vp);
glOrtho(0., vp[2], 0., vp[3], -1., 1.);
}
pushMatrix(Matrix4f::Identity(),GL_MODELVIEW);
}
void SpinArm::display() {
strokeWeight(1);
stroke(0);
pushMatrix();
translate(x, y);
angle += speed;
rotate(angle);
line(0, 0, 165, 0);
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);
}
////
/// \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 CRender::orthoSet(float xres, float yres) {
float xhalf, yhalf;
setProjectionMatrix();
pushMatrix();
xhalf = (xres==-1) ? (this->m_Width)*0.5 : xres*0.5;
yhalf = (yres==-1) ? (this->m_Height)*0.5 : yres*0.5;
glViewport(0, 0, m_Width, m_Height);
glOrtho(-xhalf, xhalf, -yhalf, yhalf, m_OrthoNear, m_OrthoFar);
setModelMatrix();
}
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);
}
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 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 VertexCollectionVisitor::apply(osg::Transform& transform)
{
osg::Matrix matrix;
if (!_matrixStack.empty()) matrix = _matrixStack.back();
transform.computeLocalToWorldMatrix(matrix,this);
pushMatrix(matrix);
traverse(transform);
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 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);
}
// 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 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);
}
void ComputeCylinderVisitor::apply( osg::Transform & transform )
{
osg::Matrix matrix;
if( !stack.empty() )
{
matrix = stack.back();
}
transform.computeLocalToWorldMatrix( matrix, this );
pushMatrix( matrix );
traverse( transform );
popMatrix();
}
/*
* Draws the plant.
*
* ADD YOUR CODE and modify the function to take an L-system depth and
* any other necessary arguments.
*/
void drawTree(int depth) {
srand(randomSeed);
glDepthMask(GL_FALSE); // disable z buffer before drawing ppm file
int w;
int h;
GLubyte *pixels = readPPMfile("mountains.ppm", &w, &h);
glDrawPixels(w, h, GL_RGB, GL_UNSIGNED_BYTE, pixels);
glDepthMask(GL_TRUE); // reenable z buffer
scaleFactor = depth;
pushMatrix();
initialize();
centerBranch(depth);
popMatrix();
} // drawPlant
void HudMessage::render(VSShaderLib &shader, GLint &pvm_uniformId, GLint &vm_uniformId, GLint &normal_uniformId, GLint &texMode_uniformId) {
GLuint loc;
for (int i = 0; i < meshLength; ++i) {
if (mesh[i].mat.texCount != 0) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh[i].texUnits[messageType]);
glUniform1i(texMode_uniformId, 2);
}
for (int j = 0; j < mesh[i].vaoElements; j++) {
// send the material
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.ambient");
glUniform4fv(loc, 1, mesh[i].mat.ambient);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.diffuse");
glUniform4fv(loc, 1, mesh[i].mat.diffuse);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.specular");
glUniform4fv(loc, 1, mesh[i].mat.specular);
loc = glGetUniformLocation(shader.getProgramIndex(), "mat.shininess");
glUniform1f(loc, mesh[i].mat.shininess);
pushMatrix(MODEL);
translate(MODEL, current_position[0], current_position[1], current_position[2]);
if (i == 0) {
scale(MODEL, 4.0f, 4.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
glBindVertexArray(mesh[i].vao);
glDrawElements(mesh[i].type, mesh[i].numIndexes, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
popMatrix(MODEL);
}
glUniform1i(texMode_uniformId, 0);
}
glBindTexture(GL_TEXTURE_2D, 0);
}
