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 endDraw(void)
{
MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
render->disableTexCoordArray();
render->disableColorArray();
render->disableNormalArray();
render->enableVertexArray();
render->setVertexPointer(M_FLOAT, 3, g_vertices);
render->drawArray(g_primitiveType, 0, g_verticesNumber);
}
void MGuiTextureFont::drawSelection(const char * text, const MVector2 & position, float size, unsigned int startId, unsigned int endId)
{
MRenderingContext * render = MGui::getInstance()->getRenderingContext();
if(startId == endId)
return;
MVector2 g_vertices[4];
render->disableNormalArray();
render->disableColorArray();
render->disableTexCoordArray();
render->enableVertexArray();
render->setVertexPointer(M_FLOAT, 2, g_vertices);
unsigned int start;
unsigned int end;
if(endId > startId)
{
start = startId;
end = endId;
}
else
{
start = endId;
end = startId;
}
render->disableTexture();
MVector2 startPosition = getCharacterPosition(text, position, size, start);
float xc = startPosition.x;
float yc = startPosition.y;
float offset = (size - (size*getSpace()))*0.5f;
// left quad
g_vertices[0] = MVector2(xc+offset, yc);
g_vertices[1] = MVector2(xc+offset, yc+size);
unsigned int i;
unsigned int textLength = strlen(text);
for(i=start; i<end && i<textLength; i++)
{
if(text[i] == '\n') // return
{
// right quad
{
g_vertices[3] = MVector2(xc+size*0.5f, yc+size);
g_vertices[2] = MVector2(xc+size*0.5f, yc);
render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);
}
yc += size;
xc = position.x;
// left quad
{
g_vertices[0] = MVector2(xc+offset, yc);
g_vertices[1] = MVector2(xc+offset, yc+size);
}
}
else if(text[i] == ' ') // tab
{
xc += size * getTabSpace();
if(i+1 == end || i+1 == textLength)
{
// right quad
g_vertices[3] = MVector2(xc+offset, yc+size);
g_vertices[2] = MVector2(xc+offset, yc);
render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);
}
}
else
{
xc += size * getSpace(); //move to next character
if(i+1 == end || i+1 == textLength)
{
// right quad
g_vertices[3] = MVector2(xc+offset, yc+size);
g_vertices[2] = MVector2(xc+offset, yc);
render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);
}
}
}
}
void MGuiEditText::draw(void)
{
MRenderingContext * render = MGui::getInstance()->getRenderingContext();
if(! isVisible())
return;
if(! isPressed())
updateFromVariable();
// draw selection
if(isPressed())
{
render->disableTexture();
render->setColor4(MVector4(1, 0.1f, 0.1f, 0.3f));
getFont()->drawSelection(getText(), getPosition(), getTextSize(), m_startSelectionId, m_endSelectionId);
}
// set text color
if(isPressed()){
render->setColor4(getPressedColor());
}
else if(isHighLight()){
render->setColor4(getHighLightColor());
}
else{
render->setColor4(getNormalColor());
}
// draw text
render->enableTexture();
getFont()->draw(getText(), getPosition(), getTextSize());
if(isPressed() && (m_startSelectionId == m_endSelectionId)) // cursor
{
render->disableTexture();
render->setColor4(MVector4(1, 0, 0, 0.5f));
// position
MVector2 position = getFont()->getCharacterPosition(
getText(),
getPosition(),
getTextSize(),
getCharId()
);
// scale
MVector2 scale = MVector2(getTextSize() * 0.1f, getTextSize());
float offset = (getTextSize() - (getTextSize()*getFont()->getSpace()))*0.5f;
float px = (float)((int)(position.x + offset));
float py = (float)((int)position.y);
// draw
render->disableNormalArray();
render->disableTexCoordArray();
render->disableColorArray();
render->enableVertexArray();
MVector2 vertices[4] = {
MVector2(px, py),
MVector2(px, py + scale.y),
MVector2(px + scale.x, py),
MVector2(px + scale.x, py + scale.y)
};
render->setVertexPointer(M_FLOAT, 2, vertices);
render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);
}
MGuiEvent guiEvent;
guiEvent.type = MGUI_EVENT_DRAW;
if(m_pointerEvent)
m_pointerEvent(this, &guiEvent);
}
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();
}
}