Changeset 75 for trunk


Ignore:
Timestamp:
Jul 7, 2010, 2:11:16 AM (10 years ago)
Author:
sam
Message:

Much better resource allocation and release. Scene manager stub.

Location:
trunk/src
Files:
4 added
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/Makefile

    r74 r75  
    11
    2 SRC = test-map.cpp video.cpp tileset.cpp layer.cpp map.cpp
     2SRC = test-map.cpp video.cpp tiler.cpp tileset.cpp scene.cpp layer.cpp map.cpp
    33
    44all: test-map
  • trunk/src/layer.cpp

    r74 r75  
     1
     2#include <stdlib.h>
    13
    24#include "layer.h"
     
    2224Layer::~Layer()
    2325{
    24     delete data;
     26    free(data);
     27}
     28
     29void Layer::Draw()
     30{
     31    for (int y = 0; y < 32; y++)
     32        for (int x = 0; x < 32; x++)
     33            ;//tileset->AddTile(GetTile(x, y), x * 32, y * 32, z);
    2534}
    2635
  • trunk/src/layer.h

    r74 r75  
    1919    unsigned int GetTile(int x, int y);
    2020
     21    void Draw();
     22
    2123private:
    2224    int width, height, z;
  • trunk/src/map.cpp

    r74 r75  
    88#include "map.h"
    99#include "layer.h"
     10#include "tiler.h"
    1011
    11 Map::Map(char const *path) :
    12     layers(0),
    13     nlayers(0)
     12#define MAX_TILERS 128
     13
     14/*
     15 * Map implementation class
     16 */
     17
     18class MapData
    1419{
     20    friend class Map;
     21
     22private:
     23    int tilers[MAX_TILERS];
     24    int ntilers;
     25    Layer **layers;
     26    int nlayers;
     27};
     28
     29/*
     30 * Public Map class
     31 */
     32
     33Map::Map(char const *path)
     34{
     35    data = new MapData();
     36    data->ntilers = 0;
     37    data->layers = NULL;
     38    data->nlayers = 0;
     39
    1540    char tmp[BUFSIZ];
    16     uint32_t *data = NULL;
    17     int width = 0, height = 0, level = 0, orientation = 0;
    18     int firstgid = 0, ntiles = 0;
     41    int gids[MAX_TILERS];
     42    uint32_t *tiles = NULL;
     43    int width = 0, height = 0, level = 0, orientation = 0, ntiles = 0;
    1944
    2045    FILE *fp = fopen(path, "r");
     
    2954        char a, b;
    3055
     56        /* Read a line, then decide what to do with it. */
    3157        fgets(tmp, BUFSIZ, fp);
    3258
    33         if (data)
     59        if (tiles)
    3460        {
    3561            /* We are in the process of reading layer data. Only stop
     
    3864            while (ntiles < width * height)
    3965            {
    40                 data[ntiles++] = atoi(parser);
     66                uint32_t code = 0;
     67                int id = atoi(parser);
     68                if (id)
     69                {
     70                    for (int n = 0; n < data->ntilers; n++)
     71                    {
     72                        if (id < gids[n])
     73                            continue;
     74                        if (n == data->ntilers - 1
     75                             || id < gids[n + 1])
     76                        {
     77                            code = (data->tilers[n] << 16) | (id - 1);
     78                            break;
     79                        }
     80                    }
     81                }
     82
     83                tiles[ntiles++] = code;
    4184                while (isdigit(*parser))
    4285                    parser++;
     
    4992            if (ntiles == width * height)
    5093            {
    51                 layers[nlayers] = new Layer(width, height, level, data);
    52                 nlayers++;
    53                 data = NULL;
     94                data->layers[data->nlayers] = new Layer(width, height, level, tiles);
     95                data->nlayers++;
     96                tiles = NULL;
    5497            }
    5598        }
    5699        else if (sscanf(tmp, " <tileset firstgid=\"%i\"", &i) == 1)
    57100        {
    58             /* This is a tileset description. Remember its firstgid value. */
    59             firstgid = i;
     101            /* This is a tileset description. Remember its first gid value. */
     102            gids[data->ntilers] = i;
    60103        }
    61104        else if (sscanf(tmp, " <image source=\"%[^\"]\"", str) == 1)
    62105        {
    63106            /* This is a tileset image file. Associate it with firstgid. */
     107            data->tilers[data->ntilers] = Tiler::Register(str);
     108            data->ntilers++;
    64109        }
    65110        else if (sscanf(tmp, " <layer name=\"%c%i%c%*[^\"]\" "
     
    67112        {
    68113            /* This is a layer description. Prepare to read the data. */
    69             layers = (Layer **)realloc(layers,
    70                                        sizeof(Layer **) * (nlayers + 1));
     114            data->layers = (Layer **)realloc(data->layers,
     115                                       sizeof(Layer **) * (data->nlayers + 1));
    71116            orientation = toupper(a) == 'V' ? 1 : 0;
    72117            width = j;
    73118            height = k;
     119            tiles = (uint32_t *)malloc(width * height * sizeof(uint32_t));
    74120            ntiles = 0;
    75             data = (uint32_t *)malloc(width * height * sizeof(uint32_t));
    76121        }
    77122    }
     
    82127Map::~Map()
    83128{
    84     for (int i = 0; i < nlayers; i++)
    85         delete layers[i];
    86     free(layers);
     129    for (int i = 0; i < data->ntilers; i++)
     130        Tiler::Deregister(data->tilers[i]);
     131    for (int i = 0; i < data->nlayers; i++)
     132        delete data->layers[i];
     133    free(data->layers);
     134    delete data;
    87135}
    88136
    89 void Map::Draw(Tileset *tileset)
     137void Map::Draw()
    90138{
    91     for (int i = 0; i < nlayers; i++)
    92     {
    93         int z = layers[i]->GetZ();
    94 
    95         for (int y = 0; y < 32; y++)
    96             for (int x = 0; x < 32; x++)
    97                 tileset->AddTile(layers[i]->GetTile(x, y), x * 32, y * 32, z);
    98     }
     139    for (int i = 0; i < data->nlayers; i++)
     140        data->layers[i]->Draw();
    99141}
    100142
  • trunk/src/map.h

    r74 r75  
    1010
    1111#include "layer.h"
    12 #include "tileset.h"
     12
     13class MapData;
    1314
    1415class Map
     
    1819    ~Map();
    1920
    20     void Draw(Tileset *tileset);
     21    void Draw();
    2122
    2223private:
    23     Layer **layers;
    24     int nlayers;
     24    MapData *data;
    2525};
    2626
  • trunk/src/test-map.cpp

    r74 r75  
    77
    88#include "video.h"
    9 #include "tileset.h"
     9#include "tiler.h"
    1010#include "map.h"
    1111
     
    1313{
    1414    Video *video = new Video("Deus Hax", 640, 480);
    15     Tileset *tileset = new Tileset();
    1615    Map *map = new Map("maps/testmap-grass.tmx");
    1716
     
    2019        video->Clear();
    2120
    22         map->Draw(tileset);
     21        //map->Draw(tiler);
    2322
    2423        /* Test stuff */
     
    2827        playery = playery * (480 - 32) / 480;
    2928
    30         tileset->AddTile(50, playerx, playery, 1);
     29        //tiler->AddTile(50, playerx, playery, 1);
    3130
    32         tileset->Render();
     31        //tiler->Render();
    3332        video->Refresh(33.33333f);
    3433
     
    5049
    5150    delete map;
    52     delete tileset;
    5351    delete video;
    5452
  • trunk/src/tileset.cpp

    r74 r75  
    2020
    2121/*
    22  * Tileset implementation class
     22 * TileSet implementation class
    2323 */
    2424
    25 class TilesetData
    26 {
    27     friend class Tileset;
     25class TileSetData
     26{
     27    friend class TileSet;
    2828
    2929private:
     
    3636    }
    3737
     38    char *name;
     39    int ref;
    3840    int *tiles;
    3941    int ntiles;
     
    4446
    4547/*
    46  * Public Tileset class
     48 * Public TileSet class
    4749 */
    4850
    49 Tileset::Tileset()
    50 {
    51     data = new TilesetData();
     51TileSet::TileSet(char const *path)
     52{
     53    SDL_Surface *img = NULL;
     54
     55    data = new TileSetData();
     56    data->name = strdup(path);
     57    data->ref = 0;
    5258    data->tiles = NULL;
    5359    data->ntiles = 0;
    5460
    5561    /* One tile texture */
    56     SDL_Surface *img = IMG_Load("art/test/grasstest.png");
     62    for (char const *name = path; *name; name++)
     63        if ((img = IMG_Load(name)))
     64            break;
    5765
    5866    if (!img)
     
    6270    }
    6371
    64     glGenTextures(1, &data->texture[0]);
     72    glGenTextures(1, data->texture);
    6573    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
    6674
     
    7583}
    7684
    77 Tileset::~Tileset()
    78 {
     85TileSet::~TileSet()
     86{
     87    glDeleteTextures(1, data->texture);
     88    glDeleteBuffers(3, data->buflist);
     89
    7990    free(data->tiles);
     91    free(data->name);
    8092    delete data;
    8193}
    8294
    83 void Tileset::AddTile(int n, int x, int y, int z)
     95void TileSet::Ref()
     96{
     97    data->ref++;
     98}
     99
     100int TileSet::Unref()
     101{
     102    return --data->ref;
     103}
     104
     105char const *TileSet::GetName()
     106{
     107    return data->name;
     108}
     109
     110void TileSet::AddTile(int n, int x, int y, int z)
    84111{
    85112    if ((data->ntiles % 1024) == 0)
     
    97124}
    98125
    99 void Tileset::Render()
     126void TileSet::Render()
    100127{
    101128    /* Sort tiles */
    102     qsort(data->tiles, data->ntiles, 4 * sizeof(int), TilesetData::Compare);
     129    qsort(data->tiles, data->ntiles, 4 * sizeof(int), TileSetData::Compare);
    103130
    104131    /* Texture coord buffer */
  • trunk/src/tileset.h

    r74 r75  
    44 */
    55
    6 #if !defined __DH_TILER_H__
    7 #define __DH_TILER_H__
     6#if !defined __DH_TILESET_H__
     7#define __DH_TILESET_H__
    88
    9 class TilesetData;
     9class TileSetData;
    1010
    11 class Tileset
     11class TileSet
    1212{
    1313public:
    14     Tileset();
    15     ~Tileset();
     14    TileSet(char const *path);
     15    ~TileSet();
     16
     17    void Ref();
     18    int Unref();
     19
     20    char const *GetName();
    1621
    1722    void AddTile(int n, int x, int y, int z);
     
    2025
    2126private:
    22     TilesetData *data;
     27    TileSetData *data;
    2328};
    2429
    25 #endif // __DH_TILER_H__
     30#endif // __DH_TILESET_H__
    2631
Note: See TracChangeset for help on using the changeset viewer.