void PlayerMonsterBook::infoData(PacketCreator &packet) {
packet.add<int32_t>(getLevel());
packet.add<int32_t>(getNormals());
packet.add<int32_t>(getSpecials());
packet.add<int32_t>(getSize());
packet.add<int32_t>(getCover());
}
Mesh* ModelLoaderMD3::Surface::getObject(size_t frame) const {
const vector<vec3> verticesArray = getVertices(vertices + frame*header.numVerts, header.numVerts);
const vector<vec3> normalsArray = getNormals(vertices + frame*header.numVerts, header.numVerts);
const vector<vec2> texcoordsArray = getTexCoords(texCoords, header.numVerts);
const vector<Face> facesArray = getFaces(triangles, header.numTris);
return new Mesh(verticesArray, normalsArray, texcoordsArray, facesArray);
}
void m_Polygon::drawNormals() {
vector2f *normals = getNormals();
glBegin(GL_LINES);
for(int i=0; i < numVerticies; i++) {
vector2f pos = (verticies[(i+1)%numVerticies] - verticies[i]) / 2 + verticies[i];
glVertex2f(normals[i].x * 20 + pos.x, normals[i].y * 20 + pos.y);
glVertex2f(pos.x, pos.y);
}
glEnd();
}
//reads in an object from a .obj file
BasicObject::BasicObject(const std::string &filename, const float _shininess){
shininess = _shininess;
_numVerticies = numVertices(filename.c_str());
_numFaces = numFaces(filename.c_str());
_indexCount = _numFaces * 3;
verticies = getVertices(filename.c_str(), _numVerticies);
normals = getNormals(filename.c_str(), _numVerticies);
faces = getFaces(filename.c_str(), _numFaces);
texCoords = getTextureCoords(filename.c_str(), _numVerticies);
}
Mesh* ModelLoaderMD2::buildKeyFrame(const Material &skin,
const Header &header,
TexCoord *texCoords,
Triangle *triangles,
const Frame &frame) {
const vector<vec3> verticesArray = getVertices(frame.vertices, header.numOfVertices, frame.scale, frame.translate);
const vector<vec3> normalsArray = getNormals(frame.vertices, header.numOfVertices);
const vector<vec2> texcoordsArray = getTexCoords(texCoords, header.numOfSt, header.skinWidth, header.skinHeight);
const vector<Face> facesArray = getFaces(triangles, header.numOfTris);
Mesh *mesh = new Mesh(verticesArray, normalsArray, texcoordsArray, facesArray);
mesh->material = skin;
return mesh;
}
void ofxMesh::fromMesh(const ofMesh & mesh){
if (mesh.hasVertices()) {
getVertices()=mesh.getVertices();
}
if (mesh.hasColors()) {
getColors()=mesh.getColors();
}
if (mesh.hasNormals()) {
getNormals()=mesh.getNormals();
}
if (mesh.hasTexCoords()) {
getTexCoords()=mesh.getTexCoords();
}
if (mesh.hasIndices()) {
getIndices()=mesh.getIndices();
}
}
void ofxMesh::toMesh(ofMesh & mesh){
mesh.clear();
if (hasVertices()) {
mesh.getVertices()=getVertices();
}
if (hasColors()) {
mesh.getColors()=getColors();
}
if (hasNormals()) {
mesh.getNormals()=getNormals();
}
if (hasTexCoords()) {
mesh.getTexCoords()=getTexCoords();
}
if (hasIndices()) {
mesh.getIndices()=getIndices();
}
}
void MFixedRenderer::drawOpaques(MSubMesh * subMesh, MArmature * armature)
{
M_PROFILE_SCOPE(MFixedRenderer::drawOpaques);
// data
MVector3 * vertices = subMesh->getVertices();
MVector3 * normals = subMesh->getNormals();
MColor * colors = subMesh->getColors();
if(! vertices)
return;
MSkinData * skinData = subMesh->getSkinData();
if(armature && skinData)
{
unsigned int verticesSize = subMesh->getVerticesSize();
unsigned int normalsSize = subMesh->getNormalsSize();
MVector3 * skinVertices = getVertices(verticesSize);
MVector3 * skinNormals = getNormals(normalsSize);
computeSkinning(armature, skinData, vertices, normals, NULL, skinVertices, skinNormals, NULL);
subMesh->getBoundingBox()->initFromPoints(skinVertices, verticesSize);
vertices = skinVertices;
normals = skinNormals;
}
unsigned int i;
unsigned int displayNumber = subMesh->getDisplaysNumber();
for(i=0; i<displayNumber; i++)
{
MDisplay * display = subMesh->getDisplay(i);
if(! display->isVisible())
continue;
MMaterial * material = display->getMaterial();
if(material)
{
if(material->getBlendMode() == M_BLENDING_NONE)
drawDisplay(subMesh, display, vertices, normals, colors);
}
}
}
/** Interpolates the normal at the given position for the triangle with
* a given index. The position must be inside of the given triangle.
* \param index Index of the triangle to use.
* \param position The position for which to interpolate the normal.
*/
btVector3 TriangleMesh::getInterpolatedNormal(unsigned int index,
const btVector3 &position) const
{
btVector3 p1, p2, p3;
getTriangle(index, &p1, &p2, &p3);
btVector3 n1, n2, n3;
getNormals(index, &n1, &n2, &n3);
// Compute the Barycentric coordinates of position inside triangle
// p1, p2, p3.
btVector3 edge1 = p2 - p1;
btVector3 edge2 = p3 - p1;
// Area of triangle ABC
btScalar p1p2p3 = edge1.cross(edge2).length2();
// Area of BCP
btScalar p2p3p = (p3 - p2).cross(position - p2).length2();
// Area of CAP
btScalar p3p1p = edge2.cross(position - p3).length2();
btScalar s = btSqrt(p2p3p / p1p2p3);
btScalar t = btSqrt(p3p1p / p1p2p3);
btScalar w = 1.0f - s - t;
#ifdef NORMAL_DEBUGGING
btVector3 regen_position = s * p1 + t * p2 + w * p3;
if((regen_position - position).length2() >= 0.0001f)
{
printf("bary:\n");
printf("new: %f %f %f\n", regen_position.getX(),regen_position.getY(),regen_position.getZ());
printf("old: %f %f %f\n", position.getX(), position.getY(),position.getZ());
printf("stw: %f %f %f\n", s, t, w);
printf("p1: %f %f %f\n", p1.getX(),p1.getY(),p1.getZ());
printf("p2: %f %f %f\n", p2.getX(),p2.getY(),p2.getZ());
printf("p3: %f %f %f\n", p3.getX(),p3.getY(),p3.getZ());
printf("pos: %f %f %f\n", position.getX(),position.getY(),position.getZ());
}
#endif
return s*n1 + t*n2 + w*n3;
} // getInterpolatedNormal
void PolyLineEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeDataPointer modelTreeElementExtraEncodeData,
EntityPropertyFlags& requestedProperties,
EntityPropertyFlags& propertyFlags,
EntityPropertyFlags& propertiesDidntFit,
int& propertyCount,
OctreeElement::AppendState& appendState) const {
QWriteLocker lock(&_quadReadWriteLock);
bool successPropertyFits = true;
APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
APPEND_ENTITY_PROPERTY(PROP_LINE_WIDTH, getLineWidth());
APPEND_ENTITY_PROPERTY(PROP_LINE_POINTS, getLinePoints());
APPEND_ENTITY_PROPERTY(PROP_NORMALS, getNormals());
APPEND_ENTITY_PROPERTY(PROP_STROKE_COLORS, getStrokeColors());
APPEND_ENTITY_PROPERTY(PROP_STROKE_WIDTHS, getStrokeWidths());
APPEND_ENTITY_PROPERTY(PROP_TEXTURES, getTextures());
APPEND_ENTITY_PROPERTY(PROP_IS_UV_MODE_STRETCH, getIsUVModeStretch());
}
void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned pointlightcount, std::vector<GlowData>& glows, float dt, bool hasShadow, bool forceRTT)
{
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
m_scene_manager->setActiveCamera(camnode);
PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
PrepareDrawCalls(camnode);
PROFILER_POP_CPU_MARKER();
// Shadows
{
// To avoid wrong culling, use the largest view possible
m_scene_manager->setActiveCamera(m_suncam);
if (!m_mipviz && !m_wireframe && UserConfigParams::m_dynamic_lights &&
UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround() && hasShadow)
{
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
renderShadows();
PROFILER_POP_CPU_MARKER();
if (UserConfigParams::m_gi)
{
PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF);
renderRSM();
PROFILER_POP_CPU_MARKER();
}
}
m_scene_manager->setActiveCamera(camnode);
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
if (UserConfigParams::m_dynamic_lights || forceRTT)
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
glClearColor(0., 0., 0., 0.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
renderSolidFirstPass();
}
PROFILER_POP_CPU_MARKER();
// Lights
{
PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
if (UserConfigParams::m_dynamic_lights)
renderLights(pointlightcount, hasShadow);
PROFILER_POP_CPU_MARKER();
}
// Handle SSAO
{
PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_SSAO));
if (UserConfigParams::m_ssao)
renderSSAO();
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
if (UserConfigParams::m_dynamic_lights || forceRTT)
{
m_rtts->getFBO(FBO_COLORS).Bind();
SColor clearColor(0, 150, 150, 150);
if (World::getWorld() != NULL)
clearColor = World::getWorld()->getClearColor();
glClearColor(clearColor.getRed() / 255.f, clearColor.getGreen() / 255.f,
clearColor.getBlue() / 255.f, clearColor.getAlpha() / 255.f);
glClear(GL_COLOR_BUFFER_BIT);
glDepthMask(GL_FALSE);
}
renderSolidSecondPass();
PROFILER_POP_CPU_MARKER();
if (getNormals())
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
renderNormalsVisualisation();
m_rtts->getFBO(FBO_COLORS).Bind();
}
if (UserConfigParams::m_dynamic_lights && World::getWorld() != NULL &&
World::getWorld()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
m_post_processing->renderFog();
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
renderSkybox(camnode);
PROFILER_POP_CPU_MARKER();
if (getRH())
{
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderRHDebug(m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2], rh_matrix, rh_extend);
}
if (getGI())
{
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderGI(rh_matrix, rh_extend, m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2]);
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing.
if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow)
{
irr_driver->setPhase(GLOW_PASS);
renderGlow(glows);
} // end glow
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
computeSunVisibility();
PROFILER_POP_CPU_MARKER();
// Render transparent
{
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_TRANSPARENT));
renderTransparent();
PROFILER_POP_CPU_MARKER();
}
m_sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
// Render particles
{
PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_PARTICLES));
renderParticles();
PROFILER_POP_CPU_MARKER();
}
if (!UserConfigParams::m_dynamic_lights && !forceRTT)
{
glDisable(GL_FRAMEBUFFER_SRGB);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
return;
}
// Ensure that no object will be drawn after that by using invalid pass
irr_driver->setPhase(PASS_COUNT);
}
void Mesh
::getDifferentialGeometry(const Triangle &tri,
const Point &p,
const float b1,
const float b2,
DifferentialGeometry &dg) const
{
// shorthand
const Point &p1 = mPoints[tri[0]];
const Point &p2 = mPoints[tri[1]];
const Point &p3 = mPoints[tri[2]];
// compute the last barycentric coordinate
float b0 = 1.0f - b1 - b2;
// XXX why do we do this here and not getDifferentialGeometry()?
// interpolate normal?
Normal ng;
if(mInterpolateNormals)
{
// get each vertex's Normals
const Mesh::NormalList &norms = getNormals();
const Normal &n1 = norms[tri[0]];
const Normal &n2 = norms[tri[1]];
const Normal &n3 = norms[tri[2]];
ng = b0 * n1 + b1 * n2 + b2 * n3;
// no need to normalize this if they are
// unit-length to begin with
//ng = ng.normalize();
} // end else
else
{
// XXX just look up from mNormals
ng = (p2 - p1).cross(p3 - p1).normalize();
} // end else
ParametricCoordinates uv0;
ParametricCoordinates uv1;
ParametricCoordinates uv2;
getParametricCoordinates(tri, uv0, uv1, uv2);
// compute deltas for partial derivatives
float du1 = uv0[0] - uv2[0];
float du2 = uv1[0] - uv2[0];
float dv1 = uv0[1] - uv2[1];
float dv2 = uv1[1] - uv2[1];
Vector dp1 = p1 - p3, dp2 = p2 - p3;
float determinant = du1 * dv2 - dv1 * du2;
Vector dpdu, dpdv;
if(determinant == 0.0)
{
// handle zero determinant case
dpdu = ng.orthogonalVector();
dpdv = ng.cross(dpdu).normalize();
} // end if
else
{
float invDet = 1.0f / determinant;
dpdu = ( dv2*dp1 - dv1*dp2) * invDet;
dpdv = (-du2*dp1 + du1*dp2) * invDet;
} // end else
dg.setPointPartials(dpdu,dpdv);
// interpolate uv using barycentric coordinates
ParametricCoordinates uv;
uv[0] = b0*uv0[0] + b1*uv1[0] + b2*uv2[0];
uv[1] = b0*uv0[1] + b1*uv1[1] + b2*uv2[1];
dg.setPoint(p);
dg.setNormal(ng);
dg.setParametricCoordinates(uv);
dg.setTangent(dpdu.normalize());
// force an orthonormal basis
dg.setBinormal(ng.cross(dg.getTangent()));
// set the inverse surface area
dg.setInverseSurfaceArea(getInverseSurfaceArea());
} // end Mesh::getDifferentialGeometry()
void ofxMesh::invertNormals() {
for (int i=0; i<getNumNormals(); i++) {
getNormals()[i] *= -1;
}
}
void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned pointlightcount, std::vector<GlowData>& glows, float dt, bool hasShadow, bool forceRTT)
{
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
glBindBufferBase(GL_UNIFORM_BUFFER, 1, SharedObject::LightingDataUBO);
m_scene_manager->setActiveCamera(camnode);
PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
PrepareDrawCalls(camnode);
PROFILER_POP_CPU_MARKER();
// Shadows
{
// To avoid wrong culling, use the largest view possible
m_scene_manager->setActiveCamera(m_suncam);
if (CVS->isDefferedEnabled() &&
CVS->isShadowEnabled() && hasShadow)
{
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
renderShadows();
PROFILER_POP_CPU_MARKER();
if (CVS->isGlobalIlluminationEnabled())
{
PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF);
renderRSM();
PROFILER_POP_CPU_MARKER();
}
}
m_scene_manager->setActiveCamera(camnode);
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
if (CVS->isDefferedEnabled() || forceRTT)
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
glClearColor(0., 0., 0., 0.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
renderSolidFirstPass();
}
else
{
// We need a cleared depth buffer for some effect (eg particles depth blending)
if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_FRAMEBUFFER_SRGB_WORKING))
glDisable(GL_FRAMEBUFFER_SRGB);
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
// Bind() modifies the viewport. In order not to affect anything else,
// the viewport is just reset here and not removed in Bind().
const core::recti &vp = Camera::getActiveCamera()->getViewport();
glViewport(vp.UpperLeftCorner.X,
irr_driver->getActualScreenSize().Height - vp.LowerRightCorner.Y,
vp.LowerRightCorner.X - vp.UpperLeftCorner.X,
vp.LowerRightCorner.Y - vp.UpperLeftCorner.Y);
glClear(GL_DEPTH_BUFFER_BIT);
if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_FRAMEBUFFER_SRGB_WORKING))
glEnable(GL_FRAMEBUFFER_SRGB);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
PROFILER_POP_CPU_MARKER();
// Lights
{
PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
if (CVS->isDefferedEnabled())
renderLights(pointlightcount, hasShadow);
PROFILER_POP_CPU_MARKER();
}
// Handle SSAO
{
PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_SSAO));
if (UserConfigParams::m_ssao)
renderSSAO();
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
if (CVS->isDefferedEnabled() || forceRTT)
{
m_rtts->getFBO(FBO_COLORS).Bind();
SColor clearColor(0, 150, 150, 150);
if (World::getWorld() != NULL)
clearColor = World::getWorld()->getClearColor();
glClearColor(clearColor.getRed() / 255.f, clearColor.getGreen() / 255.f,
clearColor.getBlue() / 255.f, clearColor.getAlpha() / 255.f);
glClear(GL_COLOR_BUFFER_BIT);
glDepthMask(GL_FALSE);
}
renderSolidSecondPass();
PROFILER_POP_CPU_MARKER();
if (getNormals())
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
renderNormalsVisualisation();
m_rtts->getFBO(FBO_COLORS).Bind();
}
// Render ambient scattering
if (CVS->isDefferedEnabled() && World::getWorld() != NULL &&
World::getWorld()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- Ambient scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_FOG));
renderAmbientScatter();
PROFILER_POP_CPU_MARKER();
}
{
PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
ScopedGPUTimer Timer(getGPUTimer(Q_SKYBOX));
renderSkybox(camnode);
PROFILER_POP_CPU_MARKER();
}
// Render discrete lights scattering
if (CVS->isDefferedEnabled() && World::getWorld() != NULL &&
World::getWorld()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- PointLight Scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_FOG));
renderLightsScatter(pointlightcount);
PROFILER_POP_CPU_MARKER();
}
if (getRH())
{
glDisable(GL_BLEND);
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderRHDebug(m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2], rh_matrix, rh_extend);
}
if (getGI())
{
glDisable(GL_BLEND);
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderGI(rh_matrix, rh_extend, m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2]);
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing.
if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow)
{
ScopedGPUTimer Timer(getGPUTimer(Q_GLOW));
irr_driver->setPhase(GLOW_PASS);
renderGlow(glows);
} // end glow
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
computeSunVisibility();
PROFILER_POP_CPU_MARKER();
// Render transparent
{
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_TRANSPARENT));
renderTransparent();
PROFILER_POP_CPU_MARKER();
}
m_sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
// Render particles
{
PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_PARTICLES));
renderParticles();
PROFILER_POP_CPU_MARKER();
}
if (!CVS->isDefferedEnabled() && !forceRTT)
{
glDisable(GL_FRAMEBUFFER_SRGB);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
return;
}
// Ensure that no object will be drawn after that by using invalid pass
irr_driver->setPhase(PASS_COUNT);
}
void MFixedRenderer::drawTransparents(MSubMesh * subMesh, MArmature * armature)
{
M_PROFILE_SCOPE(MFixedRenderer::drawTransparents);
MRenderingContext * render = MEngine::getInstance()->getRenderingContext();
// data
MVector3 * vertices = subMesh->getVertices();
MVector3 * normals = subMesh->getNormals();
MColor * colors = subMesh->getColors();
if(! vertices)
return;
MSkinData * skinData = subMesh->getSkinData();
if(armature && skinData)
{
unsigned int verticesSize = subMesh->getVerticesSize();
unsigned int normalsSize = subMesh->getNormalsSize();
MVector3 * skinVertices = getVertices(verticesSize);
MVector3 * skinNormals = getNormals(normalsSize);
computeSkinning(armature, skinData, vertices, normals, NULL, skinVertices, skinNormals, NULL);
subMesh->getBoundingBox()->initFromPoints(skinVertices, verticesSize);
vertices = skinVertices;
normals = skinNormals;
}
render->setColorMask(0, 0, 0, 0);
unsigned int i;
unsigned int displayNumber = subMesh->getDisplaysNumber();
for(i=0; i<displayNumber; i++)
{
MDisplay * display = subMesh->getDisplay(i);
if((! display->isVisible()) || (! display->getMaterial()))
continue;
if(display->getMaterial()->getBlendMode() == M_BLENDING_ALPHA)
drawDisplayTriangles(subMesh, display, vertices);
}
render->setColorMask(1, 1, 1, 1);
render->setDepthMask(0);
for(i=0; i<displayNumber; i++)
{
MDisplay * display = subMesh->getDisplay(i);
if(! display->isVisible())
continue;
MMaterial * material = display->getMaterial();
if(material)
{
if(material->getBlendMode() != M_BLENDING_NONE)
drawDisplay(subMesh, display, vertices, normals, colors);
}
}
render->setDepthMask(1);
}
void loadPGMFile(){
FILE *pgmFile;
char pgm_name[10000];
size_t x,y;
unsigned int k=0;
GLfloat **verticesArrayX, **verticesArrayY, **verticesArrayZ;
// pgmFile = fopen("sthelens_after.pgm","r");
pgmFile = fopen("dem/sthelens_before.pgm","r");
//pgmFile = fopen("dem/mtbachelor.pgm","r");
fgets(pgm_name,10000,pgmFile);
fscanf(pgmFile,"%d", &width);
fscanf(pgmFile,"%d", &height);
fscanf(pgmFile,"%d", &maxVal);
gridData = malloc(height * sizeof(int *));
for( x = 0; x < height; x++){
gridData[x] = malloc(width * sizeof(int));
for(y = 0; y < width; y++){
fscanf(pgmFile, "%d", &gridData[x][y]);
}
}
verticesArray = malloc(width * height * 3 * sizeof(GLfloat));
indicesArray = malloc(width * height * 6 * sizeof(GLuint));
normalsArray = malloc(width * height * 3 * sizeof(GLfloat));
verticesArrayX = malloc(height*sizeof(GLfloat*));
verticesArrayY = malloc(height*sizeof(GLfloat*));
verticesArrayZ = malloc(height*sizeof(GLfloat*));
for(k=0;k<height;k++)
{
verticesArrayX[k] = malloc(width* sizeof(GLfloat));
verticesArrayY[k] = malloc(width* sizeof(GLfloat));
verticesArrayZ[k] = malloc(width* sizeof(GLfloat));
}
int indicesI=0;
unsigned long i=0,j=0;
unsigned long vertexIndex = 0;
for(j=0;j<height;j++){
for(i=0;i<width; i++){
verticesArrayX[j][i] = getNormalizedX(i);
verticesArrayY[j][i] = getNormalizedY(j);
verticesArrayZ[j][i] = getNormalizedZ(i,j);
verticesArray[vertexIndex++] = verticesArrayX[j][i];
verticesArray[vertexIndex++] = verticesArrayY[j][i];
verticesArray[vertexIndex++] = verticesArrayZ[j][i];
}
}
indicesI=0;
for( size_t row = 1; row < height; ++row ){
for( size_t col = 1; col < width; ++col )
{
indicesArray[indicesI++] = ( (col-1) + (row-1) * width );
indicesArray[indicesI++] = ( (col-0) + (row-1) * width );
indicesArray[indicesI++] = ( (col-1) + (row-0) * width );
indicesArray[indicesI++] = ( (col-1) + (row-0) * width );
indicesArray[indicesI++] = ( (col-0) + (row-1) * width );
indicesArray[indicesI++] = ( (col-0) + (row-0) * width );
}
}
unsigned long normalIndex = 0;
for(size_t row=0; row < height; ++row){
for(size_t col =0; col < width; ++col){
GLfloat *normalResult;
getNormals(verticesArrayX,verticesArrayY, verticesArrayZ, row,col,height,width, &normalResult);
normalsArray[normalIndex++]= normalResult[0];
normalsArray[normalIndex++]= normalResult[1];
normalsArray[normalIndex++]= normalResult[2];
}
}
totalVertices = width*height*3;
totalIndices = indicesI;
totalNormals = width*height*3;
// computeMinimum();
}
void Geometry::write(IResource* resource)
{
ChunkHeader geometryHeader( BA_GEOMETRY, sizeof( Chunk ) );
geometryHeader.write( resource );
Chunk chunk;
chunk.id = (auid)( this );
memset( chunk.name, 0, engine::maxNameLength );
if( _name.length() > engine::maxNameLength )
{
strncpy( chunk.name, _name.c_str(), engine::maxNameLength - 1 );
}
else
{
strcpy( chunk.name, _name.c_str() );
}
chunk.numShaders = getNumShaders();
chunk.numVertices = getNumVertices();
chunk.numUVSets = getNumUVSets();
chunk.numPrelights = getNumPrelights();
chunk.numTriangles = getNumTriangles();
chunk.sharedShaders = _sharedShaders;
if( _ocTreeRoot )
{
chunk.numOcTreeSectors = _ocTreeRoot->getOcTreeSize();
}
else
{
chunk.numOcTreeSectors = 0;
}
chunk.hasEffect = ( _effect != NULL );
fwrite( &chunk, sizeof( Chunk ), 1, resource->getFile() );
// write shaders
if( !_sharedShaders ) for( int i=0; i<getNumShaders(); i++ )
{
_shaders[i]->write( resource );
}
// write vertices
ChunkHeader verticesHeader( BA_BINARY, sizeof(Vector) * getNumVertices() );
verticesHeader.write( resource );
fwrite( getVertices(), verticesHeader.size, 1, resource->getFile() );
// write normals
ChunkHeader normalsHeader( BA_BINARY, sizeof(Vector) * getNumVertices() );
normalsHeader.write( resource );
fwrite( getNormals(), normalsHeader.size, 1, resource->getFile() );
// write UV-sets
int i;
for( i=0; i<getNumUVSets(); i++ )
{
ChunkHeader uvsHeader( BA_BINARY, sizeof(Flector) * getNumVertices() );
uvsHeader.write( resource );
fwrite( getUVSet(i), uvsHeader.size, 1, resource->getFile() );
}
// write prelights
for( i=0; i< getNumPrelights(); i++ )
{
ChunkHeader prelightsHeader( BA_BINARY, sizeof(Color) * getNumVertices() );
prelightsHeader.write( resource );
fwrite( getPrelights(i), prelightsHeader.size, 1, resource->getFile() );
}
// write triangles
ChunkHeader trianglesHeader( BA_BINARY, sizeof(Triangle) * getNumTriangles() );
trianglesHeader.write( resource );
fwrite( getTriangles(), trianglesHeader.size, 1, resource->getFile() );
// write shaders
if( !_sharedShaders )
{
ChunkHeader shadersHeader( BA_BINARY, sizeof(auid) * getNumShaders() );
shadersHeader.write( resource );
fwrite( _shaders, shadersHeader.size, 1, resource->getFile() );
}
// write octree
if( _ocTreeRoot )
{
_ocTreeRoot->write( resource );
}
// write effect
if( chunk.hasEffect )
{
reinterpret_cast<Effect*>( _effect )->write( resource );
}
}
void ofApp::draw(){
if (isDofEnabled) depthOfField.begin();
ofBackgroundGradient(bgColourIn.get(), bgColourOut.get());
ofEnableDepthTest();
cam.begin();
// lights
ofEnableLighting();
spotLight.enable();
ofSetColor(255);
// Phong Shader
if (isPhongShaderOn) {
phongShader.begin();
phongShader.setUniform1i("numLights", 1);
}
else if (isToonShaderOn) {
toonShader.begin();
toonShader.setUniform1i("numLights", 1);
}
material.begin();
sphere.pan(.1);
icoSphere.pan(.1);
if (ofGetKeyPressed('w')) {
if (isIcoSphere) icoSphere.draw(OF_MESH_WIREFRAME);
else sphere.draw(OF_MESH_WIREFRAME);
}
else {
if (isIcoSphere) icoSphere.draw();
else sphere.draw();
}
material.end();
// Phong / Toon shader end
if (isPhongShaderOn) phongShader.end();
else if (isToonShaderOn) toonShader.end();
// lights / DOF
spotLight.disable();
ofDisableLighting();
// normals debug
auto mesh = sphere.getMeshPtr();
if(ofGetKeyPressed('n')){
vector<ofVec3f> n = mesh->getNormals();
vector<ofVec3f> v = mesh->getVertices();
float normalLength = 3;
for(int i=0; i < n.size() ;i++){
int rowEnd = (UV_SPHERE_RES*2) + 1;
if (i % rowEnd == 0) ofSetColor(255, 255, 0);
else if ( (i+1) % rowEnd == 0 ) ofSetColor(0, 255, 255);
else ofSetColor(255);
//ofDrawBitmapString(ofToString(i), v[i].x+n[i].x*normalLength, v[i].y+n[i].y*normalLength ,v[i].z+n[i].z*normalLength);
ofDrawLine(v[i].x, v[i].y, v[i].z,
v[i].x+n[i].x*normalLength, v[i].y+n[i].y*normalLength ,v[i].z+n[i].z*normalLength);
}
}
cam.end();
if (isDofEnabled) {
depthOfField.end();
if(ofGetKeyPressed('d')){
depthOfField.drawFocusAssist(0, 0);
}
else{
depthOfField.getFbo().draw(0, 0);
}
}
// GUI
ofDisableDepthTest();
ofSetColor(255);
if (isGuiVisible) gui.draw();
}
