예제 #1
0
파일: atlas.cpp 프로젝트: galek/MIngEd
    void Atlas::Generate(bool clear)
    {
	m_Atlas.create(M_UBYTE, m_Width, m_Height, m_BPP);
	unsigned char col[]= {255, 255, 255, 0};
	for(uint32 x = 0; x < m_Width; ++x)
	    for(uint32 y = 0; y < m_Height; ++y) 
		m_Atlas.writePixel(x, y, col);

	for(imageMapIter iImage = m_Images.begin(); 
	    iImage != m_Images.end(); 
	    iImage++)
	    WriteImage(iImage->second);

	MEngine* engine = MEngine::getInstance();
	MRenderingContext* render = engine->getRenderingContext();
	
	if(m_TextureID == 0)
	    render->createTexture(&m_TextureID);

	render->bindTexture(m_TextureID);
	render->sendTextureImage(&m_Atlas, false, 1, 0);

	if(clear)
	{
	    // remove images
            delete [] m_Layout;
            m_Layout = NULL;
        }
    }
예제 #2
0
void MGui2d::drawTexturedQuad(unsigned int textureId)
{
	MRenderingContext * render = MGui::getInstance()->getRenderingContext();

	MVector2 g_vertices[8];
	MVector2 g_texCoords[8];

	render->disableNormalArray();
	render->disableColorArray();
	render->enableVertexArray();
	render->enableTexCoordArray();

	g_vertices[0] = MVector2(m_position.x, m_position.y);
	g_vertices[1] = MVector2(m_position.x, m_position.y + m_scale.y);
	g_vertices[3] = MVector2(m_position.x + m_scale.x, m_position.y + m_scale.y);
	g_vertices[2] = MVector2(m_position.x + m_scale.x, m_position.y);

	g_texCoords[0] = MVector2(0, 0);
	g_texCoords[1] = MVector2(0, 1);
	g_texCoords[3] = MVector2(1, 1);
	g_texCoords[2] = MVector2(1, 0);

	render->setTexCoordPointer(M_FLOAT, 2, g_texCoords);
	render->setVertexPointer(M_FLOAT, 2, g_vertices);

	render->bindTexture(textureId);
	render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);
}
예제 #3
0
void MGuiTextureFont::draw(const char * text, const MVector2 & position, float size)
{
	MRenderingContext * render = MGui::getInstance()->getRenderingContext();

	MVector2 g_vertices[4];
	MVector2 g_texCoords[4];

	float xc=position.x, yc=position.y, u=0, v=0;

	render->disableNormalArray();
	render->disableColorArray();
	render->enableVertexArray();
	render->enableTexCoordArray();

	render->setVertexPointer(M_FLOAT, 2, g_vertices);
	render->setTexCoordPointer(M_FLOAT, 2, g_texCoords);

	render->bindTexture(m_texture);

	unsigned int i;
	unsigned int textLength = strlen(text);
	for(i=0; i<textLength; i++)
	{
		if(text[i] == '\n')	// return
		{
			yc += size;
			xc = position.x;
		}
		else if(text[i] == '	') // tab
		{
			xc += size * getTabSpace();
		}
		else
		{
			u=float((unsigned char)text[i]%16)/16.0f; //u position of character
			v=float((unsigned char)text[i]/16)/16.0f; //v position of character

			g_texCoords[0] = MVector2(u, v+0.0625f);
			g_vertices[0] = MVector2(xc, yc+size);						
			
			g_texCoords[1] = MVector2(u+0.0625f, v+0.0625f);	
			g_vertices[1] = MVector2(xc+size, yc+size);							
			
			g_texCoords[3] = MVector2(u+0.0625f, v+0.001f);	
			g_vertices[3] = MVector2(xc+size, yc);							
			
			g_texCoords[2] = MVector2(u, v+0.001f);				
			g_vertices[2] = MVector2(xc, yc);

			render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);

			xc += size * getSpace(); //move to next character
		}
	}
}
예제 #4
0
파일: atlas.cpp 프로젝트: galek/MIngEd
    void Atlas::Select()
    {
	if(g_Selected == this)
	    return;
	MEngine* engine = MEngine::getInstance();
	MRenderingContext* render = engine->getRenderingContext();
	
	Renderer::Flush();

	render->enableTexture();
	render->setBlendingMode(M_BLENDING_ALPHA);
	render->enableBlending();
	
	if(m_TextureID != 0)
	{
	    render->bindTexture(m_TextureID);
	    //render->sendTextureImage(&m_Atlas, false, 1, 0);
	}
	g_Selected = this;
    }
예제 #5
0
void MTextureRef::update(void)
{
    M_PROFILE_SCOPE(MTextureRef::update);
	MEngine * engine = MEngine::getInstance();
	MRenderingContext * render = engine->getRenderingContext();

	MImage image;
	if(engine->getImageLoader()->loadData(getFilename(), &image))
	{
		if(m_textureId == 0)
			render->createTexture(&m_textureId);

		m_components = image.getComponents();
		m_width = image.getWidth();
		m_height = image.getHeight();
				
		// send texture image
		render->bindTexture(m_textureId);
		render->sendTextureImage(&image, isMipmapEnabled(), 1, 0);
	}
}
예제 #6
0
void MFixedRenderer::drawText(MOText * textObj)
{
    M_PROFILE_SCOPE(MFixedRenderer::drawText);
	MFont * font = textObj->getFont();
	const char * text = textObj->getText();
	vector <float> * linesOffset = textObj->getLinesOffset();
	
	if(! (strlen(text) > 0 && font))
		return;
	
	if(linesOffset->size() == 0)
		return;
	
	MRenderingContext * render = MEngine().getInstance()->getRenderingContext();
	
	
	render->enableBlending();
	render->enableTexture();
	render->disableLighting();
	
	render->setColor4(*textObj->getColor());
	render->setBlendingMode(M_BLENDING_ALPHA);
	
	static MVector2 vertices[4];
	static MVector2 texCoords[4];
	
	render->disableNormalArray();
	render->disableColorArray();
	render->enableVertexArray();
	render->enableTexCoordArray();
	
	render->setVertexPointer(M_FLOAT, 2, vertices);
	render->setTexCoordPointer(M_FLOAT, 2, texCoords);
	
	render->bindTexture(font->getTextureId());
	
	unsigned int lineId = 0;
	float lineOffset = (*linesOffset)[0];
	
	float size = textObj->getSize();
	float tabSize = size*2;
	float fontSize = (float)font->getFontSize();
	float widthFactor = font->getTextureWith() / fontSize;
	float heightFactor = font->getTextureHeight() / fontSize;
	float xc = 0, yc = 0;
	
	unsigned int i;
	unsigned int textLen = strlen(text);
	for(i=0; i<textLen; i++)
	{
		if(text[i] == '\n') // return
		{
			if(((i+1) < textLen))
			{
				lineId++;
				lineOffset = (*linesOffset)[lineId];
				
				yc += size;
				xc = 0;
			}
			continue;
		}
		
		if(text[i] == '\t') // tab
		{
			int tab = (int)(xc / tabSize) + 1;
			xc = tab*tabSize;
			continue;
		}
		
		// get character
		unsigned int charCode = (unsigned int)((unsigned char)text[i]);
		MCharacter * character = font->getCharacter(charCode);
		if(! character)
			continue;
		
		MVector2 pos = character->getPos();
		MVector2 scale = character->getScale();
		MVector2 offset = character->getOffset() * size + MVector2(lineOffset, 0);
		
		float width = scale.x * widthFactor * size;
		float height = scale.y * heightFactor * size;
		
		// construct quad
		texCoords[0] = MVector2(pos.x, (pos.y + scale.y));
		vertices[0] = MVector2(xc, (yc + height)) + offset;						
		
		texCoords[1] = MVector2((pos.x + scale.x), (pos.y + scale.y));	
		vertices[1] = MVector2((xc + width), (yc + height)) + offset;							
		
		texCoords[3] = MVector2((pos.x + scale.x), pos.y);	
		vertices[3] = MVector2((xc + width), yc) + offset;							
		
		texCoords[2] = MVector2(pos.x, pos.y);				
		vertices[2] = MVector2(xc, yc) + offset;
		
		// draw quad
		render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);
		
		//move to next character
		xc += character->getXAdvance() * size;
	}	
}
예제 #7
0
void MFixedRenderer::drawDisplay(MSubMesh * subMesh, MDisplay * display, MVector3 * vertices, MVector3 * normals, MColor * colors)
{
    M_PROFILE_SCOPE(MFixedRenderer::drawDisplay);
	MEngine * engine = MEngine::getInstance();
	MRenderingContext * render = engine->getRenderingContext();
	
	
	render->setColor4(MVector4(1, 1, 1, 1));
	

	// get material
	MMaterial * material = display->getMaterial();
	{
		float opacity = material->getOpacity();
		if(opacity <= 0.0f)
			return;
		
		// data
		M_TYPES indicesType = subMesh->getIndicesType();
		void * indices = subMesh->getIndices();
		MVector2 * texCoords = subMesh->getTexCoords();

		// begin / size
		unsigned int begin = display->getBegin();
		unsigned int size = display->getSize();
		
		// get properties
		M_PRIMITIVE_TYPES primitiveType = display->getPrimitiveType();
		M_BLENDING_MODES blendMode = material->getBlendMode();
		M_CULL_MODES cullMode = display->getCullMode();
		MVector3 * diffuse = material->getDiffuse();
		MVector3 * specular = material->getSpecular();
		MVector3 * emit = material->getEmit();
		float shininess = material->getShininess();
		
		// get current fog color
		MVector3 currentFogColor;
		render->getFogColor(&currentFogColor);
		
		// set cull mode
		if(cullMode == M_CULL_NONE){
			render->disableCullFace();
		}
		else{
			render->enableCullFace();
			render->setCullMode(cullMode);
		}
		
		// texture passes
		unsigned int texturesPassNumber = MIN(8, material->getTexturesPassNumber());
		
		// set blending mode
		render->setBlendingMode(blendMode);
		
		// alpha test
		if(blendMode != M_BLENDING_ALPHA && texturesPassNumber > 0)
		{
			MTexturePass * texturePass = material->getTexturePass(0);
			MTexture * texture = texturePass->getTexture();
			if(texture)
			{
				if(texture->getTextureRef()->getComponents() > 3)
					render->setAlphaTest(0.5f);
			}
		}
		
		// set fog color depending on blending
		switch(blendMode)
		{
			case M_BLENDING_ADD:
			case M_BLENDING_LIGHT:
				render->setFogColor(MVector3(0, 0, 0));
				break;
			case M_BLENDING_PRODUCT:
				render->setFogColor(MVector3(1, 1, 1));
				break;
		}
		
		// fixed pipeline
		{
			// no FX
			render->bindFX(0);
			
			// Vertex
			render->enableVertexArray();
			render->setVertexPointer(M_FLOAT, 3, vertices);
			
			// Normal
			if(normals)
			{
				render->enableNormalArray();
				render->setNormalPointer(M_FLOAT, normals);
			}
			
			// Color
			if(colors)
			{
				render->disableLighting();
				render->enableColorArray();
				render->setColorPointer(M_UBYTE, 4, colors);
			}
			
			// Material
			render->setMaterialDiffuse(MVector4(diffuse->x, diffuse->y, diffuse->z, opacity));
			render->setMaterialSpecular(MVector4(*specular));
			render->setMaterialAmbient(MVector4());
			render->setMaterialEmit(MVector4(*emit));
			render->setMaterialShininess(shininess);
			
			// switch to texture matrix mode
			if(texturesPassNumber > 0)
				render->setMatrixMode(M_MATRIX_TEXTURE);
			else
				render->disableTexture();
			
			// Textures
			int id = texturesPassNumber;
			for(unsigned int t=0; t<texturesPassNumber; t++)
			{
				MTexturePass * texturePass = material->getTexturePass(t);
				
				MTexture * texture = texturePass->getTexture();
				if((! texture) || (! texCoords))
				{
					render->bindTexture(0, t);
					render->disableTexture();
					render->disableTexCoordArray();
					continue;
				}
				
				// texCoords
				unsigned int offset = 0;
				if(subMesh->isMapChannelExist(texturePass->getMapChannel()))
					offset = subMesh->getMapChannelOffset(texturePass->getMapChannel());
				
				// texture id
				unsigned int textureId = 0;
				MTextureRef * texRef = texture->getTextureRef();
				if(texRef)
					textureId = texRef->getTextureId();
				
				// bind texture
				render->bindTexture(textureId, t);
				render->enableTexture();
				render->setTextureCombineMode(texturePass->getCombineMode());
				render->setTextureUWrapMode(texture->getUWrapMode());
				render->setTextureVWrapMode(texture->getVWrapMode());
				
				// texture matrix
				render->loadIdentity();
				render->translate(MVector2(0.5f, 0.5f));
				render->scale(*texture->getTexScale());
				render->rotate(MVector3(0, 0, -1), texture->getTexRotate());
				render->translate(MVector2(-0.5f, -0.5f));
				render->translate(*texture->getTexTranslate());
				
				// texture coords
				render->enableTexCoordArray();
				render->setTexCoordPointer(M_FLOAT, 2, texCoords + offset);
			}
			
			// switch back to modelview matrix mode
			if(texturesPassNumber > 0)
				render->setMatrixMode(M_MATRIX_MODELVIEW);
			
			// draw
			if(indices)
			{
				switch(indicesType)
				{
					case M_USHORT:
						render->drawElement(primitiveType, size, indicesType, (unsigned short*)indices + begin);
						break;
					case M_UINT:
						render->drawElement(primitiveType, size, indicesType, (unsigned int*)indices + begin);
						break;
				}
			}
			else{
				render->drawArray(primitiveType, begin, size);
			}
			
			
			// disable arrays
			render->disableVertexArray();
			if(normals)
				render->disableNormalArray();
			if(colors)
				render->disableColorArray();
			
			// restore textures
			for(int t=(int)(id-1); t>=0; t--)
			{
				render->bindTexture(0, t);
				render->disableTexture();
				render->disableTexCoordArray();
				render->setTextureCombineMode(M_TEX_COMBINE_MODULATE);
				
				render->setMatrixMode(M_MATRIX_TEXTURE);
				render->loadIdentity();
				render->setMatrixMode(M_MATRIX_MODELVIEW);
			}
		}

		// restore fog and alpha test
		render->setFogColor(currentFogColor);
		if(blendMode != M_BLENDING_ALPHA)
			render->setAlphaTest(0.0f);
		
		// restore lighting
		if(colors)
			render->enableLighting();
	}
}
예제 #8
0
파일: MFontBin.cpp 프로젝트: Keedu/maratis
bool exportFontBin(const char * filename, MFont * font)
{
	if(! font)
		return false;

	MEngine * engine = MEngine::getInstance();
	MRenderingContext * render = engine->getRenderingContext();

	// read image
	MImage image;
	render->bindTexture(font->getTextureId());
	render->getTexImage(0, &image);
	
	unsigned int width = image.getWidth();
	unsigned int height = image.getHeight();

	if(width == 0 && height == 0)
	{
		printf("Error : unable to create image font for %s\n", filename);
		return false;
	}

	// create file
	FILE * file = fopen(filename, "wb");
	if(! file)
	{
		printf("Error : can't create file %s\n", filename);
		return false;
	}
	
	// bin
	fwrite(M_FONT_HEADER, sizeof(char), 8, file);

	// version
	int version = 1;
	fwrite(&version, sizeof(int), 1, file);

	// font size
	unsigned int fontSize = font->getFontSize();
	fwrite(&fontSize, sizeof(int), 1, file);

	// write image
	{
		fwrite(&width, sizeof(int), 1, file);
		fwrite(&height, sizeof(int), 1, file);

		unsigned char color[4];
		unsigned int x, y;
		for(y=0; y<height; y++)
		{
			for(x=0; x<width; x++)
			{
				image.readPixel(x, y, color);
				fwrite(&color[3], sizeof(char), 1, file);
			}
		}
	}

	// write characters infos
	{
		map <unsigned int, MCharacter> * characters = font->getCharacters();

		// size
		unsigned int size = font->getCharactersNumber();
		fwrite(&size, sizeof(int), 1, file);

		// characters
		map <unsigned int, MCharacter>::iterator
			mit (characters->begin()),
			mend(characters->end());

		for(;mit!=mend;++mit)
		{
			unsigned int charCode = mit->first;
			MCharacter * character = &mit->second;

			MVector2 pos = character->getPos();
			MVector2 offset = character->getOffset();
			MVector2 scale = character->getScale();
			float xadvance = character->getXAdvance();

			fwrite(&charCode, sizeof(int), 1, file);
			fwrite(&pos, sizeof(float), 2, file);
			fwrite(&offset, sizeof(float), 2, file);
			fwrite(&scale, sizeof(float), 2, file);
			fwrite(&xadvance, sizeof(float), 1, file);
		}
	}

	fclose(file);
	return true;
}
예제 #9
0
bool M_loadFont(const char * filename, void * data, void * arg)
{
	MFont * font = (MFont *)data;
	
	int pen_x, pen_y, max_y;
	unsigned int n, max_code = 4096;
	unsigned int size = font->getFontSize();
	unsigned int space = 2;
	unsigned int width = 1024;
	unsigned int height = 0;

	MImage image;

	FT_GlyphSlot slot;
	FT_Library library;
	FT_Face face;
	FT_Byte * file_base;
	FT_Long file_size;


	// init
	FT_Error error = FT_Init_FreeType(&library); 
	if(error){
		printf("ERROR Load Font : unable to init FreeType\n");
		return false;
	}
	
	
	// open file
	MFile * file = M_fopen(filename, "rb");
	if(! file)
	{
		FT_Done_FreeType(library);
		printf("ERROR Load Font : can't read file %s\n", filename);
		return false;
	}
	
	M_fseek(file, 0, SEEK_END);
	file_size = M_ftell(file);
	M_rewind(file);
	
	file_base = new FT_Byte[file_size];
	if(file_size != M_fread(file_base, sizeof(FT_Byte), file_size, file))
	{
		M_fclose(file);
		FT_Done_FreeType(library);
		delete [] file_base;
		return false;
	}
	
	
	// read font
	error = FT_New_Memory_Face(library, file_base, file_size, 0, &face);
	M_fclose(file);
	
	if(error)
	{
		printf("ERROR Load Font : unable to read data %s\n", filename);
		FT_Done_FreeType(library);
		delete [] file_base;
		return false;
	}

	// set font size
	error = FT_Set_Pixel_Sizes(face, 0, size);
	if(error)
	{
		printf("ERROR Load Font : unable to size font\n");
		FT_Done_FreeType(library);
		delete [] file_base;
		return false;
	}


	// parse characters
	max_y = 0;
	slot = face->glyph;
	pen_x = space; pen_y = space; 
	for(n = 0; n<max_code; n++)
	{
		// load glyph image into the slot (erase previous one)
		error = FT_Load_Char(face, n, FT_LOAD_RENDER | FT_LOAD_NO_HINTING); 

		if(error)
			continue;

		if(FT_Get_Char_Index(face, n) == 0)
			continue;

		// max y
		max_y = MAX(max_y, slot->bitmap.rows);

		if((pen_x + slot->bitmap.width + space) > width)
		{
			pen_x = space;
			pen_y += max_y + space;
			height += max_y + space;
			max_y = 0;
		}

		// increment pen position 
		pen_x += slot->bitmap.width + space; 
	}

	if(height == 0)
	{
		printf("ERROR Load Font : unable to create font texture\n");
		FT_Done_FreeType(library);
		delete [] file_base;
		return false;
	}


	// create image
	height = getNextPowerOfTwo(height);
	image.create(M_UBYTE, width, height, 4);
	memset(image.getData(), 0, image.getSize()*sizeof(char));


	// init font
	font->setTextureWidth(width);
	font->setTextureHeight(height);


	// create font texture
	max_y = 0;
	slot = face->glyph;
	pen_x = space; pen_y = space; 
	for(n = 0; n<max_code; n++)
	{
		// load glyph image into the slot (erase previous one)
		error = FT_Load_Char(face, n, FT_LOAD_RENDER | FT_LOAD_NO_HINTING);

		if(error) 
			continue;

		if(FT_Get_Char_Index(face, n) == 0)
			continue;

		// max y
		max_y = MAX(max_y, slot->bitmap.rows);
		
		if((pen_x + slot->bitmap.width + space) > (int)image.getWidth()){
			pen_x = space;
			pen_y += max_y + space;
		}

		// get character properties
		float xAdvance = (slot->advance.x >> 6) / ((float)size);
		MVector2 offset = MVector2((float)slot->bitmap_left - 1, - (float)slot->bitmap_top - 1) / ((float)size);
		MVector2 pos = MVector2((float)(pen_x-1) / (float)width, (float)(pen_y-1) / (float)height);
		MVector2 scale = MVector2((float)(slot->bitmap.width+2) / (float)width, (float)(slot->bitmap.rows+2) / (float)height);

		// set character
		font->setCharacter(n, MCharacter(xAdvance, offset, pos, scale));

		// draw to image
		drawBitmap(&image, &slot->bitmap, pen_x, pen_y);

		// increment pen position 
		pen_x += slot->bitmap.width + space; 
	} 


	// send texture
	MEngine * engine = MEngine().getInstance();
	MRenderingContext * render = engine->getRenderingContext();
	
	// gen texture id
	unsigned int textureId = font->getTextureId();
	if(textureId == 0)
	{
		render->createTexture(&textureId);
		font->setTextureId(textureId);
	}
	
	// send texture image
	render->bindTexture(textureId);
	render->setTextureUWrapMode(M_WRAP_REPEAT);
	render->setTextureVWrapMode(M_WRAP_REPEAT);
	render->sendTextureImage(&image, 0, 1, 0);

	// finish
	FT_Done_FreeType(library);
	delete [] file_base;
	return true;
}
예제 #10
0
파일: main.cpp 프로젝트: mconbere/Newt
// main
int main(int argc, char **argv)
{
	setlocale(LC_NUMERIC, "C");


	// get engine (first time call onstructor)
	MEngine * engine = MEngine::getInstance();

	// get window (first time call onstructor)
	MWindow * window = MWindow::getInstance();

	// create window
	window->create("Maratis", 1024,768, 32, false);

	// set current directory
	char rep[256];
	getRepertory(rep, argv[0]);
	window->setCurrentDirectory(rep);

	// get Maratis (first time call onstructor)
	Maratis * maratis = Maratis::getInstance();
	MRenderingContext * render = engine->getRenderingContext();

	// init gui
	MGui * gui = MGui::getInstance();
	gui->setRenderingContext(render);
	gui->addFont(new MGuiTextureFont("font/default.tga"));

	// init MaratisUI
	window->setPointerEvent(MaratisUI::windowEvents);

	// logo
	{
		MImage image;
		if(! M_loadImage("gui/Title.png", &image))
			return 0;

		render->createTexture(&logoTextureId);
		render->bindTexture(logoTextureId);
		render->sendTextureImage(&image, false, false, false);

		// clear window
		draw();

		MGuiText text("LOADING", MVector2(480, 280), 16, MVector4(1, 1, 1, 1));
		text.draw();

		window->swapBuffer();
	}

	// load project
	if(argc > 1)
    {
		maratis->loadProject(argv[1]);
	}

	// time
	unsigned int frequency = 60;
	unsigned long previousFrame = 0;
	unsigned long startTick = window->getSystemTick();

	int f = 0;
	int t = 0;
	
	
	// on events
	while(window->isActive())
	{
		// on events
		if(window->onEvents())
		{
			// compute target tick
			unsigned long currentTick = window->getSystemTick();

			unsigned long tick = currentTick - startTick;
			unsigned long frame = (unsigned long)(tick * (frequency * 0.001f));

			// update elapsed time
			unsigned int i;
			unsigned int steps = (unsigned int)(frame - previousFrame);

			if(window->getFocus())
			{
				// don't wait too much
				if(steps >= (frequency/2))
				{
					update();
					draw();
					previousFrame += steps;
					continue;
				}
				
				// update
				for(i=0; i<steps; i++)
				{
					update();
					previousFrame++;
					t++;
					if(t == frequency)
					{
						MGame * game = engine->getGame();
						if(game)
						{
							if(! game->isRunning())
								MFilesUpdate::update();
						}
						else
						{
							MFilesUpdate::update();
						}

						//printf("fps:%d\n", f);
						t = 0;
						f = 0;
					}
				}

				// draw
				//if(steps > 0)
				{
					draw();
					f++;
				}
			}
			else
			{
				previousFrame = frame;
				window->swapBuffer();
			}
		}
	}

	gui->clear();
	maratis->clear();
	return 0;
}
예제 #11
0
bool M_loadBinFont(const char * filename, void * data)
{
	// open file
	FILE * file = fopen(filename, "rb");
	if(! file)
	{
		printf("Error : can't read file %s\n", filename);
		return false;
	}

	// bin
	char header[8];
	fread(header, sizeof(char), 8, file);

	if(strcmp(header, "MFONT") != 0)
		return false;

	// version
	int version;
	fread(&version, sizeof(int), 1, file);

	// font size
	unsigned int fontSize;
	fread(&fontSize, sizeof(int), 1, file);

	// init font
	MFont * font = (MFont *)data;
	font->setFontSize(fontSize);


	// create image
	{
		unsigned int width, height;
		fread(&width, sizeof(int), 1, file);
		fread(&height, sizeof(int), 1, file);

		font->setTextureWidth(width);
		font->setTextureHeight(height);

		MImage image;
		image.create(M_UBYTE, width, height, 4);

		unsigned char color[4] = {255, 255, 255, 0};
		unsigned int x, y;
		for(y=0; y<height; y++)
		{
			for(x=0; x<width; x++)
			{
				fread(&color[3], sizeof(char), 1, file);
				image.writePixel(x, y, color);
			}
		}

		MEngine * engine = MEngine().getInstance();
		MRenderingContext * render = engine->getRenderingContext();
		
		// gen texture id
		unsigned int textureId = font->getTextureId();
		if(textureId == 0)
		{
			render->createTexture(&textureId);
			font->setTextureId(textureId);
		}

		// send texture image
		render->bindTexture(textureId);
		render->setTextureUWrapMode(M_WRAP_REPEAT);
		render->setTextureVWrapMode(M_WRAP_REPEAT);
		render->sendTextureImage(&image, 0, 1, 0);
	}

	// read characters infos
	{
		// size
		unsigned int size;
		fread(&size, sizeof(int), 1, file);

		// characters
		unsigned int i;
		for(i=0; i<size; i++)
		{
			unsigned int charCode;
			MVector2 pos;
			MVector2 offset;
			MVector2 scale;
			float xadvance;

			fread(&charCode, sizeof(int), 1, file);
			fread(&pos, sizeof(float), 2, file);
			fread(&offset, sizeof(float), 2, file);
			fread(&scale, sizeof(float), 2, file);
			fread(&xadvance, sizeof(float), 1, file);

			font->setCharacter(charCode, MCharacter(xadvance, offset, pos, scale));
		}
	}

	fclose(file);
	return true;
}