void MGui2d::drawShadow(void)
{
MRenderingContext * render = MGui::getInstance()->getRenderingContext();
MVector2 g_vertices[8];
MVector4 g_colors[8];
render->disableTexture();
render->enableBlending();
render->setBlendingMode(M_BLENDING_ALPHA);
MVector4 color0 = MVector4(0, 0, 0, 0);
MVector4 color1 = MVector4(0, 0, 0, 0.05f);
float size = 4;
MVector2 dir[4];
dir[0] = MVector2(size, size*0.4f);
dir[1] = MVector2(size*0.4f, size);
dir[2] = MVector2(size*0.4f, size*0.1f);
dir[3] = MVector2(size*0.1f, size*0.4f);
render->disableNormalArray();
render->disableTexCoordArray();
render->enableVertexArray();
render->enableColorArray();
render->setVertexPointer(M_FLOAT, 2, g_vertices);
render->setColorPointer(M_FLOAT, 4, g_colors);
for(int i=0; i<4; i++)
{
g_colors[0] = color1;
g_vertices[0] = MVector2(0, m_scale.y) + MVector2(dir[i].x, 0);
g_colors[1] = color0;
g_vertices[1] = MVector2(0, m_scale.y) + MVector2(size, size) + dir[i];
g_colors[2] = color1;
g_vertices[2] = MVector2(m_scale.x, m_scale.y);
g_colors[3] = color0;
g_vertices[3] = MVector2(m_scale.x, m_scale.y) + MVector2(size, size) + dir[i];
g_colors[4] = color1;
g_vertices[4] = MVector2(m_scale.x, 0) + MVector2(0, dir[i].y);
g_colors[5] = color0;
g_vertices[5] = MVector2(m_scale.x, 0) + MVector2(size, size) + dir[i];
render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 6);
}
}
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 MFixedRenderer::drawScene(MScene * scene, MOCamera * camera)
{
M_PROFILE_SCOPE(MFixedRenderer::drawScene);
struct MEntityLight
{
MBox3d lightBox;
MOLight * light;
};
struct MSubMeshPass
{
unsigned int subMeshId;
unsigned int lightsNumber;
MObject3d * object;
MOLight * lights[4];
};
// sub objects
#define MAX_TRANSP_SUBOBJ 4096
static int transpList[MAX_TRANSP_SUBOBJ];
static float transpZList[MAX_TRANSP_SUBOBJ];
static MSubMeshPass transpSubObjs[MAX_TRANSP_SUBOBJ];
// lights list
#define MAX_ENTITY_LIGHTS 256
static int entityLightsList[MAX_ENTITY_LIGHTS];
static float entityLightsZList[MAX_ENTITY_LIGHTS];
static MEntityLight entityLights[MAX_ENTITY_LIGHTS];
// get render
MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
render->enableLighting();
render->enableBlending();
// make frustum
MFrustum * frustum = camera->getFrustum();
frustum->makeVolume(camera);
// update visibility
updateVisibility(scene, camera);
// fog
enableFog(camera);
// camera
MVector3 cameraPos = camera->getTransformedPosition();
// transp sub obj number
unsigned int transpSubObsNumber = 0;
// lights
unsigned int l;
unsigned int lSize = scene->getLightsNumber();
// entities
unsigned int i;
unsigned int eSize = scene->getEntitiesNumber();
for(i=0; i<eSize; i++)
{
// get entity
MOEntity * entity = scene->getEntityByIndex(i);
MMesh * mesh = entity->getMesh();
if(! entity->isActive())
continue;
if(! entity->isVisible())
{
if(mesh)
{
MArmature * armature = mesh->getArmature();
MArmatureAnim * armatureAnim = mesh->getArmatureAnim();
if(armature)
{
// animate armature
if(armatureAnim)
animateArmature(
mesh->getArmature(),
mesh->getArmatureAnim(),
entity->getCurrentFrame()
);
// TODO : optimize and add a tag to desactivate it
updateSkinning(mesh, armature);
(*entity->getBoundingBox()) = (*mesh->getBoundingBox());
}
}
continue;
}
// draw mesh
if(mesh)
{
MVector3 scale = entity->getTransformedScale();
MBox3d * entityBox = entity->getBoundingBox();
float minScale = scale.x;
minScale = MIN(minScale, scale.y);
minScale = MIN(minScale, scale.z);
minScale = 1.0f / minScale;
unsigned int entityLightsNumber = 0;
for(l=0; l<lSize; l++)
{
// get entity
MOLight * light = scene->getLightByIndex(l);
if(! light->isActive())
continue;
if(! light->isVisible())
continue;
// light box
MVector3 lightPos = light->getTransformedPosition();
MVector3 localPos = entity->getInversePosition(lightPos);
float localRadius = light->getRadius() * minScale;
MBox3d lightBox(
MVector3(localPos - localRadius),
MVector3(localPos + localRadius)
);
if(! entityBox->isInCollisionWith(&lightBox))
continue;
MEntityLight * entityLight = &entityLights[entityLightsNumber];
entityLight->lightBox = lightBox;
entityLight->light = light;
entityLightsNumber++;
if(entityLightsNumber == MAX_ENTITY_LIGHTS)
break;
}
// animate armature
if(mesh->getArmature() && mesh->getArmatureAnim())
animateArmature(
mesh->getArmature(),
mesh->getArmatureAnim(),
entity->getCurrentFrame()
);
// animate textures
if(mesh->getTexturesAnim())
animateTextures(mesh, mesh->getTexturesAnim(), entity->getCurrentFrame());
// animate materials
if(mesh->getMaterialsAnim())
animateMaterials(mesh, mesh->getMaterialsAnim(), entity->getCurrentFrame());
unsigned int s;
unsigned int sSize = mesh->getSubMeshsNumber();
for(s=0; s<sSize; s++)
{
MSubMesh * subMesh = &mesh->getSubMeshs()[s];
MBox3d * box = subMesh->getBoundingBox();
// check if submesh visible
if(sSize > 1)
{
MVector3 * min = box->getMin();
MVector3 * max = box->getMax();
MVector3 points[8] = {
entity->getTransformedVector(MVector3(min->x, min->y, min->z)),
entity->getTransformedVector(MVector3(min->x, max->y, min->z)),
entity->getTransformedVector(MVector3(max->x, max->y, min->z)),
entity->getTransformedVector(MVector3(max->x, min->y, min->z)),
entity->getTransformedVector(MVector3(min->x, min->y, max->z)),
entity->getTransformedVector(MVector3(min->x, max->y, max->z)),
entity->getTransformedVector(MVector3(max->x, max->y, max->z)),
entity->getTransformedVector(MVector3(max->x, min->y, max->z))
};
if(! frustum->isVolumePointsVisible(points, 8))
continue;
}
// subMesh center
MVector3 center = (*box->getMin()) + ((*box->getMax()) - (*box->getMin()))*0.5f;
center = entity->getTransformedVector(center);
// sort entity lights
unsigned int lightsNumber = 0;
for(l=0; l<entityLightsNumber; l++)
{
MEntityLight * entityLight = &entityLights[l];
if(! box->isInCollisionWith(&entityLight->lightBox))
continue;
MOLight * light = entityLight->light;
float z = (center - light->getTransformedPosition()).getLength();
entityLightsList[lightsNumber] = l;
entityLightsZList[l] = (1.0f/z)*light->getRadius();
lightsNumber++;
}
if(lightsNumber > 1)
sortFloatList(entityLightsList, entityLightsZList, 0, (int)lightsNumber-1);
// local lights
if(lightsNumber > 4)
lightsNumber = 4;
for(l=0; l<lightsNumber; l++)
{
MEntityLight * entityLight = &entityLights[entityLightsList[l]];
MOLight * light = entityLight->light;
// attenuation
float quadraticAttenuation = (8.0f / light->getRadius());
quadraticAttenuation = (quadraticAttenuation*quadraticAttenuation)*light->getIntensity();
// color
MVector3 color = light->getFinalColor();
// set light
render->enableLight(l);
render->setLightPosition(l, light->getTransformedPosition());
render->setLightDiffuse(l, MVector4(color));
render->setLightSpecular(l, MVector4(color));
render->setLightAmbient(l, MVector3(0, 0, 0));
render->setLightAttenuation(l, 1, 0, quadraticAttenuation);
// spot
render->setLightSpotAngle(l, light->getSpotAngle());
if(light->getSpotAngle() < 90){
render->setLightSpotDirection(l, light->getRotatedVector(MVector3(0, 0, -1)).getNormalized());
render->setLightSpotExponent(l, light->getSpotExponent());
}
else {
render->setLightSpotExponent(l, 0.0f);
}
}
for(l=lightsNumber; l<4; l++){
render->disableLight(l);
}
render->pushMatrix();
render->multMatrix(entity->getMatrix());
// draw opaques
drawOpaques(subMesh, mesh->getArmature());
if(subMesh->hasTransparency())
{
if(transpSubObsNumber < MAX_TRANSP_SUBOBJ)
{
// transparent subMesh pass
MSubMeshPass * subMeshPass = &transpSubObjs[transpSubObsNumber];
// lights
subMeshPass->lightsNumber = lightsNumber;
for(l=0; l<lightsNumber; l++)
subMeshPass->lights[l] = entityLights[entityLightsList[l]].light;
// z distance to camera
float z = getDistanceToCam(camera, center);
// set values
transpList[transpSubObsNumber] = transpSubObsNumber;
transpZList[transpSubObsNumber] = z;
subMeshPass->subMeshId = s;
subMeshPass->object = entity;
transpSubObsNumber++;
}
}
render->popMatrix();
}
mesh->updateBoundingBox();
(*entity->getBoundingBox()) = (*mesh->getBoundingBox());
}
}
// texts
unsigned int tSize = scene->getTextsNumber();
for(i=0; i<tSize; i++)
{
MOText * text = scene->getTextByIndex(i);
if(text->isActive() && text->isVisible())
{
// transparent pass
MSubMeshPass * subMeshPass = &transpSubObjs[transpSubObsNumber];
// center
MBox3d * box = text->getBoundingBox();
MVector3 center = (*box->getMin()) + ((*box->getMax()) - (*box->getMin()))*0.5f;
center = text->getTransformedVector(center);
// z distance to camera
float z = getDistanceToCam(camera, center);
// set values
transpList[transpSubObsNumber] = transpSubObsNumber;
transpZList[transpSubObsNumber] = z;
subMeshPass->object = text;
transpSubObsNumber++;
}
}
// sort transparent list
if(transpSubObsNumber > 1)
sortFloatList(transpList, transpZList, 0, (int)transpSubObsNumber-1);
// draw transparents
for(i=0; i<transpSubObsNumber; i++)
{
MSubMeshPass * subMeshPass = &transpSubObjs[transpList[i]];
MObject3d * object = subMeshPass->object;
// objects
switch(object->getType())
{
case M_OBJECT3D_ENTITY:
{
MOEntity * entity = (MOEntity *)object;
unsigned int subMeshId = subMeshPass->subMeshId;
MMesh * mesh = entity->getMesh();
MSubMesh * subMesh = &mesh->getSubMeshs()[subMeshId];
// animate armature
if(mesh->getArmature() && mesh->getArmatureAnim())
animateArmature(
mesh->getArmature(),
mesh->getArmatureAnim(),
entity->getCurrentFrame()
);
// animate textures
if(mesh->getTexturesAnim())
animateTextures(mesh, mesh->getTexturesAnim(), entity->getCurrentFrame());
// animate materials
if(mesh->getMaterialsAnim())
animateMaterials(mesh, mesh->getMaterialsAnim(), entity->getCurrentFrame());
// lights
for(l=0; l<subMeshPass->lightsNumber; l++)
{
MOLight * light = subMeshPass->lights[l];
// attenuation
float quadraticAttenuation = (8.0f / light->getRadius());
quadraticAttenuation = (quadraticAttenuation*quadraticAttenuation)*light->getIntensity();
// color
MVector3 color = light->getFinalColor();
// set light
render->enableLight(l);
render->setLightPosition(l, light->getTransformedPosition());
render->setLightDiffuse(l, MVector4(color));
render->setLightSpecular(l, MVector4(color));
render->setLightAmbient(l, MVector3(0, 0, 0));
render->setLightAttenuation(l, 1, 0, quadraticAttenuation);
// spot
render->setLightSpotAngle(l, light->getSpotAngle());
if(light->getSpotAngle() < 90){
render->setLightSpotDirection(l, light->getRotatedVector(MVector3(0, 0, -1)).getNormalized());
render->setLightSpotExponent(l, light->getSpotExponent());
}
else {
render->setLightSpotExponent(l, 0.0f);
}
}
for(l=subMeshPass->lightsNumber; l<4; l++){
render->disableLight(l);
}
render->pushMatrix();
render->multMatrix(entity->getMatrix());
drawTransparents(subMesh, mesh->getArmature());
render->popMatrix();
mesh->updateBoundingBox();
(*entity->getBoundingBox()) = (*mesh->getBoundingBox());
}
break;
case M_OBJECT3D_TEXT:
{
MOText * text = (MOText *)object;
render->pushMatrix();
render->multMatrix(text->getMatrix());
drawText(text);
render->popMatrix();
}
break;
}
}
render->disableLighting();
render->disableFog();
}
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 MGuiWindow::draw(void)
{
MRenderingContext * render = MGui::getInstance()->getRenderingContext();
if(! isVisible())
return;
MWindow * window = MWindow::getInstance();
rescaleScrollingBar();
render->enableScissorTest();
render->setScissor((int)getPosition().x, window->getHeight() - (int)getPosition().y - (unsigned int)getScale().y, (unsigned int)getScale().x, (unsigned int)getScale().y);
// normal clear
if((getNormalColor().w >= 1.0f) && (! hasNormalTexture()))
{
render->setClearColor(getNormalColor());
render->clear(M_BUFFER_COLOR);
MGuiEvent guiEvent;
guiEvent.type = MGUI_EVENT_DRAW;
if(m_pointerEvent)
m_pointerEvent(this, &guiEvent);
// 2d mode
set2dMode(render);
render->disableDepthTest();
render->disableCullFace();
render->disableLighting();
render->enableBlending();
render->setBlendingMode(M_BLENDING_ALPHA);
render->enableTexture();
}
else
{
// background
set2dMode(render);
render->disableDepthTest();
render->disableCullFace();
render->disableLighting();
render->enableBlending();
render->setBlendingMode(M_BLENDING_ALPHA);
if(hasNormalTexture()) // texture clear
{
render->enableTexture();
render->setColor4(getNormalColor());
drawTexturedQuad(getNormalTexture());
}
else if(getNormalColor().w < 1.0f)
{
render->disableTexture();
render->setColor4(getNormalColor());
drawQuad();
}
if(m_pointerEvent)
{
MGuiEvent guiEvent;
guiEvent.type = MGUI_EVENT_DRAW;
m_pointerEvent(this, &guiEvent);
// 2d mode
set2dMode(render);
render->disableDepthTest();
render->disableCullFace();
render->disableLighting();
render->enableBlending();
render->setBlendingMode(M_BLENDING_ALPHA);
render->enableTexture();
}
}
// gui
render->pushMatrix();
render->translate(MVector3(getPosition().x, getPosition().y, 0));
render->pushMatrix();
render->translate(MVector3(getScroll().x, getScroll().y, 0));
// drawing
unsigned int i;
unsigned int oSize = m_objects.size();
for(i=0; i<oSize; i++)
m_objects[i]->draw();
render->popMatrix();
// draw shadows
if(hasShadow())
{
render->disableScissorTest();
drawShadow();
render->enableScissorTest();
}
// scolling slides
if(isHorizontalScroll())
m_hScrollSlide.draw();
if(isVerticalScroll())
m_vScrollSlide.draw();
render->popMatrix();
}
