src/Scoobie/ScImage.cpp

/*
	Copyright (C) 2005 by Ruben Henner Zilibowitz <rzilibowitz@users.sourceforge.net>
	Part of the Toy Cars Project http://toycars.sourceforge.net

	This program is free software; you can redistribute it and/or modify
	it under the terms of the license.
	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY.

	See the COPYING file for more details.
*/

/*
 *  ScImage.cpp
 *  Scoobie
 *
 *  Created by Ruben Henner Zilibowitz on 26/11/04.
 *
 */

#include "ScImage.h"
#include "ScException.h"
#include <cstdio>
#include <cstring>

// constructor - Loads image into texture memory. Fits powers of two textures to the
// size of the image. If dimensions are odd then one pixel will be cropped.
//
// border must be either 0 or 1. Usually 1 is desireable since then a one pixel border of the
// image is not drawn but instead used to do linear filtering. If 0 border is used then
// image is drawn at original dimensions and the border color option is used by OpenGL.
//
// flip can be true or false. If it is true, the pixel data will be flipped vertically when
// stored as a texture. This can be usefull because Scoobie's coordinate system is upside down.
//
ScImage::ScImage(short border, const ScPixelData& pixelData, bool flip)
{
	GLsizei maxtexsize;
	short col, row, k;
	short x, y;
	long offset;
	int imageWidth = pixelData.width;
	int imageHeight = pixelData.height;
	const char* pixels = pixelData.pixels;

	// make width and height even
	if (imageWidth % 2 == 1)	imageWidth--;
	if (imageHeight % 2 == 1)	imageHeight--;

	// get the maximum texture size
	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize);

	// calculate number of columns and rows
	columns = calculateNumCells(maxtexsize, imageWidth);
	rows = calculateNumCells(maxtexsize, imageHeight);

	// generate texture names
	texs = new GLuint [columns*rows];
	glGenTextures(columns*rows, texs);

	// allocate column info arrays
	colSize = new short [columns];
	colTC1 = new ScFloat [columns];
	colTC2 = new ScFloat [columns];

	// allocate row info  arrays
	rowSize = new short [rows];
	rowTC1 = new ScFloat [rows];
	rowTC2 = new ScFloat [rows];

	// calculate cell sizes and texture coordinates
	calculateCellSizeAndTC(maxtexsize, imageWidth, colSize, colTC1, colTC2);
	calculateCellSizeAndTC(maxtexsize, imageHeight, rowSize, rowTC1, rowTC2);

	// make sure 2d textures are enabled
	glEnable(GL_TEXTURE_2D);

	// tell OpenGL what the row length of the image data is
	glPixelStorei(GL_UNPACK_ROW_LENGTH, pixelData.pitch / pixelData.bytes_pp);

	// flip pixels vertically if necessary
	if (flip)
	{
		char* flippedPix = new char [pixelData.pitch * pixelData.height];
		if (flippedPix == NULL)
			ScThrowErr("out of memory whilst flipping pixels");

		for (y = 0; y < pixelData.height; y++)
		{
			// copy a row
			memcpy(	flippedPix + y*pixelData.pitch,
					pixelData.pixels + (pixelData.height-y-1)*pixelData.pitch,
					pixelData.pitch);
		}

		pixels = flippedPix;
	}

	// upload textures

	// init texture counter
	k = 0;

	// init y location
	y = 0;

	// loop through rows
	for (row = 0; row < rows; row++)
	{
		// init x location
		x = 0;

		// loop through columns
		for (col = 0; col < columns; col++)
		{
			// bind to correct texture id
			glBindTexture(GL_TEXTURE_2D, texs[k]);

			// set texture parameters
			if (border > 0)
			{
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			}
			else
			{
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			}
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

			// calculate offset in pixel data
			offset = y*pixelData.pitch + x*pixelData.bytes_pp;

			// upload texture to graphics card
			glTexImage2D(	GL_TEXTURE_2D,
							0,
							pixelData.internalformat,
							colSize[col]+2,
							rowSize[row]+2,
							0,
							pixelData.format,
							pixelData.type,
							pixels + offset);
			if (glGetError() != GL_NO_ERROR) {
				char msg[256];
				sprintf(msg, "OpenGL error number %d", glGetError());
				ScThrowErr(msg);
			}

			// move x location
			x += colSize[col];

			// increment texture counter
			k++;
		}

		// move y location
		y += rowSize[row];
	}

	// Above calculation assume a border of 1 pixel in the image.
	// If there is no border modify row and column info. OpenGL
	// will use the border color setting to draw scaled image.
	// Image width and height are each made two pixels larger.
	if (border == 0)
	{
		colTC1[0] = 0.0;
		colTC2[columns-1] = 1.0;
		colSize[0]++;
		colSize[columns-1]++;

		rowTC1[0] = 0.0;
		rowTC2[rows-1] = 1.0;
		rowSize[0]++;
		rowSize[rows-1]++;
	}

	// if flipping was used we must deallocate the memory for the flipped pixels
	if (flip)
		delete [] pixels;
}

//
// destructor - frees up our memory
//
ScImage::~ScImage()
{
	// free textures
	if (columns*rows > 0)
		glDeleteTextures(columns*rows, texs);

	// free array memory
	if (texs)		delete [] texs;
	if (colSize)	delete [] colSize;
	if (colTC1)		delete [] colTC1;
	if (colTC2)		delete [] colTC2;
	if (rowSize)	delete [] rowSize;
	if (rowTC1)		delete [] rowTC1;
	if (rowTC2)		delete [] rowTC2;
}

//
// draw - draws entire image at given location
//
void ScImage::draw(ScFloat locx, ScFloat locy)
{
	short col, row, k;
	ScFloat x1, y1, x2, y2;
	ScFloat tx1, ty1, tx2, ty2;

	// init texture counter
	k = 0;

	// init pixel location y1
	y1 = locy;

	// loop through rows
	for (row = 0; row < rows; row++)
	{
		// get texture coordinates
		ty1 = rowTC1[row];
		ty2 = rowTC2[row];

		// calculate pixel location y2
		y2 = y1 + rowSize[row];

		// init pixel location x1
		x1 = locx;

		// loop through columns
		for (col = 0; col < columns; col++)
		{
			// calculate pixel location x2
			x2 = x1 + colSize[col];

			// get texture coordinates
			tx1 = colTC1[col];
			tx2 = colTC2[col];

			// bind to correct texture id
			glBindTexture(GL_TEXTURE_2D, texs[k]);

			// draw texture
			glBegin(GL_QUADS);
			glTexCoord2d(tx1, ty1);	glVertex2d(x1, y1);
			glTexCoord2d(tx2, ty1);	glVertex2d(x2, y1);
			glTexCoord2d(tx2, ty2);	glVertex2d(x2, y2);
			glTexCoord2d(tx1, ty2);	glVertex2d(x1, y2);
			glEnd();

			// move pixel location x1 to x2
			x1 = x2;

			// increment texture counter
			k++;
		}

		// move pixel location y1 to y2
		y1 = y2;
	}
}

// given a maximum texture size and a distance, calculate how many
// textures are needed to span the distance where each texture is a
// power of two and adjacent textures overlap by two pixels.
short ScImage::calculateNumCells(short maxtexsize, short distance)
{
	short cellCount = 0;

	// adjust distance for border on each side
	distance -= 2;

	do
	{
		// count number of cells with current size will fit
		while (distance >= maxtexsize - 2)
		{
			distance -= maxtexsize - 2;
			cellCount++;
		}

		// drop to smaller texture size
		maxtexsize /= 2;
	}
	while (maxtexsize > 2);

	// if distance still remains then textures got too small
	if (distance > 0)
		printf("Warning: Texture size too small. Distance remaining: %d\n", distance);

	// return the count
	return cellCount;
}

// calculate the sizes and texture coordinates for each cell
// given the maximum texture size and the distance.
void ScImage::calculateCellSizeAndTC(short maxtexsize, short distance, short* sizes, ScFloat* tc1, ScFloat* tc2)
{
	short cellCount = 0;

	// adjust distance for border on each side
	distance -= 2;

	do
	{
		// count number of cells with current size will fit
		while (distance >= maxtexsize - 2)
		{
			// calculate cell info
			sizes[cellCount] = maxtexsize - 2;
			tc1[cellCount] = 1.0 / ScFloat(maxtexsize);
			tc2[cellCount] = 1.0 - tc1[cellCount];

			// decrease distance
			distance -= maxtexsize - 2;

			// count a cell
			cellCount++;
		}

		// drop to smaller texture size
		maxtexsize /= 2;
	}
	while (maxtexsize > 2);
}