blockgroup.cc

#include "stage.hh"
#include "worldfile.hh"

#include <libgen.h> // for dirname(3)
#include <limits.h> // for _POSIX_PATH_MAX

#undef DEBUG

using namespace Stg;
using namespace std;

BlockGroup::BlockGroup() 
  : displaylist(0),
    blocks(), 
    minx(0),
    maxx(0),
    miny(0),
    maxy(0)
{ /* empty */ }

BlockGroup::~BlockGroup()
{	 
  Clear();
}

void BlockGroup::AppendBlock( Block* block )
{
  blocks.push_back( block );
}

void BlockGroup::Clear()
{
  FOR_EACH( it, blocks )
    delete *it;
  
  blocks.clear();
}

void BlockGroup::AppendTouchingModels( std::set<Model*>& v )
{
  FOR_EACH( it, blocks )
    (*it)->AppendTouchingModels( v );  
}

Model* BlockGroup::TestCollision()
{
  Model* hitmod = NULL;
   
  FOR_EACH( it, blocks )
    if( (hitmod = (*it)->TestCollision()))
      break; // bail on the earliest collision

  return hitmod; // NULL if no collision
}


// establish the min and max of all the blocks, so we can scale this
// group later
void BlockGroup::CalcSize()
{  
  // assuming the blocks currently fit in a square +/- one billion units
  //double minx, miny, maxx, maxy, minz, maxz;
  minx = miny =  billion;
  maxx = maxy = -billion;
  
  size.z = 0.0; // grow to largest z we see
  
  FOR_EACH( it, blocks )
    {
      // examine all the points in the polygon
      Block* block = *it;
      
      FOR_EACH( it, block->pts )
	{
	  if( it->x < minx ) minx = it->x;
	  if( it->y < miny ) miny = it->y;
	  if( it->x > maxx ) maxx = it->x;
	  if( it->y > maxy ) maxy = it->y;
	}
      
      size.z = std::max( block->local_z.max, size.z );
    }
  
  // store these bounds for normalization purposes
  size.x = maxx-minx;
  size.y = maxy-miny;
  
  offset.x = minx + size.x/2.0;
  offset.y = miny + size.y/2.0;
  offset.z = 0; // todo?

  InvalidateModelPointCache();
}


void BlockGroup::Map( unsigned int layer )
{
  FOR_EACH( it, blocks )
    (*it)->Map(layer);
}

// defined in world.cc
//void SwitchSuperRegionLock( SuperRegion* current, SuperRegion* next );

void BlockGroup::UnMap( unsigned int layer )
{
  FOR_EACH( it, blocks )
    (*it)->UnMap(layer);
}

void BlockGroup::DrawSolid( const Geom & geom )
{
  glPushMatrix();
  
  Gl::pose_shift( geom.pose );
  
  glScalef( geom.size.x / size.x,
	    geom.size.y / size.y,				
	    geom.size.z / size.z );
  
  glTranslatef( -offset.x, -offset.y, -offset.z );
  
  FOR_EACH( it, blocks )
    (*it)->DrawSolid(false);
  
  glPopMatrix();
}

void BlockGroup::DrawFootPrint( const Geom & geom )
{
  glPushMatrix();
  
  glScalef( geom.size.x / size.x,
	    geom.size.y / size.y,				
	    geom.size.z / size.z );
  
  glTranslatef( -offset.x, -offset.y, -offset.z );
  
  FOR_EACH( it, blocks )
    (*it)->DrawFootPrint();
  
  glPopMatrix();
}

void BlockGroup::BuildDisplayList( Model* mod )
{
  //puts( "build" );
  
  if( ! mod->world->IsGUI() )
    return;
  
  //printf( "display list for model %s\n", mod->token );
  if( displaylist == 0 )
    {
      displaylist = glGenLists(1);
      CalcSize();
    }
  
  
  glNewList( displaylist, GL_COMPILE );	
  
  
  // render each block as a polygon extruded into Z
  
  Geom geom = mod->GetGeom();
  
  Gl::pose_shift( geom.pose );
  
  glScalef( geom.size.x / size.x,
	    geom.size.y / size.y,				
	    geom.size.z / size.z );
  
  glTranslatef( -offset.x, -offset.y, -offset.z );
  
  glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
  glEnable(GL_POLYGON_OFFSET_FILL);
  glPolygonOffset(1.0, 1.0);
  
  mod->PushColor( mod->color );
  
  //const bool topview =  dynamic_cast<WorldGui*>(mod->world)->IsTopView();
  
  FOR_EACH( it, blocks )
    {
      Block* blk = (*it);
      
      if( (!blk->inherit_color) && (blk->color != mod->color) )
	{
	  mod->PushColor( blk->color );					 
	  blk->DrawSolid(false);			
	  mod->PopColor();
	}
      else
	blk->DrawSolid(false);
    }
  
  mod->PopColor();
  
  // outline each poly in a darker version of the same color

  glDisable(GL_POLYGON_OFFSET_FILL);
  
  glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
  glDepthMask(GL_FALSE);
  
  Color c = mod->color;
  c.r /= 2.0;
  c.g /= 2.0;
  c.b /= 2.0;
  mod->PushColor( c );
  
  FOR_EACH( it, blocks )
    {
      Block* blk = *it;
		
      if( (!blk->inherit_color) && (blk->color != mod->color) )
	{
	  Color c = blk->color;
	  c.r /= 2.0;
	  c.g /= 2.0;
	  c.b /= 2.0;
	  mod->PushColor( c );
	  blk->DrawSolid(false);
	  mod->PopColor();
	}
      else
	blk->DrawSolid(false);
    }
  
  glDepthMask(GL_TRUE);
  glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
  
  mod->PopColor();

  glEndList();
}

void BlockGroup::CallDisplayList( Model* mod )
{
  if( displaylist == 0 || mod->rebuild_displaylist )
    {
      BuildDisplayList( mod );
      mod->rebuild_displaylist = 0;
    }
  
  glCallList( displaylist );
}

void BlockGroup::LoadBlock( Model* mod, Worldfile* wf, int entity )
{
  AppendBlock( new Block( mod, wf, entity ));
  CalcSize();
}				
  
void BlockGroup::LoadBitmap( Model* mod, const std::string& bitmapfile, Worldfile* wf )
{
  PRINT_DEBUG1( "attempting to load bitmap \"%s\n", bitmapfile );
	
  std::string full;
  
  if( bitmapfile[0] == '/' )
    full = bitmapfile;
  else
    {
      char* workaround_const = strdup(wf->filename.c_str());
      full = std::string(dirname(workaround_const)) + "/" + bitmapfile;			
      free( workaround_const );
    }
  
  PRINT_DEBUG1( "attempting to load image %s", full );
  
  std::vector<rotrect_t> rects;
  if( rotrects_from_image_file( full,
				rects ) )
    {
      PRINT_ERR1( "failed to load rects from image file \"%s\"",
		  full.c_str() );
      return;
    }
  
  //printf( "found %d rects in \"%s\" at %p\n", 
  //	  rect_count, full, rects );
			 
  // TODO fix this
  Color col( 1.0, 0.0, 1.0, 1.0 );
	
  FOR_EACH( rect, rects )
    {
      std::vector<point_t> pts(4);
			
      const double x = rect->pose.x;
      const double y = rect->pose.y;
      const double w = rect->size.x;
      const double h = rect->size.y;
			
      pts[0].x = x;
      pts[0].y = y;
      pts[1].x = x + w;
      pts[1].y = y;
      pts[2].x = x + w;
      pts[2].y = y + h;
      pts[3].x = x;
      pts[3].y = y + h;							 
      
      AppendBlock( new Block( mod,
			      pts,
			      0,1,
			      col,
			      true,
			      false) );		 
    }			 
  
  CalcSize();
}


void BlockGroup::Rasterize( uint8_t* data, 
			    unsigned int width, 
			    unsigned int height,
			    meters_t cellwidth,
			    meters_t cellheight )
{  
  FOR_EACH( it, blocks )
    (*it)->Rasterize( data, width, height, cellwidth, cellheight );
}