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;
}
}
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);
}
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
}
}
}
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;
}
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);
}
}
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;
}
}
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(¤tFogColor);
// 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();
}
}
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;
}
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;
}
// 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;
}
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;
}