12     TERRAIN_EMPTY, 

    15     /** Empty space, air */

    13     TERRAIN_DIRT, 

    16     TERRAIN_EMPTY   = 0x00,

    14     TERRAIN_ROCK

    17 

    18     /** Dirt, which can be destroyed/dug through */

    19     TERRAIN_DIRT    = 0x01,

    20 

    21     /** Indestructible rock */

    22     TERRAIN_ROCK    = 0x02

    38     // terrain dimensions

    42     /** The terrain data is stored as a linear array in row-major order, with width*height elements */

    39     PixelDimension map_width, map_height;

    43     TerrainPixel *terrain_buf;

    40 

    44 

    41     // We can pre-render the terrain as a pixel buffer and then just modify this

    45     /** Terrain dimensions */

    46     PixelDimension width, height;

    47     

    48     /** We pre-render the textured terrain data for display */

    44     // terrain texture

    51     // XXX: terrain texture

    57      * @param scale The "real" width and height of the terrain.

    62      * @param width terrain width

    58      * @param seed Random number generator seed used to create the

    63      * @param height terrain height

    59      * terrain.

    64      * @param seed andom number generator seed used to generate the random terrain.

    60      */

    65      */

    61     Terrain (PixelDimension map_width, PixelDimension map_height, int seed);

    66     Terrain (PixelDimension width, PixelDimension height, int seed);

    62 

    63     /**

    64      * Copy constructor.

    65      *

    66      * @param t Terrain to be copied.

    67      */

    68     Terrain (const Terrain &t);

    73     ~Terrain (void) {}

    71     ~Terrain (void);

    72 

    73 private:

    74     /* No copying */

    75     Terrain (const Terrain &copy);

    76     Terrain &operator= (const Terrain &copy);

    76     void generate_texture();

    79     /**

    77     void noisifyPixel(CL_Color& col, PixelCoordinate pc);

    80      * Set induvidual pixel value, updates both terrain_buf and pixbuf

    78 

    81      */

    82     inline void setType (PixelDimension x, PixelDimension y, TerrainType t) {

    83         terrain_buf[y * width + x] = (TerrainPixel) t;

    84 

    85         // XXX: locking?

    86         pixbuf.draw_pixel(x, y, getTexturePixel(x, y));

    87     }

    88 

    89     /**

    90      * Generate random terrain using given seed

    91      *

    92      * @param seed seed for the random number generator

    93      */

    94     void generateTerrain (int seed);

    95 

    96     /**

    97      * Regenerates our pixbuf from the current terrain. This is a slow process, but using the pixbuffer directly

    98      * greatly speeds up drawing.

    99      */

   100     void generatePixelBuffer (void);

   101 

   102     /**

   103      * Generates an area of random texture using a fractal-based algorithm, this can then be applied to the terrain

   104      * pixels using noisifyPixel

   105      */

   106     void generateTexture();

   107     

   108     /**

   109      * Applies noise generated using generateTexture to generate a slightly varying color for the terrain pixel

   110      * at \a pc.

   111      */

   112     CL_Color getTexturePixel (PixelDimension x, PixelDimension y);

    86     PixelDimension scale (float x) const;

   120     inline PixelDimension scale (float x) const {

    87 

   121         return (int) x;

    88     /**

   122     }

    89      * Sets to color the correct color of pixel in (x,y)

    90      */

    91     void loadPixelColor (CL_Color& color, PixelCoordinate pc);

   100     PixelCoordinate getPixelCoordinate (Vector point) const;

   131     inline PixelCoordinate getPixelCoordinate (Vector point) const {

   132         return PixelCoordinate(scale(point.x), scale(point.y));

   133     }

   105     PixelCoordinate getDimensions (void) const;

   138     inline PixelCoordinate getDimensions (void) const {

   106 

   139         return PixelCoordinate(width, height);

   107     /**

   140     }

   108      * Return the type of terrain at given position. Returns ROCK if

   141 

   109      * given point is not inside terrain area.

   142     /**

   110      *

   143      * Return the type of terrain at given position. Returns TERRAIN_ROCK if given point is not inside terrain area.

   111      * @param x X coordinate

   144      *

   112      * @param y Y coordinate

   145      * @param x terrain x coordinate

   113      * @return Terrain type

   146      * @param y terrain x coordinate

   114      */

   147      * @return terrain pixel type

   115     TerrainType getType (PixelDimension px, PixelDimension py) const;

   148      */

   116     TerrainType getType (PixelCoordinate pc) const;

   149     TerrainType getType (PixelDimension x, PixelDimension y) const {

   117     TerrainType getType (Vector point) const;

   150         // XXX: optimize access by removing error checking?

   118 

   151         if (x < 0 || y < 0 || x >= width || y >= height)

   119     /**

   152             return TERRAIN_ROCK;

   120      * Check if given point has some terrain.

   153 

   121      *

   154         return (TerrainType) terrain_buf[y * width + x];

   122      * @param point Point that is in scaled units.

   155     }

   156 

   157     inline TerrainType getType (PixelCoordinate pc) const {

   158         return getType(pc.x, pc.y);

   159     }

   160     

   161     

   162     inline TerrainType getType (Vector point) const {

   163         return getType(getPixelCoordinate(point));

   164     }

   165 

   166     /**

   167      * Get raw read-only terrain data buffer

   168      *

   169      * @see terrain_buf

   170      */

   171     const TerrainPixel* getTerrainBuffer (void) const;

   172 

   173     /**

   174      * Load new terrain data from given buffer. Must be the right size

   175      *

   176      * @see terrain_buf

   177      */

   178     void loadFromBuffer (const TerrainPixel *buf);

   179 

   180     /**

   181      * Check if the given point is terrain

   125     /**

   184 

   126      * Check if given line collides with terrain.

   185     /**

   127      *

   186      * Check if the given line collides with terrain

   128      * @param begin Line begin point in scaled units.

   187      *

   129      * @param end Line end point in scaled units.

   188      * @param begin line starting point

   189      * @param end line ending point

   134      * Remove a circular area from terrain.

   194      * Remove a circular area of terrain

   135      *

   195      *

   136      * @param pos Circle center

   196      * @param pos circle center

   137      * @param r Circle radius

   197      * @param r circle radius

   142      * Return normal for the given point.

   202      * Returns direction normal vector for the given \a point. 

   143      *

   203      *

   144      * @param point Point for which the normal is calculated.

   204      * \a point should be ground, and \a prevPoint air.

   145      * @return Normal vector ((0,0) if there's no terrain)

   205      *

   206      * @param point the ground that we collided into

   207      * @param prevPoint position in air where we were before the collision

   208      * @return direction ormal vector, or (0,0) if there's no terrain

   150      * Generate random terrain.

   213      * Draw the terrain onto the given graphics context

   151      *

   214      *

   152      * @param seed Seed for the randomnumber generator.

   215      * @param gc Graphics to draw on

   153      */

   216      * @param camera view position

   154     void generateTerrain (int seed);

   155 

   156     /**

   157      * Draw the terrain for given graphicscontext.

   158      *

   159      * @param gc CL_GraphicContext

   160      * @param camera - upper left corner of screen