No OneTemporary
Actions

Authored By

Unknown

Size

18 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/ftalleg.cpp b/util/ftalleg.cpp
	index dbd272ef..43c4f945 100644
	--- a/util/ftalleg.cpp
	+++ b/util/ftalleg.cpp
	@@ -1,491 +1,491 @@
	/*
	--------------
	About
	--------------
	A Freetype wrapper for use with allegro
	Feel free to do whatever you like with this, by all means enjoy!
	Just add it to your project

	--------------
	Linking
	--------------
	on linux:
	g++ `freetype-config --cflags` ftalleg.cpp myfiles.cpp `freetype-config --libs` `allegro-config --libs`

	on windows (you may need to include the freetype dir location, ie -Ic:/mingw/include):
	g++ ftalleg.cpp myfiles.cpp -lfreetype -lalleg

	--------------
	Disclaimer
	--------------
	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
	TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE
	SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*/

	#ifndef FT_FONT_CPP
	#define FT_FONT_CPP

	#include "ftalleg.h"
	#include <allegro.h>
	#include <iostream>
	#include <sstream>
	#include <cassert>

	namespace ftalleg{

	typedef void (pixeler)( BITMAP bitmap, int x, int y, int color );

	static int fixColor(const unsigned char *c,short grays){
	// Safety checks
	assert(c != 0);
	assert(grays != 1);

	// invariant: c can be dereferenced safely
	// invariant: (grays - 1) != 0, thus it can be used as divisor.

	int red = c 255 / (grays - 1);
	int green = c 255 / (grays - 1);
	int blue = c 255 / (grays - 1);
	//alpha = c 255 / (grays - 1);
	return makecol(red,green,blue);
	}
	// Static count of instances of fonts to track library
	static int instances=0;
	static FT_Library ftLibrary = 0;

	character::character() {
	}

	character::~character() {
	//if(line)delete [] line;
	}

	fontSize::fontSize() {
	width = height = italics = 0;
	}

	fontSize::~fontSize() {
	}

	bool fontSize::operator<(const fontSize &fs) const {
	return (width<fs.width \|\| height<fs.height \|\| italics<fs.italics);
	}

	const int fontSize::createKey() const {
	return ((width+10) * (height+20) * (italics+250));
	}

	//! Constructor
	freetype::freetype( const std::string & str, const int x, const int y ){
	//Load library
	if ( !ftLibrary ){
	FT_Init_FreeType(&ftLibrary);
	}
	instances++;
	faceLoaded = kerning = false;
	currentIndex=0;
	currentFilename="";
	faceName="";
	currentChar = new character;
	systemName="";
	internalFix = false;

	this->load( str, 0, x, y );
	}

	//! Destructor
	freetype::~freetype(){

	//if(face!=NULL)FT_Done_Face(face);

	if ( instances > 0 ){
	instances--;
	}

	if ( instances == 0 ){
	FT_Done_FreeType( ftLibrary );
	}

	if ( currentChar ){
	delete currentChar;
	}
	}

	// Extract glyph
	character freetype::extractGlyph(signed long unicode){
	int w, h, ew;
	character tempChar;

	// Translate it according to the given italics
	double italics = (double)(size.italics)*GLYPH_PI/180;

	FT_Matrix matrix;
	matrix.xx = 0x10000L;
	matrix.xy = (FT_Fixed)( sin( italics ) * (GLYPH_SQRT2*0x10000L) );
	matrix.yx = 0;
	matrix.yy = 0x10000L;
	FT_Set_Transform( face, &matrix, 0 );

	FT_Load_Char(face, unicode, FT_LOAD_TARGET_NORMAL \| FT_LOAD_RENDER \| FT_LOAD_FORCE_AUTOHINT);

	w = face->glyph->bitmap.width;
	h = face->glyph->bitmap.rows;
	ew = 0;
	if (!w)ew = 1;
	if (!h)h = 1;

	tempChar.width = (w + ew);
	tempChar.height = h;

	tempChar.rows = face->glyph->bitmap.rows;
	tempChar.grays = face->glyph->bitmap.num_grays;
	tempChar.pitch = face->glyph->bitmap.pitch;
	tempChar.line = new unsigned char[tempChar.rows * tempChar.pitch];
	memcpy(tempChar.line,face->glyph->bitmap.buffer,tempChar.rows * tempChar.pitch);

	tempChar.left = face->glyph->bitmap_left;
	tempChar.top = face->glyph->bitmap_top;
	tempChar.right = face->glyph->advance.x >> 6;
	tempChar.unicode = unicode;

	tempChar.length = (w + ew)+face->glyph->advance.x >> 6;

	return tempChar;
	}

	// Create single index
	void freetype::createIndex(){
	std::map<int, std::map<signed long, character> >::iterator p;
	p = fontTable.find(size.createKey());
	if ( p == fontTable.end() ){
	FT_Set_Pixel_Sizes(face, size.width, size.height);

	FT_UInt g;

	FT_ULong unicode = FT_Get_First_Char(face, &g);
	std::map<signed long, character>tempMap;
	while ( g ){
	tempMap.insert(std::make_pair(unicode,extractGlyph(unicode)));
	unicode = FT_Get_Next_Char(face, unicode, &g);
	}

	fontTable.insert(std::make_pair(size.createKey(),tempMap));
	}
	}

	pixeler getPutPixel(){
	switch( get_color_depth() ){
	case 8 : return _putpixel;
	case 15 : return _putpixel15;
	case 16 : return _putpixel16;
	case 24 : return _putpixel24;
	case 32 : return _putpixel32;
	default : return putpixel;
	}
	}

	// Render a character from the lookup table
	void freetype::drawCharacter(signed long unicode, int &x1, int &y1, BITMAP *bitmap, const int &color){

	pixeler putter = getPutPixel();

	std::map<int, std::map<signed long, character> >::iterator ft;
	ft = fontTable.find(size.createKey());
	if ( ft!=fontTable.end() ){
	std::map<signed long, character>::iterator p;
	p = (ft->second).find(unicode);
	if(p!=(ft->second).end())
	{
	const character & tempChar = p->second;

	unsigned char *line = tempChar.line;
	for (int y = 0; y < tempChar.rows; y++)
	{
	unsigned char *buffer = line;
	for (int x = 0; x < tempChar.width; x++)
	{
	int col = fixColor(buffer++,tempChar.grays);

	if((getr(col)< 50) \|\| (getg(col)< 50) \|\| (getb(col)< 50))continue;
	int red = getr(col) * getr(color) / 255;
	int green = getg(col) * getg(color) / 255;
	int blue = getb(col) * getb(color) / 255;

	//col.alpha= col.alpha * color.alpha / 255;
	// putpixel(bitmap,x1+tempChar.left+x,y1 - tempChar.top+y + size.height,makecol(red,blue,green));
	/* dangerous! putter is probably one of the _putpixel* routines so if x or y are off the bitmap
	* you will get a segfault
	*/
	// putter(bitmap,x1+tempChar.left+x,y1 - tempChar.top+y + size.height,makecol(red,blue,green));
	putter = 0;
	- putpixel(bitmap,x1+tempChar.left+x,y1 - tempChar.top + y + size.height, makecol(red,blue,green));
	+ putpixel(bitmap,x1+tempChar.left+x,y1 - tempChar.top + y + size.height, makecol(red,green,blue));
	}
	line += tempChar.pitch;
	}
	x1+=tempChar.right;
	}
	}
	}

	//! Load font from memory
	bool freetype::load(const unsigned char *memoryFont, unsigned int length, int index, unsigned int width, unsigned int height)
	{
	if(!FT_New_Memory_Face(ftLibrary,memoryFont, length,index,&face))
	{
	currentFilename = "memoryFont";
	currentIndex = index;
	faceLoaded = true;
	size.italics = 0;
	setSize(width, height);
	if(FT_HAS_GLYPH_NAMES(face))
	{
	char buff[1024];
	if(!FT_Get_Glyph_Name(face,currentIndex,buff,sizeof(buff)))
	{
	faceName = currentFilename;
	}
	else faceName = std::string(buff);
	}
	else
	{
	faceName = currentFilename;
	}
	if(FT_HAS_KERNING(face))kerning=true;
	else kerning = false;
	}
	else
	{
	faceLoaded=false;
	std::cout << "Load system font failed\n";
	}

	return faceLoaded;
	}

	//! Load font from file
	bool freetype::load(const std::string & filename, int index, unsigned int width, unsigned int height)
	{
	if(!FT_New_Face(ftLibrary,filename.c_str(),index,&face))
	{
	currentFilename = filename;
	currentIndex = index;
	faceLoaded = true;
	size.italics = 0;
	setSize(width, height);
	if(FT_HAS_GLYPH_NAMES(face))
	{
	char buff[1024];
	if(!FT_Get_Glyph_Name(face,currentIndex,buff,sizeof(buff)))
	{
	faceName = currentFilename;
	}
	else faceName = std::string(buff);
	}
	else
	{
	faceName = currentFilename;
	}
	if(FT_HAS_KERNING(face))kerning=true;
	else kerning = false;
	}
	else
	{
	faceLoaded=false;
	}

	return faceLoaded;
	}

	//! Get text length
	int freetype::getLength(const std::string & text)
	{
	int length=0;
	std::map<int, std::map<signed long, character> >::iterator ft;
	ft = fontTable.find(size.createKey());
	if(ft!=fontTable.end())
	{
	for(unsigned int i = 0; i<text.length();++i)
	{
	std::map<signed long, character>::iterator p;
	p = (ft->second).find(text[i]);
	if(p!=(ft->second).end())
	{
	if(p!=fontTable[size.createKey()].end())
	{
	length+=(p->second).length;
	}
	}
	}
	}
	return length;
	}

	//! Render font to a bitmap
	void freetype::render(int x, int y, const int & color, BITMAP *bmp, ftAlign alignment, const std::string & text, ...)
	{
	if(faceLoaded)
	{
	int rend_x=0;
	int rend_y=0;
	std::ostringstream str;

	// Get extra arguments
	va_list ap;
	va_start(ap,text);
	for(unsigned int i = 0; i<text.length();++i)
	{
	if(text[i]=='%')
	{
	if(text[i+1]=='s')
	{
	str << va_arg(ap,char *);
	++i;
	}
	else if(text[i+1]=='d'\|\|text[i+1]=='i')
	{
	str << va_arg(ap,signed int);
	++i;
	}
	else if(text[i+1]=='c')
	{
	str << (char)va_arg(ap,int);
	++i;
	}
	else str << text[i];
	}
	else
	{
	str << text[i];
	}
	}
	va_end(ap);

	std::string fixedText(str.str());
	switch(alignment)
	{
	case ftLeft:
	rend_x=x;
	rend_y=y;
	break;
	case ftCenter:
	rend_x = x - getLength(fixedText)/2;
	rend_y=y;
	break;
	case ftRight:
	rend_x = x - getLength(fixedText);
	rend_y=y;
	break;
	default:
	rend_x=x;
	rend_y=y;
	break;
	}
	int previous = 0;
	int next = 0;
	for(unsigned int i = 0; i<fixedText.length();++i){
	if(kerning && previous && next){
	next = FT_Get_Char_Index( face, fixedText[i] );
	FT_Vector delta;
	FT_Get_Kerning( face, previous, next, FT_KERNING_DEFAULT, &delta );
	rend_x += delta.x >> 6;
	previous = next;
	}
	drawCharacter(fixedText[i],rend_x, rend_y, bmp, color);
	}
	}
	}

	int freetype::calculateMaximumHeight(){
	std::map<int, std::map<signed long, character> >::iterator ft;
	ft = fontTable.find(size.createKey());
	int top = 0;
	long code = 0;
	if ( ft != fontTable.end() ){
	std::map<signed long, character>::iterator p;
	std::map< signed long, character > & map = ft->second;
	for ( p = map.begin(); p != map.end(); p++ ){
	const character & ch = p->second;
	printf( "%c( %ld ). top = %d. rows = %d. total = %d\n", (char) ch.unicode, ch.unicode, ch.top, ch.rows, ch.top + ch.rows );
	if ( ch.top + ch.rows > top ){
	code = ch.unicode;
	top = ch.top + ch.rows;
	}
	}
	}
	printf( "Largest letter = %ld\n", code );
	return top;
	}


	const int freetype::height( long code ) const {
	std::map<int, std::map<signed long, character> >::const_iterator ft;
	ft = fontTable.find( size.createKey() );
	if ( ft != fontTable.end() ){
	std::map<signed long, character>::const_iterator p;
	p = (ft->second).find( code );
	if ( p != (ft->second).end() ){
	const character & temp = p->second;
	// printf( "%c top = %d rows = %d\n", (char) code, temp.top, temp.rows );
	return temp.top + temp.rows;
	}
	}
	return 0;
	}

	const int freetype::calculateHeight( const std::string & str ) const {
	int max = 0;
	for ( unsigned int i = 0; i < str.length(); i++ ){
	int q = height( str[ i ] );
	// printf( "Height of %c is %d\n", str[ i ], q );
	if ( q > max ){
	max = q;
	}
	}

	return max;
	}

	//! Set size
	void freetype::setSize( unsigned int w, unsigned int h){
	if ( w != size.width && h != size.height ){
	if(internalFix)return;
	if(w<=0 \|\| h<=0)return;
	size.width=w;
	size.height=h;
	createIndex();
	// maximumHeight = calculateMaximumHeight();
	}
	}

	//! Set italics
	void freetype::setItalics(int i)
	{
	if(internalFix)return;
	if(i<-45)i=(-45);
	else if(i>45)i=45;
	size.italics = i;
	createIndex();
	}

	//! Get Width
	int freetype::getWidth(){
	return size.width;
	}

	//! Get Height
	int freetype::getHeight( const std::string & str ) const {
	// return size.height;
	return calculateHeight( str );
	}

	//! Get Italics
	int freetype::getItalics()
	{
	return size.italics;
	}
	}

	#endif /* FONT_BASE_CPP */
	diff --git a/util/funcs.cpp b/util/funcs.cpp
	index 80ba86b2..bb115a75 100644
	--- a/util/funcs.cpp
	+++ b/util/funcs.cpp
	@@ -1,60 +1,64 @@
	#include "funcs.h"
	#include <allegro.h>
	#include <vector>
	#include <string>

	using namespace std;

	/*
	inline int rnd( int q ){
	if ( q <= 0 ) return 0;
	return (int)( rand() % q );
	}
	*/

	int Util::rnd( int q, int min, int range ){
	return q - min + rnd( range );
	}

	int Util::rnd( int min, int max ){
	return rnd( max - min ) + min;
	}

	+void Util::rest( int x ){
	+ ::rest( x );
	+}
	+
	vector< string > Util::getFiles( string dataPath, string find ){
	struct al_ffblk info;
	vector< string > files;

	if ( al_findfirst( (dataPath + find).c_str(), &info, FA_ALL ) != 0 ){
	return files;
	}
	files.push_back( string( info.name ) );
	while ( al_findnext( &info ) == 0 ){
	files.push_back( dataPath + string( info.name ) );
	}
	al_findclose( &info );

	return files;
	}

	void Util::blend_palette( int * pal, int mp, int sc, int ec ) {

	ASSERT( pal );
	ASSERT( mp != 0 );

	int sc_r = getr( sc );
	int sc_g = getg( sc );
	int sc_b = getb( sc );

	int ec_r = getr( ec );
	int ec_g = getg( ec );
	int ec_b = getb( ec );

	for ( int q = 0; q < mp; q++ ) {
	float j = (float)( q ) / (float)( mp );
	int f_r = (int)( 0.5 + (float)( sc_r ) + (float)( ec_r-sc_r ) * j );
	int f_g = (int)( 0.5 + (float)( sc_g ) + (float)( ec_g-sc_g ) * j );
	int f_b = (int)( 0.5 + (float)( sc_b ) + (float)( ec_b-sc_b ) * j );
	pal[q] = makecol( f_r, f_g, f_b );
	}

	}
	diff --git a/util/funcs.h b/util/funcs.h
	index b29eea63..7eb63b16 100644
	--- a/util/funcs.h
	+++ b/util/funcs.h
	@@ -1,28 +1,30 @@
	#ifndef _funcs_h
	#define _funcs_h

	#include <stdlib.h>
	#include <vector>
	#include <string>

	namespace Util{

	// int rnd( int q );
	inline int rnd( int q ){
	if ( q <= 0 ) return 0;
	return (int)( rand() % q );
	}

	std::vector< std::string > getFiles( std::string dataPath, std::string find );

	/* return a random number + some range between min/max */
	int rnd( int q, int min, int max );

	/* return a number between min/max */
	int rnd( int min, int max );

	void blend_palette( int * pal, int mp, int sc, int ec );

	+void rest( int x );
	+
	}

	#endif
	diff --git a/util/keyboard.cpp b/util/keyboard.cpp
	index f253984d..6ad963c3 100644
	--- a/util/keyboard.cpp
	+++ b/util/keyboard.cpp
	@@ -1,51 +1,53 @@
	#include "keyboard.h"
	#include "allegro.h"
	#include <iostream>
	#include <vector>
	#include <map>

	using namespace std;

	#ifndef debug
	#define debug cout<<"File: "<<__FILE__<<" Line: "<<__LINE__<<endl;
	#endif

	const int Keyboard::Key_A = KEY_A;
	const int Keyboard::Key_S = KEY_S;
	const int Keyboard::Key_D = KEY_D;

	const int Keyboard::Key_LEFT = KEY_LEFT;
	const int Keyboard::Key_RIGHT = KEY_RIGHT;
	const int Keyboard::Key_UP = KEY_UP;
	const int Keyboard::Key_DOWN = KEY_DOWN;
	const int Keyboard::Key_SPACE = KEY_SPACE;
	+const int Keyboard::Key_F12 = KEY_F12;
	+const int Keyboard::Key_ESC = KEY_ESC;

	Keyboard::Keyboard(){
	}

	/* KEY_MAX is defined in allegro at
	* allegro/include/allegro/keyboard.h
	*/
	void Keyboard::poll(){

	for ( int q = 0; q < KEY_MAX; q++ ){
	my_keys[ q ] = key[ q ];
	}

	}

	void Keyboard::readKeys( vector< int > & all_keys ) const{
	for ( map<int,bool>::const_iterator it = my_keys.begin(); it != my_keys.end(); it++ ){
	if ( (*it).second ){
	all_keys.push_back( (*it).first );
	}
	}
	}

	bool Keyboard::keypressed() const{
	for ( map<int,bool>::const_iterator it = my_keys.begin(); it != my_keys.end(); it++ ){
	const bool & n = (*it).second;
	if ( n ) return true;
	}
	return false;
	}
	diff --git a/util/keyboard.h b/util/keyboard.h
	index a13d7906..3e166ec1 100644
	--- a/util/keyboard.h
	+++ b/util/keyboard.h
	@@ -1,55 +1,58 @@
	#ifndef _keyboard_h
	#define _keyboard_h

	#include <map>
	#include <vector>

	using namespace std;

	/* handles allegro key[] array better than keypressed()
	* and readkey()
	*/
	class Keyboard{
	public:

	Keyboard();

	/* poll:
	* Put the keys in Allegro's key[] array into our map of int -> bool
	*/
	void poll();

	/* []:
	* Extract a boolean value given a key number
	*/
	inline const bool operator[] ( const int i ){
	return my_keys[ i ];
	}

	/* keypressed:
	* Returns true if a key is pressed
	*/
	bool keypressed() const;

	/* readKeys:
	* Store all pressed keys in a user supplied vector
	*/
	void readKeys( vector< int > & all_keys ) const;

	static const int Key_A;
	static const int Key_S;
	static const int Key_D;

	static const int Key_LEFT;
	static const int Key_RIGHT;
	static const int Key_UP;
	static const int Key_DOWN;
	static const int Key_SPACE;

	+ static const int Key_F12;
	+ static const int Key_ESC;
	+
	protected:

	map<int,bool> my_keys;

	};

	#endif
	diff --git a/util/lit_bitmap.cpp b/util/lit_bitmap.cpp
	new file mode 100644
	index 00000000..2ba96382
	--- /dev/null
	+++ b/util/lit_bitmap.cpp
	@@ -0,0 +1,23 @@
	+#include <allegro.h>
	+
	+#include "bitmap.h"
	+#include "lit_bitmap.h"
	+
	+LitBitmap::LitBitmap( const Bitmap & b ):
	+Bitmap( b ){
	+}
	+
	+LitBitmap::LitBitmap():
	+Bitmap(){
	+}
	+
	+LitBitmap::~LitBitmap(){
	+}
	+
	+void LitBitmap::draw( const int x, const int y, const Bitmap & where ) const {
	+ ::draw_sprite_ex( where.getBitmap(), getBitmap(), x, y, SPRITE_LIT );
	+}
	+
	+void LitBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	+ ::draw_sprite_h_flip_ex( where.getBitmap(), getBitmap(), x, y, SPRITE_LIT );
	+}
	diff --git a/util/lit_bitmap.h b/util/lit_bitmap.h
	new file mode 100644
	index 00000000..2a40c4cf
	--- /dev/null
	+++ b/util/lit_bitmap.h
	@@ -0,0 +1,16 @@
	+#ifndef _paintown_lit_bitmap_h
	+#define _paintown_lit_bitmap_h
	+
	+#include "bitmap.h"
	+
	+class LitBitmap: public Bitmap {
	+public:
	+ LitBitmap( const Bitmap & b );
	+ LitBitmap();
	+ virtual ~LitBitmap();
	+
	+ virtual void draw( const int x, const int y, const Bitmap & where ) const;
	+ virtual void drawHFlip( const int x, const int y, const Bitmap & where ) const;
	+};
	+
	+#endif

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 2:15 PM (3 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 69419
Default Alt Text: (18 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions