chunkter.cc

Go to the documentation of this file.

/*
Copyright (C) 2001 The Exult Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif
#include "chunkter.h"
#include "gamewin.h"
#ifdef INCL_OPENGL
#include "glshape.h"
#endif

Chunk_terrain *Chunk_terrain::render_queue = 0;
int Chunk_terrain::queue_size = 0;

/*
 *  Insert at start of render queue.  It may already be there, but it's
 *  assumed that it's already tested as not being at the start.
 */

void Chunk_terrain::insert_in_queue
  (
  )
  {
  if (render_queue_next)    // In queue already?
    {     // !!Assuming it's not at head!!
    render_queue_next->render_queue_prev = render_queue_prev;
    render_queue_prev->render_queue_next = render_queue_next;
    }
  else
    queue_size++;   // Adding, so increment count.
  if (!render_queue)    // First?
    render_queue_next = render_queue_prev = this;
  else
    {
    render_queue_next = render_queue;
    render_queue_prev = render_queue->render_queue_prev;
    render_queue_prev->render_queue_next = this;
    render_queue->render_queue_prev = this;
    }
  render_queue = this;
  }

/*
 *  Remove from render queue.
 */

void Chunk_terrain::remove_from_queue
  (
  )
  {
  if (!render_queue_next)
    return;     // Not in queue.
  queue_size--;
  if (render_queue_next == this)  // Only element?
    render_queue = 0;
  else
    {
    if (render_queue == this)
      render_queue = render_queue_next;
    render_queue_next->render_queue_prev = render_queue_prev;
    render_queue_prev->render_queue_next = render_queue_next;
    }
  render_queue_next = render_queue_prev = 0;
  }

/*
 *  Paint a flat tile into our cached buffer.
 */

inline void Chunk_terrain::paint_tile
  (
  int tilex, int tiley    // Tile within chunk.
  )
  {
  Shape_frame *shape = get_shape(tilex, tiley);
  if (shape && !shape->is_rle())    // Only do flat tiles.
    rendered_flats->copy8(shape->get_data(), 
      c_tilesize, c_tilesize, tilex*c_tilesize,
            tiley*c_tilesize);
  }

/*
 *  Create list for a given chunk.
 */

Chunk_terrain::Chunk_terrain
  (
  unsigned char *data   // Chunk data.
  ) : undo_shapes(0),
      rendered_flats(0), glflats(0), 
      num_clients(0), render_queue_next(0),
      render_queue_prev(0), modified(false)
  {
  for (int tiley = 0; tiley < c_tiles_per_chunk; tiley++)
    for (int tilex = 0; tilex < c_tiles_per_chunk; tilex++)
      {
      ShapeID id(data[0], (unsigned char) (data[1]&0x7f));
      shapes[16*tiley + tilex] = id;
      data += 2;
      }
  }

/*
 *  Copy another.  The 'modified' flag is set to true.
 */

Chunk_terrain::Chunk_terrain
  (
  const Chunk_terrain& c2
  ) : undo_shapes(0),
      rendered_flats(0), glflats(0),
      num_clients(0), render_queue_next(0),
      render_queue_prev(0), modified(true)
  {
  for (int tiley = 0; tiley < c_tiles_per_chunk; tiley++)
    for (int tilex = 0; tilex < c_tiles_per_chunk; tilex++)
      shapes[16*tiley + tilex] = c2.shapes[16*tiley + tilex];
  }

/*
 *  Clean up.
 */

Chunk_terrain::~Chunk_terrain
  (
  )
  {
  delete [] undo_shapes;
  delete rendered_flats;
#ifdef HAVE_OPENGL
  delete glflats;
#endif
  remove_from_queue();
  }


/*
 *  Set tile's shape.
 *  NOTE:  Set's 'modified' flag.
 */

void Chunk_terrain::set_flat
  (
  int tilex, int tiley,
  ShapeID id
  )
  {
  if (!undo_shapes)   // Create backup.
    {
    undo_shapes = new ShapeID[256];
    std::memcpy((char *) undo_shapes, (char *) &shapes[0],
              sizeof(shapes));
    }
  shapes[16*tiley + tilex] = id;
  modified = true;
  }

/*
 *  Commit changes.
 *
 *  Output: True if this was edited, else false.
 */

bool Chunk_terrain::commit_edits
  (
  )
  {
  if (!undo_shapes)
    return false;
  delete [] undo_shapes;
  undo_shapes = 0;
  render_flats();     // Update with new data.
  return true;
  }

/*
 *  Undo changes.   Note:  We don't clear 'modified', since this could
 *  still have been moved to a different position.
 */

void Chunk_terrain::abort_edits
  (
  )
  {
  if (undo_shapes)
    {
    std::memcpy((char *) &shapes[0], (char *) undo_shapes,
              sizeof(shapes));
    delete [] undo_shapes;
    undo_shapes = 0;
    }
  }

/*
 *  Figure max. queue size for given game window.
 */
static int Figure_queue_size
  (
  )
  {
  Game_window *gwin = Game_window::get_instance();
  int w = gwin->get_width(), h = gwin->get_height();
          // Figure # chunks, rounding up.
  int cw = (w + c_chunksize - 1)/c_chunksize,
      ch = (h + c_chunksize - 1)/c_chunksize;
          // Add extra in each dir.
  return 6;//(cw + 3)*(ch + 3);
  }

/*
 *  Create rendered_flats buffer.
 */

Image_buffer8 *Chunk_terrain::render_flats
  (
  )
  {
  if (!rendered_flats)
    {
    if (queue_size > Figure_queue_size())
      {   // Grown too big.  Remove last.
      Chunk_terrain *last = render_queue->render_queue_prev;
      last->free_rendered_flats();
      render_queue->render_queue_prev = 
            last->render_queue_prev;
      last->render_queue_prev->render_queue_next = 
            render_queue;
      last->render_queue_next = last->render_queue_prev = 0;
      queue_size--;
      }
    rendered_flats = new Image_buffer8(c_chunksize, c_chunksize);
    }
          // Go through array of tiles.
  for (int tiley = 0; tiley < c_tiles_per_chunk; tiley++)
    for (int tilex = 0; tilex < c_tiles_per_chunk; tilex++)
      paint_tile(tilex, tiley);
#ifdef HAVE_OPENGL
  delete glflats;
  glflats = 0;
  GL_manager *glman = GL_manager::get_instance();
  if (glman)      // Using OpenGL?
    glflats = glman->create(rendered_flats);
#endif
  return rendered_flats;
  }

/*
 *  Free pre-rendered landscape.
 */

void Chunk_terrain::free_rendered_flats
  (
  )
  {
  delete rendered_flats; 
  rendered_flats = 0; 
#ifdef HAVE_OPENGL
  delete glflats;
  glflats = 0;
#endif
  }

/*
 *  This method is only used in 'terrain-editor' mode, NOT in normal
 *  gameplay.
 */

void Chunk_terrain::render_all
  (
  int cx, int cy      // Chunk rendering too.
  )
  {
  Image_window8 *iwin = gwin->get_win();
  int ctx = cx*c_tiles_per_chunk, cty = cy*c_tiles_per_chunk;
  int scrolltx = gwin->get_scrolltx(), scrollty = gwin->get_scrollty();
          // Go through array of tiles.
  for (int tiley = 0; tiley < c_tiles_per_chunk; tiley++)
    for (int tilex = 0; tilex < c_tiles_per_chunk; tilex++)
      {
      Shape_frame *shape = get_shape(tilex, tiley);
      if (!shape)
        continue;
      if (!shape->is_rle())
        iwin->copy8(shape->get_data(), c_tilesize, 
          c_tilesize, 
          (ctx + tilex - scrolltx)*c_tilesize,
          (cty + tiley - scrollty)*c_tilesize);
      else    // RLE.
        {
        int x, y;
        Tile_coord tile(ctx + tilex, cty + tiley, 0);
        gwin->get_shape_location(tile, x, y);
        sman->paint_shape(x, y, shape);
        }
      }
  }

/*
 *  Write out to a chunk.
 */
  
void Chunk_terrain::write_flats
  (
  unsigned char *chunk_data
  )
  {
  for (int ty = 0; ty < c_tiles_per_chunk; ty++)
    for (int tx = 0; tx < c_tiles_per_chunk; tx++)
      {
      ShapeID id = get_flat(tx, ty);
      int shapenum = id.get_shapenum(), 
          framenum = id.get_framenum();
      *chunk_data++ = shapenum&0xff;
      *chunk_data++ = ((shapenum>>8)&3) | (framenum<<2);
      }
  }

---