Thread: Could someone take a look at this

This is annoying me no end. I'm working on the tile loader modules of this little thing I'm writing - it all seems to work find except the texture isn't actually displayed. I don't know if it's something to do with my drawing code or the way the tile textures are shared via a static std::vector in a class.

It runs fine, loads the textures fine, but just displays a blank tile. If someone could look at this I'd really appreciate it.

http://www.ahluka.co.uk/strat.rar ~3 MB

Originally Posted by Perspective

Post the texture gen and render code. Are the texture dimensions a power of 2?

Yep they're 32x32.
The reason the archive is so big is because of the IntelliSense database MSVC builds. I think.

It'd be easier if I just post up the entire classes:

CTextureCache: The idea was to keep a static std::vector containing the textures for use anywhere since only ~20 textures are ever going to be used.

Code:

// CTextureCache.h
#pragma once
#include "stdafx.h"

const ILstring  textureNames[] = { "water.jpg",
                                   "grass.jpg"
                                 };

class CTextureCache {
        static std::vector<GLuint>     texture;

        const unsigned NUM_TEXTURES;
        const unsigned LIM_WIDTH;
        const unsigned LIM_HEIGHT;
        ILuint  currentTexID;
 
public:
        CTextureCache ();
        ~CTextureCache ();

        void    Init ();
        void    Load ();
        GLuint  GetByID (char id);
};

// CTextureCache.cpp
#include "StdAfx.h"
#include ".\texturecache.h"

std::vector<GLuint> CTextureCache::texture;

CTextureCache::CTextureCache () 
        :NUM_TEXTURES (2), 
        LIM_WIDTH (32), 
        LIM_HEIGHT (32)
{
}

CTextureCache::~CTextureCache ()
{
}

// Init
//
void CTextureCache::Init ()
{
        for (unsigned i = 0; i < NUM_TEXTURES; i++)
                texture.push_back (0);
}

// Load
//
void CTextureCache::Load ()
{
        unsigned        i;

        for (i = 0; i < NUM_TEXTURES; i++) {
                ilGenImages (NUM_TEXTURES, &currentTexID);
                ilBindImage (currentTexID);

                if (! ilLoadImage (textureNames[i]))
                        reportErr (true, "Unable to load texture '%s'", textureNames[i]);

                if ((ilGetInteger (IL_IMAGE_WIDTH) != LIM_WIDTH) ||
                    (ilGetInteger (IL_IMAGE_HEIGHT) != LIM_HEIGHT))
                {
                        reportErr (true, "'%s', Image dimensions out of bounds [%d, %d]",
                                   textureNames[i],
                                   ilGetInteger (IL_IMAGE_WIDTH),
                                   ilGetInteger (IL_IMAGE_HEIGHT));
                }


                ilConvertImage (IL_RGBA, IL_UNSIGNED_BYTE);
                glGenTextures (1, &texture[i]);
                glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                glTexImage2D (GL_TEXTURE_2D, 0, ilGetInteger (IL_IMAGE_BPP), ilGetInteger (IL_IMAGE_WIDTH),
                              ilGetInteger (IL_IMAGE_HEIGHT), 0, ilGetInteger (IL_IMAGE_FORMAT),
                              GL_UNSIGNED_BYTE, ilGetData ());
                ilDeleteImages (1, &currentTexID);
        }
}

// GetByID
//
GLuint CTextureCache::GetByID (char id)
{
        switch (id) {
                case 'w':
                        return texture[0];
                case 'g':
                        return texture[1];

                default:
                        reportErrBox (true, "Invalid texture ID [%c]", id);
        }

        return 0;
}

CTile:

Code:

// CTile.h
#pragma once

class CTile {
        GLuint  texture;

public:
        CTile (void);
        ~CTile (void);

        void    SetTexture (char id);
        void    Draw ();

        // Debug
        GLuint  Texture () const
        {
                return texture;
        }
};

// CTile.cpp
#include "StdAfx.h"
#include ".\tile.h"
#include "TextureCache.h"

CTile::CTile (void)
{
}

CTile::~CTile (void)
{
}

// SetTexture
//      Gets specified texture from the texture cache
void CTile::SetTexture (char id)
{
        CTextureCache*  tcache = new CTextureCache ();

        texture = tcache->GetByID (id);
        delete tcache;
}

// Draw
//
void CTile::Draw ()
{
        glBindTexture (GL_TEXTURE_2D, texture);
        glEnable (GL_TEXTURE_2D);
        glBegin (GL_QUADS);
                glTexCoord2i (1, 0);
                glVertex2i (32, 0);
                glTexCoord2i (1, 1);
                glVertex2i (32, 32);
                glTexCoord2i (0, 1);
                glVertex2i (0, 32);
                glTexCoord2i (0, 0);
                glVertex2i (0, 0);
        glEnd ();
        glDisable (GL_TEXTURE_2D);
}

I truly am a moron. I wasn't pushing the GLuint's into the vector.

Ouch. That is definatly the most annoying thing ever, when the answer to your problem is somthing simple you've overlooked. Happens to me all the time.

Taken the link down.