11

/**

    12

 * Different types of terrain available

    13

 */

    15

    /** Empty space, air */

    16

    TERRAIN_EMPTY   = 0x00,

    17

    18

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

    19

    TERRAIN_DIRT    = 0x01,

    20

    21

    /** Indestructible rock */

    22

    TERRAIN_ROCK    = 0x02

    26

 * Terrain "pixel" type

    27

 */

    28

typedef uint8_t TerrainPixel;

    29

    30

/**

    41

protected:

    42

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

    43

    TerrainPixel *terrain_buf;

    44

    45

    /** Terrain dimensions */

    46

    PixelDimension width, height;

    48

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

    51

    // XXX: terrain texture

    62

     * @param width terrain width

    63

     * @param height terrain height

    64

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

    66

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

    71

    ~Terrain (void);

    72

    73

private:

    74

    /* No copying */

    75

    Terrain (const Terrain &copy);

    76

    Terrain &operator= (const Terrain &copy);

    79

    /**

    80

     * Set induvidual pixel value, updates both terrain_buf and pixbuf

    81

     */

    82

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

    83

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

    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);

   120

    inline PixelDimension scale (float x) const {

   121

        return (int) x;

   122

    }

   131

    inline PixelCoordinate getPixelCoordinate (Vector point) const {

   132

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

   133

    }

   138

    inline PixelCoordinate getDimensions (void) const {

   139

        return PixelCoordinate(width, height);

   140

    }

   143

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

   145

     * @param x terrain x coordinate

   146

     * @param y terrain x coordinate

   147

     * @return terrain pixel type

   149

    TerrainType getType (PixelDimension x, PixelDimension y) const {

   150

        // XXX: optimize access by removing error checking?

   151

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

   152

            return TERRAIN_ROCK;

   153

   154

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

   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

    }

   167

     * Get raw read-only terrain data buffer

   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

   184

   186

     * Check if the given line collides with terrain

   188

     * @param begin line starting point

   189

     * @param end line ending point

   194

     * Remove a circular area of terrain

   196

     * @param pos circle center

   197

     * @param r circle radius

   202

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

   204

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

   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

   213

     * Draw the terrain onto the given graphics context

   215

     * @param gc Graphics to draw on

   216

     * @param camera view position