E:/Eigene Dateien/Eigene Projekte/c0re/Texture.cpp

Go to the documentation of this file.

/*
        This file is part of c0re.

        c0re is a multiplayer RTS on a hexagonal map with an evolving unit concept.
    Copyright (C) 2007 Stephan Hofmann

    c0re 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 3 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, see <http://www.gnu.org/licenses/>.
*/

#include "Texture.h"

#include "system.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include <iostream>
#include <stdlib.h>
#include <conio.h>
#include <io.h>
#include <math.h>

#include "TextureMasked.h"
#include "TextureAlpha.h"

std::map<std::string, TextureInterface*> Texture::cachedTextures;
std::map<int, Texture*> Texture::allItems;

int Texture::idCounter = 1;

Texture::Texture()
{
        id = idCounter++;
        allItems[id] = this;
}

Texture::~Texture()
{
        allItems.erase(allItems.find(id));
}

Texture* Texture::get(int p_id)
{
        Texture* ret = 0;
        std::map<int, Texture*>::iterator it = allItems.find(p_id);
        if (it != allItems.end())
                ret = it->second;
        return ret;
}

int Texture::loadAndBind(std::string p_filename, eTextureModification p_modifikationflag)
{
        int ret = 0;

        if (cachedTextures.find(p_filename) == cachedTextures.end()) //Not cached yet
        {
                TextureInterface *ti = new TextureAlpha();
                ti->loadAndBind(p_filename, p_modifikationflag);
                cachedTextures[p_filename] = ti;
        }
        
        myTexture = cachedTextures[p_filename];
        ratio = myTexture->ratio;
        sequence = 0;
        sequenceCount = 1;
        return ret;
}

int Texture::render()
{
        int ret = 0;

        glPushMatrix();
        glScaled(1.0, 1.0 / ratio, 1.0);

        double frame_width = 1.0 / (double)sequenceCount;
        double x_anfang = ((sequence % sequenceCount) * frame_width);
        double x_ende = x_anfang + frame_width;
        double y_anfang = 1 - frame_width - (sequence / sequenceCount) * frame_width;
        double y_ende = y_anfang + frame_width;

        double width = 1.0, height = 1.0;
        glLoadName(id);
                
        myTexture->render(x_anfang, x_ende, y_anfang, y_ende);

        glPopMatrix();

        return ret;
}


Field* Texture::getField()
{
        return 0;
}

Button* Texture::getButton()
{
        return 0;
}

---