//-----------------------------------------------------------------------------update modelview
void Camera::updateModelView(){
float mv[16];
getModelView(mv);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(mv);
}
/**
* drawLives
* Zeichnen der verlorenen Leben.
*/
void
GameWorld::drawLives() {
int deaths = 3-gameState->getLives();
if(deaths <= 3 && deaths > 0) {
CMatrix * modelview = getModelView();
modelview->Push();
modelview->Rotate(-PI/2,1,0,0);
modelview->Translate(-2.0,4.2,0.0);
for(int i=0; i < deaths; i++) {
ModelContainer::getContainer()->drawModel(modelX);
modelview->Translate(0.15,0.0,0.0);
}
modelview->Pop();
/*
glPushMatrix();
glTranslatef(-1.0,2.2,0.0);
glRotatef(-90,1,0,0);
for(int i=0; i < deaths; i++) {
ModelContainer::getContainer()->drawModel(modelX);
glTranslatef(0.15,0.0,0.0);
}
glPopMatrix();
*/
}
}
/**
* drawCombo
* Zeichnen der Anzeige der vom Spieler erzielten Combo.
*/
void GameWorld::drawCombo() {
if (this->gameMode->hasCombo() > 0) {
CMatrix * modelview = getModelView();
for (int i = 0; i < this->gameMode->hasCombo(); ++i) {
modelview->Push();
modelview->Rotate(-PI/2,1,0,0);
modelview->Translate(1.6-0.1*i,4.32,0.0);
ModelContainer::getContainer()->drawModel(modelChili);
modelview->Pop();
/*
glPushMatrix();
glTranslatef(0.6-0.1*i,2.32,0.0);
glRotatef(-90,1,0,0);
ModelContainer::getContainer()->drawModel(modelChili);
glPopMatrix();
*/
}
}
}
void Renderer::visitRenderQueue(const RenderQueue& queue)
{
ssize_t size = queue.size();
for (ssize_t index = 0; index < size; ++index)
{
auto command = queue[index];
auto commandType = command->getType();
if(RenderCommand::Type::QUAD_COMMAND == commandType)
{
auto cmd = static_cast<QuadCommand*>(command);
//Batch quads
if(_numQuads + cmd->getQuadCount() > VBO_SIZE)
{
CCASSERT(cmd->getQuadCount()>= 0 && cmd->getQuadCount() < VBO_SIZE, "VBO is not big enough for quad data, please break the quad data down or use customized render command");
//Draw batched quads if VBO is full
drawBatchedQuads();
}
_batchedQuadCommands.push_back(cmd);
memcpy(_quads + _numQuads, cmd->getQuads(), sizeof(V3F_C4B_T2F_Quad) * cmd->getQuadCount());
convertToWorldCoordinates(_quads + _numQuads, cmd->getQuadCount(), cmd->getModelView());
_numQuads += cmd->getQuadCount();
}
else if(RenderCommand::Type::GROUP_COMMAND == commandType)
{
flush();
int renderQueueID = ((GroupCommand*) command)->getRenderQueueID();
visitRenderQueue(_renderGroups[renderQueueID]);
}
else if(RenderCommand::Type::CUSTOM_COMMAND == commandType)
{
flush();
auto cmd = static_cast<CustomCommand*>(command);
cmd->execute();
}
else if(RenderCommand::Type::BATCH_COMMAND == commandType)
{
flush();
auto cmd = static_cast<BatchCommand*>(command);
cmd->execute();
}
else
{
CCLOGERROR("Unknown commands in renderQueue");
}
}
}
/**
* drawPoints
* Zeichnen der bis zu dem Zeitpunkt erreichten Punktzahl.
*/
void
GameWorld::drawPoints() {
CMatrix * modelview = getModelView();
modelview->Push();
modelview->Translate(1.8,4.2,0.0);
drawNumber(getGameState()->getPoints());
modelview->Pop();
/*glPushMatrix();
glTranslatef(0.8,2.2,0.0);
drawNumber(getGameState()->getPoints());
glPopMatrix();*/
}
void
World::drawSword() {
btTransform trans;
CMatrix * modelviewmatrix = getModelView();
this->sword->getMotionState()->getWorldTransform(trans);
btVector3 pos = trans.getOrigin();
btQuaternion ori = trans.getRotation();
modelviewmatrix->Push();
modelviewmatrix->Rotate(ori.getAngle() ,ori.getAxis().getX(),ori.getAxis().getY(),ori.getAxis().getZ());
modelviewmatrix->Translate(pos.getX(),pos.getY(),pos.getZ());
ModelContainer::getContainer()->drawModel(modelSword);
modelviewmatrix->Pop();
}
/**
* drawEndPoints
* Zeichnen der erreichten Endpunktzahl.
*/
void
GameWorld::drawEndPoints() {
CMatrix * modelview = getModelView();
modelview->Push();
modelview->Translate(-0.1,2.0,0.0);
modelview->Scale(1.5,1.5,1.5);
drawNumber(getGameState()->getPoints());
modelview->Pop();
/*
glPushMatrix();
glTranslatef(-0.1,1.3,0.0);
glScalef(1.5,1.5,1.5);
drawNumber(getGameState()->getPoints());
glPopMatrix();
*/
}
/**
* drawTime
* Zeichnen der Zeit.
*/
void
GameWorld::drawTime() {
int time = getGameState()->getTime();
if(time >= 0) {
CMatrix * modelview = getModelView();
modelview->Push();
modelview->Translate(-2.0,4.2,0.0);
drawNumber(time);
modelview->Pop();
/*
glPushMatrix();
glTranslatef(-1.0,2.2,0.0);
drawNumber(time);
glPopMatrix();
*/
}
}
/**
* drawNumber
* Zeichnen der übergebenen Zahl. Aufgeteilt in 1er, 10er, 100er Anteil.
* @param num Zahl
*/
void
World::drawNumber(int num) {
CMatrix * modelviewmatrix = getModelView();
int hundred = num/100;
int ten = (num-(hundred*100))/10;
int one = num-(ten*10)-(hundred*100);
if(hundred > 9) {
hundred = 9;
ten = 9;
one = 9;
}
prepareDraw();
modelviewmatrix->Push();
modelviewmatrix->Rotate(DEG2RAD*-90,1,0,0);
modelviewmatrix->Translate(0.3,0.0,0.0);
drawNumberModel(one);
modelviewmatrix->Translate(-0.15,0.0,0.0);
drawNumberModel(ten);
modelviewmatrix->Translate(-0.15,0.0,0.0);
drawNumberModel(hundred);
modelviewmatrix->Pop();
}
/*
* draw
* zeichnet model an bestimmter Position mit bestimmter Orientierung
*/
void GameObjectBomb::draw() {
btVector3 trans = getPosition();
btQuaternion ori = getOrientation();
SQuaternion4d m_ori;
CMatrix * modelviewmatrix = getModelView();
m_ori.x = ori.getAxis().getX();
m_ori.y = ori.getAxis().getY();
m_ori.z = ori.getAxis().getZ();
m_ori.w = ori.getAngle();
modelviewmatrix->Push();
if (status == statusExplosion) {
modelviewmatrix->Scale(1.0+animationStep/10.0, 1.0+animationStep/10.0, 1.0+animationStep/10.0);
}
modelviewmatrix->Rotate(ori.getAngle() ,ori.getAxis().getX(),ori.getAxis().getY(),ori.getAxis().getZ());
modelviewmatrix->Translate(trans.getX(),trans.getY(),trans.getZ());
drawModel();
modelviewmatrix->Pop();
}
void initModelView() {
CMatrix * cmModelviewMatrix = getModelView();
cmModelviewMatrix->LoadIdentity();
}
void Renderer::render()
{
//Uncomment this once everything is rendered by new renderer
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//TODO setup camera or MVP
if (_glViewAssigned)
{
// cleanup
_drawnBatches = _drawnVertices = 0;
//Process render commands
//1. Sort render commands based on ID
for (auto &renderqueue : _renderGroups)
{
renderqueue.sort();
}
while(!_renderStack.empty())
{
RenderQueue currRenderQueue = _renderGroups[_renderStack.top().renderQueueID];
size_t len = currRenderQueue.size();
//Process RenderQueue
for(size_t i = _renderStack.top().currentIndex; i < len; i++)
{
_renderStack.top().currentIndex = i;
auto command = currRenderQueue[i];
auto commandType = command->getType();
if(commandType == RenderCommand::Type::QUAD_COMMAND)
{
auto cmd = static_cast<QuadCommand*>(command);
CCASSERT(nullptr!= cmd, "Illegal command for RenderCommand Taged as QUAD_COMMAND");
//Batch quads
if(_numQuads + cmd->getQuadCount() > VBO_SIZE)
{
CCASSERT(cmd->getQuadCount()>= 0 && cmd->getQuadCount() < VBO_SIZE, "VBO is not big enough for quad data, please break the quad data down or use customized render command");
//Draw batched quads if VBO is full
drawBatchedQuads();
}
_batchedQuadCommands.push_back(cmd);
memcpy(_quads + _numQuads, cmd->getQuads(), sizeof(V3F_C4B_T2F_Quad) * cmd->getQuadCount());
convertToWorldCoordinates(_quads + _numQuads, cmd->getQuadCount(), cmd->getModelView());
_numQuads += cmd->getQuadCount();
}
else if(commandType == RenderCommand::Type::CUSTOM_COMMAND)
{
flush();
auto cmd = static_cast<CustomCommand*>(command);
cmd->execute();
}
else if(commandType == RenderCommand::Type::BATCH_COMMAND)
{
flush();
auto cmd = static_cast<BatchCommand*>(command);
cmd->execute();
}
else if(commandType == RenderCommand::Type::GROUP_COMMAND)
{
flush();
auto cmd = static_cast<GroupCommand*>(command);
_renderStack.top().currentIndex = i + 1;
//push new renderQueue to renderStack
RenderStackElement element = {cmd->getRenderQueueID(), 0};
_renderStack.push(element);
//Exit current loop
break;
}
else
{
CCASSERT(true, "Invalid command");
flush();
}
}
//Draw the batched quads
drawBatchedQuads();
currRenderQueue = _renderGroups[_renderStack.top().renderQueueID];
len = currRenderQueue.size();
//If pop the render stack if we already processed all the commands
if(_renderStack.top().currentIndex + 1 >= len)
{
_renderStack.pop();
}
}
}
for (size_t j = 0 ; j < _renderGroups.size(); j++)
{
//commands are owned by nodes
// for (const auto &cmd : _renderGroups[j])
// {
// cmd->releaseToCommandPool();
// }
_renderGroups[j].clear();
}
//Clear the stack incase gl view hasn't been initialized yet
while(!_renderStack.empty())
{
_renderStack.pop();
}
RenderStackElement element = {DEFAULT_RENDER_QUEUE, 0};
_renderStack.push(element);
_lastMaterialID = 0;
}
