void MOCamera::enable(void)
{
MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
// get viewport
render->getViewport(m_currentViewport);
// projection mode
render->setMatrixMode(M_MATRIX_PROJECTION);
render->loadIdentity();
float ratio = (m_currentViewport[2] / (float)m_currentViewport[3]);
MVector3 scale = getTransformedScale();
MVector3 iScale(1.0f / scale.x, 1.0f / scale.y, 1.0f / scale.z);
MMatrix4x4 iScaleMatrix;
iScaleMatrix.setScale(iScale);
MMatrix4x4 inverseMatrix = ((*getMatrix()) * iScaleMatrix).getInverse();
// perspective view
if(! isOrtho())
{
// normal perspective projection
render->setPerspectiveView(m_fov, ratio, m_clippingNear, m_clippingFar);
// model view mode
render->setMatrixMode(M_MATRIX_MODELVIEW);
render->loadIdentity();
render->multMatrix(&inverseMatrix);
// get current matrices
render->getModelViewMatrix(&m_currentViewMatrix);
render->getProjectionMatrix(&m_currentProjMatrix);
return;
}
// ortho view
float height = m_fov * 0.5f;
float width = height * ratio;
render->setOrthoView(-width, width, -height, height, m_clippingNear, m_clippingFar);
// model view mode
render->setMatrixMode(M_MATRIX_MODELVIEW);
render->loadIdentity();
render->multMatrix(&inverseMatrix);
// get current matrices
render->getModelViewMatrix(&m_currentViewMatrix);
render->getProjectionMatrix(&m_currentProjMatrix);
}
void MOCamera::enableViewProjMatrix(void)
{
MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
// projection
render->setMatrixMode(M_MATRIX_PROJECTION);
render->loadIdentity();
render->multMatrix(&m_currentProjMatrix);
// model view mode
render->setMatrixMode(M_MATRIX_MODELVIEW);
render->loadIdentity();
render->multMatrix(&m_currentViewMatrix);
}
void Flush()
{
g_CurrentColour.set(255, 255, 255, 255);
if(g_Cnt == 0) return;
MEngine* engine = MEngine::getInstance();
MRenderingContext* render = engine->getRenderingContext();
MSystemContext* system = engine->getSystemContext();
unsigned int w, h;
system->getScreenSize(&w, &h);
// set up the "camera"
render->setViewport(0, 0, w, h);
render->setMatrixMode(M_MATRIX_PROJECTION);
render->loadIdentity();
render->setOrthoView(0, w, h, 0, 1.0f, -1.0f);
render->setMatrixMode(M_MATRIX_MODELVIEW);
render->loadIdentity();
// set up arrays
render->enableVertexArray();
render->enableTexCoordArray();
render->enableColorArray();
render->setVertexPointer(M_FLOAT, 3, g_Vertices);
render->setTexCoordPointer(M_FLOAT, 2, g_UVs);
render->setColorPointer(M_UBYTE, 4, g_Colours);
render->disableCullFace();
render->disableDepthTest();
render->drawArray(M_PRIMITIVE_TRIANGLES, 0, g_Cnt * 6);
g_Cnt = 0;
g_Selected = NULL;
}
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();
}
}