//constructor
MGuiWindow::MGuiWindow(const MVector2 & position, const MVector2 & scale, const MVector4 & color, void (* pointerEvent)(MGuiWindow * window, MGuiEvent * guiEvent)):
m_breakEvents(false),
m_margin(10, 10),
m_isScrolled(false),
m_scroll(0, 0),
m_minScroll(0, 0),
m_maxScroll(0, 0),
m_hScrollSlide(MVector2(0, scale.y-6), MVector2(50, 6), MVector4(1, 1, 1, 0.3f), NULL),
m_vScrollSlide(MVector2(scale.x-6, 0), MVector2(6, 50), MVector4(1, 1, 1, 0.3f), NULL)
{
m_hScrollSlide.setParentWindow(this);
m_vScrollSlide.setParentWindow(this);
setParentWindow(NULL);
setPosition(position);
setScale(scale);
setNormalColor(color);
setPointerEvent(pointerEvent);
// horizontal slide
m_hScrollSlide.setScrollAffect(false);
m_hScrollSlide.setMinValue(0);
m_hScrollSlide.setMaxValue(1);
// vertical slide
m_vScrollSlide.setScrollAffect(false);
m_vScrollSlide.setMinValue(0);
m_vScrollSlide.setMaxValue(1);
resizeScroll();
}
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 beginDraw(M_PRIMITIVE_TYPES primitiveType)
{
g_verticesNumber = 0;
g_primitiveType = primitiveType;
renderColors = false;
renderTexcoords = false;
previousColor = MVector4(1, 1, 1, 1);
previousTexcoords = MVector2(0, 0);
}
MVector3 MOCamera::getProjectedPoint(const MVector3 & point) const
{
MVector4 v = m_currentViewMatrix * MVector4(point);
v = m_currentProjMatrix * v;
v.x = v.x / v.w;
v.y = v.y / v.w;
v.z = v.z / v.w;
v.x = m_currentViewport[0] + (m_currentViewport[2] * ((v.x + 1) / 2.0f));
v.y = m_currentViewport[1] + (m_currentViewport[3] * ((v.y + 1) / 2.0f));
v.z = (v.z + 1) / 2.0f;
return MVector3(v.x, v.y, v.z);
}
// draw
void draw(void)
{
MMouse * mouse = MMouse::getInstance();
MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
Maratis::getInstance()->graphicLoop();
if(logo)
{
set2dMode(render);
render->setBlendingMode(M_BLENDING_ALPHA);
render->enableTexture();
render->setColor4(MVector4(1.0f));
drawLogo();
}
if(mouse->isLeftButtonPushed() || mouse->isMiddleButtonPushed() || (mouse->getWheelDirection() != 0))
logo = false;
MWindow::getInstance()->swapBuffer();
}
MGuiFileBrowser::MGuiFileBrowser(const MVector2 & position, const MVector2 & scale)
{
m_fileButtonsWidth = 150;
m_fileButtonsHeight = 18;
m_browserHeight = 18;
m_margin = 3;
m_headWinColor = MVector4(0.2f, 0.3f, 0.4f, 1.0f);
m_mainWinColor = MVector4(0.15f, 0.15f, 0.15f, 1.0f);
m_filesWinColor = MVector4(0.4f, 0.6f, 0.8f, 0.3f);
m_headTextColor = MVector4(0.0f, 0.0f, 0.0f, 1.0f);
m_browserTextColor = MVector4(1, 1, 1, 0.75f);
m_buttonColor = MVector4(0.4f, 0.6f, 0.8f, 0.75f);
m_highButtonColor = MVector4(0.8, 0.9f, 1.0f, 0.75f);
m_pressButtonColor = MVector4(1.0, 1.0f, 0.5f, 1.0f);
m_headWin = new MGuiWindow(
position,
MVector2(scale.x, m_fileButtonsHeight*2 + m_margin*3),
m_headWinColor,
NULL
);
m_dirWin = new MGuiWindow(
position + MVector2(m_margin),
MVector2(scale.x - m_fileButtonsWidth - m_margin*3, m_fileButtonsHeight),
m_filesWinColor,
NULL
);
m_dirWin->setScrollBarVisible(false);
m_fileWin = new MGuiWindow(
position + MVector2(m_margin) + MVector2(0, m_fileButtonsHeight + m_margin),
MVector2(scale.x - m_fileButtonsWidth - m_margin*3, m_fileButtonsHeight),
m_filesWinColor,
NULL
);
m_fileWin->setScrollBarVisible(false);
m_mainWin = new MGuiWindow(
position + MVector2(0, m_headWin->getScale().y),
MVector2(scale.x, scale.y - m_headWin->getScale().y),
m_mainWinColor,
mainWinEvents
);
m_mainWin->setMargin(MVector2(0.0f));
m_mainWin->setCustomVariable(this);
// head texts and buttons
{
m_dirEditText = new MGuiEditText("", MVector2(1, 1), 16, m_headTextColor, dirEditTextEvents);
m_dirEditText->enableVariable(&m_currentDirectory, M_VAR_STRING);
m_dirEditText->setSingleLine(true);
m_dirEditText->setCustomVariable(this);
m_dirWin->addEditText(m_dirEditText);
m_fileEditText = new MGuiEditText("", MVector2(1, 1), 16, m_headTextColor, NULL);
m_fileEditText->enableVariable(&m_currentFile, M_VAR_STRING);
m_fileEditText->setSingleLine(true);
m_fileWin->addEditText(m_fileEditText);
m_okButton = new MGuiButton(
MVector2(m_dirWin->getScale().x + m_margin*2, m_margin),
MVector2(m_fileButtonsWidth, m_fileButtonsHeight),
m_buttonColor,
fileBrowserOkButtonEvents
);
m_okButton->setCenterText(true);
m_okButton->setAutoScaleFromText(false);
m_okButton->setTextColor(MVector4(0, 0, 0, 1));
m_okButton->setText("ok");
m_okButton->setHighLightColor(m_highButtonColor);
m_okButton->setPressedColor(m_pressButtonColor);
m_okButton->setCustomVariable(this);
m_headWin->addButton(m_okButton);
m_cancelButton = new MGuiButton(
MVector2(m_dirWin->getScale().x + m_margin*2, m_margin*2 + m_fileButtonsHeight),
MVector2(m_fileButtonsWidth, m_fileButtonsHeight),
m_buttonColor,
fileBrowserCancelButtonEvents
);
m_cancelButton->setCenterText(true);
m_cancelButton->setAutoScaleFromText(false);
m_cancelButton->setTextColor(MVector4(0, 0, 0, 1));
m_cancelButton->setText("cancel");
m_cancelButton->setHighLightColor(m_highButtonColor);
m_cancelButton->setPressedColor(m_pressButtonColor);
m_cancelButton->setCustomVariable(this);
m_headWin->addButton(m_cancelButton);
}
m_headWin->setVisible(false);
m_dirWin->setVisible(false);
m_fileWin->setVisible(false);
m_mainWin->setVisible(false);
MGui * gui = MGui::getInstance();
gui->addWindow(m_headWin);
gui->addWindow(m_dirWin);
gui->addWindow(m_fileWin);
gui->addWindow(m_mainWin);
}
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::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::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();
}
}
void MGLContext::setFogColor(const MVector3 & color)
{
glFogfv(GL_FOG_COLOR, MVector4(color));
m_fogColor = color;
}
// 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;
}
