/*!****************************************************************************
@Function RenderFloor
@Description Renders the floor as a quad.
******************************************************************************/
void OGLES2ParticleSystem::RenderFloor()
{
glUseProgram(m_SimpleShaderProgram.uiId);
PVRTMat3 mViewIT(m_mView.inverse().transpose());
glUniformMatrix4fv(m_SimpleShaderProgram.iModelViewProjectionMatrixLoc, 1, GL_FALSE, m_mViewProjection.f);
glUniformMatrix4fv(m_SimpleShaderProgram.iModelViewMatrixLoc, 1, GL_FALSE, m_mView.f);
glUniformMatrix3fv(m_SimpleShaderProgram.iModelViewITMatrixLoc, 1, GL_FALSE, mViewIT.f);
PVRTVec3 vLightPosition = m_mView * PVRTVec4(g_caLightPosition, 1.0f);
glUniform3fv(m_SimpleShaderProgram.iLightPosition, 1, &vLightPosition.x);
// Enable vertex arributes
glEnableVertexAttribArray(VERTEX_ARRAY);
glEnableVertexAttribArray(NORMAL_ARRAY);
PVRTVec2 minCorner(-100.0f, -100.0f);
PVRTVec2 maxCorner( 100.0f, 100.0f);
const float afVertexData[] = { minCorner.x, 0.0f, minCorner.y, maxCorner.x, 0.0f, minCorner.y,
minCorner.x, 0.0f, maxCorner.y, maxCorner.x, 0.0f, maxCorner.y };
const float afNormalData[] = { 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f };
glVertexAttribPointer(VERTEX_ARRAY, 3, GL_FLOAT, GL_FALSE, 0, afVertexData);
glVertexAttribPointer(NORMAL_ARRAY, 3, GL_FLOAT, GL_FALSE, 0, afNormalData);
// Draw the quad
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Safely disable the vertex attribute arrays
glDisableVertexAttribArray(VERTEX_ARRAY);
glDisableVertexAttribArray(NORMAL_ARRAY);
}
void ccGBLSensor::drawMeOnly(CC_DRAW_CONTEXT& context)
{
//we draw here a little 3d representation of the sensor
if (MACRO_Draw3D(context))
{
bool pushName = MACRO_DrawEntityNames(context);
if (pushName)
{
//not particulary fast
if (MACRO_DrawFastNamesOnly(context))
return;
glPushName(getUniqueIDForDisplay());
}
//DGM FIXME: this display routine is crap!
//apply rigid transformation
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
{
ccIndexedTransformation sensorPos;
if (!getAbsoluteTransformation(sensorPos,m_activeIndex))
{
//no visible position for this index!
glPopMatrix();
if (pushName)
glPopName();
return;
}
glMultMatrixf(sensorPos.data());
}
//test: center as sphere
/*{
ccSphere sphere(m_scale/10,0,"Center",12);
sphere.showColors(true);
sphere.setVisible(true);
sphere.setEnabled(true);
CC_DRAW_CONTEXT sphereContext = context;
sphereContext.flags &= (~CC_DRAW_ENTITY_NAMES); //we must remove the 'push name flag' so that the sphere doesn't push its own!
sphereContext._win = 0;
sphere.setTempColor(ccColor::magenta);
sphere.draw(sphereContext);
}
//*/
const PointCoordinateType halfHeadSize = static_cast<PointCoordinateType>(0.3);
//sensor axes
{
//increased width
glPushAttrib(GL_LINE_BIT);
GLfloat width;
glGetFloatv(GL_LINE_WIDTH,&width);
glLineWidth(width+1);
PointCoordinateType axisLength = halfHeadSize * m_scale;
ccGL::Color3v(ccColor::red.rgba);
CCVector3 C(0,0,0);
glBegin(GL_LINES);
ccGL::Vertex3v(C.u);
ccGL::Vertex3(C.x+axisLength,C.y,C.z);
glEnd();
ccGL::Color3v(ccColor::green.rgba);
glBegin(GL_LINES);
ccGL::Vertex3v(C.u);
ccGL::Vertex3(C.x,C.y+axisLength,C.z);
glEnd();
ccGL::Color3v(ccColor::blue.rgba);
glBegin(GL_LINES);
ccGL::Vertex3v(C.u);
ccGL::Vertex3(C.x,C.y,C.z+axisLength);
glEnd();
glPopAttrib();
}
//sensor head
{
CCVector3 minCorner(-halfHeadSize,-halfHeadSize,-halfHeadSize);
CCVector3 maxCorner( halfHeadSize, halfHeadSize, halfHeadSize);
minCorner *= m_scale;
maxCorner *= m_scale;
ccBBox bbHead(minCorner,maxCorner);
bbHead.draw(m_color);
}
//sensor legs
{
CCVector3 headConnect = /*headCenter*/ - CCVector3(0,0,static_cast<PointCoordinateType>(halfHeadSize)*m_scale);
ccGL::Color3v(m_color.rgb);
glBegin(GL_LINES);
ccGL::Vertex3v(headConnect.u);
ccGL::Vertex3(-m_scale,-m_scale,-m_scale);
ccGL::Vertex3v(headConnect.u);
ccGL::Vertex3(-m_scale,m_scale,-m_scale);
ccGL::Vertex3v(headConnect.u);
ccGL::Vertex3(m_scale,0,-m_scale);
glEnd();
}
if (pushName)
glPopName();
glPopMatrix();
}
}
/** Transforms an AABB by the given matrix and returns it into the \p out parameter. */
void transformed(AABB& out, const mat4& mat) const
{
out.setNull();
if ( !isNull() )
{
out.addPoint( mat * vec3(minCorner().x(), minCorner().y(), minCorner().z()) );
out.addPoint( mat * vec3(minCorner().x(), maxCorner().y(), minCorner().z()) );
out.addPoint( mat * vec3(maxCorner().x(), maxCorner().y(), minCorner().z()) );
out.addPoint( mat * vec3(maxCorner().x(), minCorner().y(), minCorner().z()) );
out.addPoint( mat * vec3(minCorner().x(), minCorner().y(), maxCorner().z()) );
out.addPoint( mat * vec3(minCorner().x(), maxCorner().y(), maxCorner().z()) );
out.addPoint( mat * vec3(maxCorner().x(), maxCorner().y(), maxCorner().z()) );
out.addPoint( mat * vec3(maxCorner().x(), minCorner().y(), maxCorner().z()) );
}
}
AABB transformed(const mat4d& mat) const
{
AABB aabb;
if ( !isEmpty() )
{
aabb.addPoint( mat * vec3d(minCorner().x(), minCorner().y(), minCorner().z()) );
aabb.addPoint( mat * vec3d(minCorner().x(), maxCorner().y(), minCorner().z()) );
aabb.addPoint( mat * vec3d(maxCorner().x(), maxCorner().y(), minCorner().z()) );
aabb.addPoint( mat * vec3d(maxCorner().x(), minCorner().y(), minCorner().z()) );
aabb.addPoint( mat * vec3d(minCorner().x(), minCorner().y(), maxCorner().z()) );
aabb.addPoint( mat * vec3d(minCorner().x(), maxCorner().y(), maxCorner().z()) );
aabb.addPoint( mat * vec3d(maxCorner().x(), maxCorner().y(), maxCorner().z()) );
aabb.addPoint( mat * vec3d(maxCorner().x(), minCorner().y(), maxCorner().z()) );
}
return aabb;
}
void transformed(AABB& aabb, const mat4d& mat) const
{
aabb.setEmpty();
if ( !isEmpty() )
{
aabb.addPoint( mat * vec3d(minCorner().x(), minCorner().y(), minCorner().z()) );
aabb.addPoint( mat * vec3d(minCorner().x(), maxCorner().y(), minCorner().z()) );
aabb.addPoint( mat * vec3d(maxCorner().x(), maxCorner().y(), minCorner().z()) );
aabb.addPoint( mat * vec3d(maxCorner().x(), minCorner().y(), minCorner().z()) );
aabb.addPoint( mat * vec3d(minCorner().x(), minCorner().y(), maxCorner().z()) );
aabb.addPoint( mat * vec3d(minCorner().x(), maxCorner().y(), maxCorner().z()) );
aabb.addPoint( mat * vec3d(maxCorner().x(), maxCorner().y(), maxCorner().z()) );
aabb.addPoint( mat * vec3d(maxCorner().x(), minCorner().y(), maxCorner().z()) );
}
}
Mesh* Resources::LoadMesh(string filename, string geometryName)
{
string filenameAndGeometryName = dataPath + "\\" + filename + "\\" + geometryName;
// Cached
if (loadedMeshes.count(filenameAndGeometryName) > 0) {
return loadedMeshes[filenameAndGeometryName];
}
domCOLLADA* doc = LoadCollada(dataPath + "\\" + filename);
// Look for the geometry
domGeometry* geom = NULL;
domElement* elem = dae.getDatabase()->idLookup(geometryName, doc->getDocument());
if (elem != NULL && elem->typeID() == domNode::ID()) {
// Forward from node name
domNode* node = daeSafeCast<domNode>(elem);
geom = daeSafeCast<domGeometry>(node->getInstance_geometry_array().get(0)->getUrl().getElement());
} else {
geom = daeSafeCast<domGeometry>(elem);
}
if (geom == NULL) {
MessageBoxA(NULL, ("Could not find mesh " + filenameAndGeometryName).c_str(), "COLLADA", MB_OK);
exit(1);
}
domMeshRef meshRef = geom->getMesh();
Mesh* mesh = new Mesh(filename, geometryName);
loadedMeshes[filenameAndGeometryName] = mesh; // Cache
// Load the <tristrips/> elements
// (other types are ignored for now)
D3DXVECTOR3 minCorner(0,0,0), maxCorner(0,0,0);
bool minMaxSet = false;
for(u_int i = 0; i < meshRef->getTristrips_array().getCount(); i++) {
domTristripsRef tristripsRef = meshRef->getTristrips_array().get(i);
Tristrip ts;
ts.fvf = 0;
ts.buffer = NULL;
// Resolve all data sources
int posOffset = -1; domListOfFloats* posSrc;
int norOffset = -1; domListOfFloats* norSrc;
int colOffset = -1; domListOfFloats* colSrc;
int texOffset = -1; domListOfFloats* texSrc;
for(u_int j = 0; j < tristripsRef->getInput_array().getCount(); j++) {
domInputLocalOffsetRef input = tristripsRef->getInput_array().get(j);
daeElementRef source = input->getSource().getElement();
// Defined per vertex - forward
if (source->typeID() == domVertices::ID()) {
source = daeSafeCast<domVertices>(source)->getInput_array().get(0)->getSource().getElement();
}
int offset = (int)input->getOffset();
domListOfFloats* src = &(daeSafeCast<domSource>(source)->getFloat_array()->getValue());
if (input->getSemantic() == string("VERTEX")) {
posOffset = offset;
posSrc = src;
ts.fvf |= D3DFVF_XYZ;
} else if (input->getSemantic() == string("NORMAL")) {
norOffset = offset;
norSrc = src;
ts.fvf |= D3DFVF_NORMAL;
} else if (input->getSemantic() == string("COLOR")) {
colOffset = offset;
colSrc = src;
ts.fvf |= D3DFVF_DIFFUSE;
} else if (input->getSemantic() == string("TEXCOORD")) {
texOffset = offset;
texSrc = src;
ts.fvf |= D3DFVF_TEX2;
}
}
// Load the <P/> elementes
int pStride = 0;
pStride = max(pStride, posOffset + 1);
pStride = max(pStride, norOffset + 1);
pStride = max(pStride, colOffset + 1);
pStride = max(pStride, texOffset + 1);
vector<float>& vb = ts.vb; // Vertex buffer data
for(u_int j = 0; j < tristripsRef->getP_array().getCount(); j++) {
domListOfUInts p = tristripsRef->getP_array().get(j)->getValue();
ts.vertexCounts.push_back(p.getCount() / pStride);
for(u_int k = 0; k < p.getCount(); k += pStride) {
if (posOffset != -1) {
int index = (int)p.get(k + posOffset);
float x = (float)posSrc->get(3 * index + 0);
float y = (float)posSrc->get(3 * index + 1);
float z = (float)posSrc->get(3 * index + 2);
if (!minMaxSet) {
minCorner = maxCorner = D3DXVECTOR3(x, y, z);
minMaxSet = true;
} else {
minCorner = min3(minCorner, D3DXVECTOR3(x, y, z));
maxCorner = max3(maxCorner, D3DXVECTOR3(x, y, z));
}
vb.push_back(x);
vb.push_back(y);
vb.push_back(z);
}
if (norOffset != -1) {
int index = (int)p.get(k + norOffset);
vb.push_back((float)norSrc->get(3 * index + 0));
vb.push_back((float)norSrc->get(3 * index + 1));
vb.push_back((float)norSrc->get(3 * index + 2));
}
if (colOffset != -1) {
int index = (int)p.get(k + colOffset);
u_int argb = GetColor(colSrc, index);
vb.push_back(*((float*)&argb));
}
if (texOffset != -1) {
int index = (int)p.get(k + texOffset);
vb.push_back((float)texSrc->get(2 * index + 0));
vb.push_back(1 - (float)texSrc->get(2 * index + 1));
}
// Note vertex buffer stride (bytes)
if (j == 0 && k == 0) {
ts.vbStride_floats = vb.size();
ts.vbStride_bytes = vb.size() * sizeof(float);
}
}
}
// Load the material
ts.materialName = tristripsRef->getMaterial();
LoadMaterial(doc, ts.materialName, &ts.material, &ts.textureFilename);
// Done with this <tristrips/>
mesh->tristrips.push_back(ts);
}
mesh->boundingBox = BoundingBox(minCorner, maxCorner);
return mesh;
}
