//place columns in the scene
void drawColumnSet(){
glPushMatrix();
glTranslatef(-11, 0, 0);
glPushMatrix();
for(int i = 1; i < 6; i++){
glTranslatef(0, 1, -2);
drawColumn(28 - i);
}
glPopMatrix();
glTranslatef(22, 0, 0);
glPushMatrix();
for(int i = 1; i < 6; i++){
glTranslatef(0, 1, -2);
drawColumn(28 - i);
}
glPopMatrix();
glPopMatrix();
}
void GUIListGadget::draw()
{
if (!isVisible_ || isValidated_ || !setupClipping())
return;
GlbRenderSys->draw2DRectangle(Rect_, Color_);
/* Draw all item entries */
s32 ItemPos = 0;
for (std::list<GUIListItem*>::iterator it = ItemList_.begin(); it != ItemList_.end(); ++it)
{
drawItem(*it, ItemPos);
ItemPos += (*it)->getItemSize();
}
/* Draw all column entries */
s32 ColumnPos = 0;
for (std::list<GUIListColumn*>::iterator it = ColumnList_.begin(); it != ColumnList_.end(); ++it)
{
drawColumn(*it, ColumnPos);
ColumnPos += (*it)->getColumnSize();
}
/* Update scrollbar ranges */
HorzScroll_.setRange(ColumnPos);
VertScroll_.setRange(ItemPos + COLUMN_HEIGHT);
drawChildren();
GlbRenderSys->setClipping(true, dim::point2di(VisRect_.Left, VisRect_.Top), VisRect_.getSize());
drawFrame(Rect_, 0, false);
}
void Health::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int healthLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( _flags.count( overlay->type() ) )
{
needDrawAnimations = true;
//city::Helper helper( _city() );
//drawArea( engine, helper.getArea( overlay ), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
else if( overlay->type() == object::house )
{
HousePtr house = ptr_cast<House>( overlay );
healthLevel = _getLevelValue( house );
needDrawAnimations = (house->spec().level() == 1) && (house->habitants().empty());
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else //other buildings
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( healthLevel > 0 )
{
drawColumn( engine, screenPos, healthLevel );
}
}
tile.setWasDrawn();
}
void Unemployed::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
WorkingBuildingPtr workBuilding = overlay.as<WorkingBuilding>();
int worklessPercent = 0;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
HousePtr house = overlay.as<House>();
int worklessNumber = (int)house->getServiceValue( Service::recruter );
int matureNumber = (int)house->habitants().mature_n();
worklessPercent = math::percentage( worklessNumber, matureNumber );
needDrawAnimations = (house->spec().level() == 1) && house->habitants().empty();
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else if( workBuilding.isValid() )
{
worklessPercent = math::percentage( workBuilding->needWorkers(), workBuilding->maximumWorkers() );
needDrawAnimations = workBuilding->needWorkers() > 0;
if( !needDrawAnimations )
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( worklessPercent > 0 )
{
drawColumn( engine, screenPos, worklessPercent );
}
}
tile.setWasDrawn();
}
void Religion::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int religionLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
HousePtr house = ptr_cast<House>( overlay );
religionLevel = (int) house->getServiceValue(Service::religionMercury);
religionLevel += house->getServiceValue(Service::religionVenus);
religionLevel += house->getServiceValue(Service::religionMars);
religionLevel += house->getServiceValue(Service::religionNeptune);
religionLevel += house->getServiceValue(Service::religionCeres);
religionLevel = math::clamp( religionLevel / (house->spec().minReligionLevel()+1), 0, 100 );
needDrawAnimations = (house->spec().level() == 1) && house->habitants().empty();
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( religionLevel > 0 )
{
drawColumn( engine, screenPos, religionLevel );
}
}
tile.setWasDrawn();
}
void Tax::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int taxLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
auto house = overlay.as<House>();
int taxAccess = house->getServiceValue( Service::forum );
taxLevel = math::clamp<int>( house->taxesThisYear(), 0, 100 );
needDrawAnimations = ((house->level() <= HouseLevel::hovel && house->habitants().empty())
|| taxAccess < 25);
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( taxLevel > 0 )
{
drawColumn( engine, screenPos, taxLevel );
}
}
tile.setRendered();
}
void Fire::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int fireLevel = 0;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
HousePtr house = ptr_cast<House>( overlay );
fireLevel = (int)house->state( pr::fire );
needDrawAnimations = (house->spec().level() == 1) && house->habitants().empty();
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
else //other buildings
{
ConstructionPtr constr = ptr_cast<Construction>( overlay );
if( constr != 0 )
{
fireLevel = (int)constr->state( pr::fire );
}
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( fireLevel >= 0)
{
drawColumn( engine, screenPos, fireLevel );
}
}
tile.setWasDrawn();
}
void Sentiment::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int sentimentLevel = 0;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
HousePtr house = overlay.as<House>();
sentimentLevel = (int)house->state( pr::happiness );
needDrawAnimations = (house->spec().level() == 1) && house->habitants().empty();
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( sentimentLevel > 0 )
{
drawColumn( engine, screenPos, 100 - sentimentLevel );
}
}
tile.setWasDrawn();
}
void Entertainment::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int entertainmentLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( _flags.count( overlay->type() ) > 0 )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
auto house = overlay.as<House>();
entertainmentLevel = _getLevelValue( house );
needDrawAnimations = (house->level() <= HouseLevel::hovel) && (house->habitants().empty());
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( entertainmentLevel > 0 )
{
drawColumn( engine, screenPos, entertainmentLevel );
}
}
tile.setRendered();
}
void MarketAccess::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int accessLevel = 0;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
auto house = overlay.as<House>();
accessLevel = (int)house->getServiceValue( Service::market );
needDrawAnimations = (house->level() <= HouseLevel::hovel) && house->habitants().empty();
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( accessLevel >= 0 )
{
drawColumn( engine, screenPos, accessLevel );
}
}
tile.setRendered();
}
void FluidField::clear() {
int i;
for ( i=0 ; i<_fieldSize ; i++ ) {
u[i] = v[i] = u_prev[i] = v_prev[i] = 0.0f;
dens_prev[i] = dens[i] = 0.0f;
}
int index = 0;
_noiseOffset = -1;
for (int j=0;j<_fieldColumns-9;++j){
index = j;
drawColumn(index);
}
}
unsigned char* FluidField::getData(float dt) {
int destIndex = 0;
int i,j;
int index = _fieldColumns;
unsigned int topDensity=250*thickness;
unsigned int color=60*thickness;
if (color>20) {
color=20;
}
for ( i=1 ; i<=_gridRows ; i++ ) {
for ( j=1 ; j<=_gridColumns ; j++ ) {
float d = dens[index];
if(d > 1.0f) d = 1.0f;
unsigned int density = d*ALPHA_VALUE;
if (density<topDensity) {
density=topDensity;
}
if(i < _topBorder) density *= (_topRamp * (float)i);
if(i > _bottomBorder) density *= (_bottomRamp * (float)(_gridRows-i));
//if(j < _leftBorder) density *= (_leftRamp * (float)j);
//if(j > _rightBorder) density *= (_rightRamp * (float)(_gridColumns - j));
data[destIndex+3] = density;
data[destIndex+1] = data[destIndex+2] = data[destIndex] = 1+(1-d)*color;
destIndex+=4;
index++;
}
index+=2;
}
timeElapsed+=dt;
if (timeElapsed>=frameTime) {
timeElapsed-=frameTime;
memcpy(dens,dens+1,(_fieldSize - 1) * sizeof(float));
index = _fieldColumns-10;
drawColumn(index);
}
return data;
}
/*!
Draw a histogram in Columns style()
\param painter Painter
\param xMap Maps x-values into pixel coordinates.
\param yMap Maps y-values into pixel coordinates.
\param from Index of the first sample to be painted
\param to Index of the last sample to be painted. If to < 0 the
histogram will be painted to its last point.
\sa setStyle(), style(), setSymbol(), drawColumn()
*/
void QwtPlotHistogram::drawColumns( QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
int from, int to ) const
{
painter->setPen( d_data->pen );
painter->setBrush( d_data->brush );
for ( int i = from; i <= to; i++ )
{
const QwtIntervalSample sample = d_series->sample( i );
if ( !sample.interval.isNull() )
{
const QwtColumnRect rect = columnRect( sample, xMap, yMap );
drawColumn( painter, rect, sample );
}
}
}
void Aborigens::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int discontentLevel = 0;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::native_hut )
{
auto nativeHut = overlay.as<NativeHut>();
discontentLevel = (int)nativeHut->discontent();
needDrawAnimations = false;
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( discontentLevel >= 0 )
{
drawColumn( engine, screenPos, discontentLevel );
}
}
tile.setRendered();
}
void Crime::drawTile( const RenderInfo& rinfo, Tile& tile)
{
if( tile.overlay().isNull() )
{
drawPass( rinfo, tile, Renderer::ground );
drawPass( rinfo, tile, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int crime = -1;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
auto house = overlay.as<House>();
crime = (int)house->getServiceValue( Service::crime );
needDrawAnimations = (house->level() <= HouseLevel::hovel) && house->habitants().empty(); // In case of vacant terrain
drawArea( rinfo, overlay->area(), config::layer.ground, config::tile.house );
}
else
{
drawArea( rinfo, overlay->area(), config::layer.ground, config::tile.constr );
}
if( needDrawAnimations )
{
Layer::drawTile( rinfo, tile );
registerTileForRendering( tile );
}
else if( crime >= 0)
{
Point screenPos = tile.mappos() + rinfo.offset;
drawColumn( rinfo, screenPos, crime );
}
}
tile.setRendered();
}
/**
* @brief Waveform::display
*
* Affiche le sonogramme du morceau chargé.
*/
void Waveform::display()
{
initImage();
int beg = ((SimpleMusicPlayer*) m_parent)->getWaveBegin(); //première sample affichée
int end = ((SimpleMusicPlayer*) m_parent)->getWaveEnd();
float size = end - beg; // nb de samples affichées
int s_beg = QTimeToSample(m_beginTime);
int s_bar = QTimeToSample(m_barTime);
int s_end = QTimeToSample(m_endTime);
float tmp_begin = (((float) s_beg - (float) beg) / size);
float tmp_end = (((float) s_end - (float) beg) / size);
float tmp_bar = (((float) s_bar - (float) beg) / size);
int pos_begin = tmp_begin * m_width;
int pos_bar = tmp_bar * m_width;
int pos_end = tmp_end * m_width;
//dessin du graphe
for(unsigned int i = 0; i < m_width ; i++)
{
drawColumn(i, beg, end, s_beg, s_end, pos_begin, pos_end);
}
//dessin des barres
if(s_beg > beg && s_beg < end)
{
simpleDrawColumn(pos_begin, m_height, m_delimiterPen);
}
if(s_bar > beg && s_bar < end)
{
simpleDrawColumn(pos_bar, m_height, m_delimiterPen);
}
if(s_end > beg && s_end < end)
{
simpleDrawColumn(pos_end, m_height, m_delimiterPen);
}
}
void cScene::drawHighlightTile(int j, int k) {
drawColumn(j, k, 0, data->getTextureID(TEX_STONE));
}
void drawRedColumn(int tid)
{
drawColumn(WIDTH, LENGTH, 30, 40*tid, 0x00ff0000);
}
void cScene::drawTile(int j, int k) {
float new_y = 0;
if (map_cds[j][k] < 0) new_y = map_cds[j][k];
switch (map[j][k]) {
case 0: break; // Empty block
case 1: // Soil
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
//data->drawModel(MODEL_GRASSIE, data->getTextureID(TEX_GRASS), position + glm::vec3(TILE_SIZE*j,0.5,-k*TILE_SIZE), rotation, scale * glm::vec3(1, 0.5, 1), angle);
break;
case 2: // Wall
drawColumn(j, k, 4, data->getTextureID(TEX_COL));
//drawLittleBlock(j, k, 7, glm::vec3(0.45), data->getTextureID(TEX_SOIL));
break;
case 3: // Wall 2
drawColumn(j, k, 1, data->getTextureID(TEX_STONE3));
//drawLittleBlock(j, k, 7, glm::vec3(0.45), data->getTextureID(TEX_SOIL));
break;
case 4: // Swap soil
drawColumn(j, k, 0, data->getTextureID(TEX_STONE));
break;
case 5: // Low columns
drawColumn(j, k, 2, data->getTextureID(TEX_COL));
break;
case 6: // Wall with a window
drawColumn(j, k, 4, data->getTextureID(TEX_STONE));
drawLittleBlock(j, k, 8, glm::vec3(1), data->getTextureID(TEX_STONE));
drawLittleBlock(j, k, 9, glm::vec3(0.1), data->getTextureID(TEX_SOIL));
break;
case 7: // New grass
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
if (data->front == 1) data->drawModel(MODEL_GRASSIE, data->getTextureID(TEX_GRASS), position + glm::vec3(TILE_SIZE*j,new_y,-k*TILE_SIZE), rotation, scale, angle);
else data->drawModel(MODEL_GRASSIE, data->getTextureID(TEX_GRASS), position + glm::vec3(TILE_SIZE*j,new_y,-k*TILE_SIZE), rotation, scale, angle + PI);
break;
case 8: // High columns
data->drawModel(MODEL_COL, data->getTextureID(TEX_COL), position + glm::vec3(TILE_SIZE*j,new_y-0.5,-k*TILE_SIZE), rotation, scale, angle);
break;
case 9: // Normal tree
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
if (data->front == 1) {
data->drawModel(MODEL_TREE_BODY, data->getTextureID(TEX_TREE_BODY), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
data->drawModel(MODEL_TREE_LEAVES, data->getTextureID(TEX_TREE_LEAVES), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
} else {
data->drawModel(MODEL_TREE_BODY, data->getTextureID(TEX_TREE_BODY), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle + PI);
data->drawModel(MODEL_TREE_LEAVES, data->getTextureID(TEX_TREE_LEAVES), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle + PI);
}
break;
case 10: // Autumn tree
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
if (data->front == 1) {
data->drawModel(MODEL_AUTUMN_BODY, data->getTextureID(TEX_TREE_BODY), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
data->drawModel(MODEL_AUTUMN_LEAVES, data->getTextureID(TEX_AUTUMN_LEAVES), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
} else {
data->drawModel(MODEL_AUTUMN_BODY, data->getTextureID(TEX_TREE_BODY), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle + PI);
data->drawModel(MODEL_AUTUMN_LEAVES, data->getTextureID(TEX_AUTUMN_LEAVES), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle + PI);
}
break;
case 11: // Stone 1
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
data->drawModel(MODEL_STONE1, data->getTextureID(TEX_STONE1), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
break;
case 12: // Stone 2
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
data->drawModel(MODEL_STONE2, data->getTextureID(TEX_STONE2), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
break;
case 13: // Stone 3
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
data->drawModel(MODEL_STONE3, data->getTextureID(TEX_STONE3), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
break;
case 14: // Stone 4
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
data->drawModel(MODEL_STONE4, data->getTextureID(TEX_STONE4), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
break;
case 15: // Stone 5
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
data->drawModel(MODEL_STONE5, data->getTextureID(TEX_STONE5), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
break;
case 16: // Stop sign
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
data->drawModel(MODEL_STOP_SIGN, data->getTextureID(TEX_STOP_SIGN), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
data->drawModel(MODEL_STOP_BODY, data->getTextureID(TEX_METAL), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
break;
case 17: // Stone
drawColumn(j, k, 0, data->getTextureID(TEX_STONE));
break;
case 18: // Level win soil
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
break;
case 19: // Metal
drawColumn(j, k, 0, data->getTextureID(TEX_METAL));
break;
case 20: // Brick
drawColumn(j, k, 0, data->getTextureID(TEX_COL));
break;
case 21: // Evil stick
if (map_cds[j][k] > 0) {
if ((rot > PI/2 && rot < PI) || (rot > PI + PI/2 && rot < 2*PI)) {
drawColumn(j, k, 0, data->getTextureID(TEX_METAL));
data->drawModel(MODEL_PYR, data->getTextureID(TEX_METAL), position + glm::vec3(TILE_SIZE*j, new_y+1.5,-k*TILE_SIZE), rotation, scale, angle);
}
data->drawModel(MODEL_PYR, data->getTextureID(TEX_METAL), position + glm::vec3(TILE_SIZE*j, new_y+0.5,-k*TILE_SIZE), rotation, scale, angle);
}
break;
case 22: // Swap soil
drawColumn(j, k, 0, data->getTextureID(TEX_SOIL));
break;
case 23: // Wall
drawColumn(j, k, 3, data->getTextureID(TEX_COL));
break;
default:
break;
}
}
void drawBlueColumn(int tid)
{
drawColumn(WIDTH, LENGTH, 30, 40*tid, 0x000000ff);
}
