void ModelDrawer::RenderObject (MdlObject *o, IView *v, int mapping)
{
// setup selector
v->PushSelector (o->selector);
// setup object transformation
Matrix tmp, mat;
o->GetTransform (mat);
mat.transpose (&tmp);
glPushMatrix ();
glMultMatrixf ( (float*)&tmp );
// render object origin
if (v->GetConfig (CFG_OBJCENTERS)!=0.0f)
{
glPointSize (ObjCenterSize);
if (o->isSelected) glColor3ub (255,0,0);
else glColor3ub (255,255,255);
glBegin(GL_POINTS);
glVertex3i(0,0,0);
glEnd();
glPointSize (1);
glColor3ub (255,255,255);
}
bool polySelect=v->GetConfig(CFG_POLYSELECT) != 0;
// if(polySelect) {
// render polygons
PolyMesh *pm = o->GetPolyMesh();
if (pm) {
for (unsigned int a=0;a<pm->poly.size();a++)
RenderPolygon (o, pm->poly[a], v,mapping, polySelect);
} else if (o->geometry)
o->geometry->Draw(this, model, o);
/* }
else
{
// render geometry using drawing list
if (!o->renderData)
o->renderData = new RenderData;
RenderData* rd = (RenderData*)o->renderData;
if (rd->drawList)
glCallList(rd->drawList);
else {
rd->drawList = glGenLists(1);
glNewList(rd->drawList, GL_COMPILE_AND_EXECUTE);
// render polygons
for (int a=0;a<o->poly.size();a++)
RenderPolygon (o, o->poly[a], v,mapping, polySelect);
glEndList ();
}
}*/
for (unsigned int a=0;a<o->childs.size();a++)
RenderObject (o->childs[a], v, mapping);
glPopMatrix ();
v->PopSelector ();
}
void ModelDrawer::Render(Model *mdl, IView *v, const Vector3& teamColor)
{
if (!glewInitialized)
SetupGL();
model = mdl;
if (!model->root)
return;
int S3ORendering=0;
MdlObject *root = model->root;
if (v->IsSelecting ())
glDisable(GL_TEXTURE_2D);
else if (v->GetRenderMode () == M3D_TEX)
S3ORendering = SetupTextureMapping (v, teamColor);
glEnable(GL_NORMALIZE);
Matrix ident;
ident.identity();
RenderObject(root, v, model->mapping);
if (S3ORendering > 0) {
if (S3ORendering == 2)
CleanupS3OAdvDrawing ();
else if (S3ORendering == 1)
CleanupS3OBasicDrawing ();
glDisable (GL_TEXTURE_2D);
}
glDisable(GL_LIGHTING);
RenderHelperGeom(root,v);
if (!v->IsSelecting ())
RenderSelection (v);
// draw radius
if (v->GetConfig (CFG_DRAWRADIUS) != 0.0f)
{
glPushMatrix();
glTranslatef(model->mid.x, model->mid.y, model->mid.z);
glScalef(model->radius,model->radius,model->radius);
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glColor3ub(255,255,255);
glDisable(GL_CULL_FACE);
glDisable(GL_TEXTURE_2D);
glCallList(sphereList);
glPopMatrix();
}
// draw height
if (v->GetConfig (CFG_DRAWHEIGHT) != 0.0f)
{
glLineWidth (5.0f);
glColor3ub (255,255,0);
glBegin (GL_LINES);
glVertex3i(0,0,0);
glVertex3f(0.0f,model->height,0.0f);
glEnd();
glLineWidth (1.0f);
}
}
void pl_Cam::RenderObject(pl_Obj *obj, pl_Float *bmatrix, pl_Float *bnmatrix) {
if (!obj||!frameBuffer) return;
pl_Float oMatrix[16], nMatrix[16], tempMatrix[16];
if (obj->GenMatrix) {
plMatrixRotate(nMatrix,1,obj->Xa);
plMatrixRotate(tempMatrix,2,obj->Ya);
plMatrixMultiply(nMatrix,tempMatrix);
plMatrixRotate(tempMatrix,3,obj->Za);
plMatrixMultiply(nMatrix,tempMatrix);
memcpy(oMatrix,nMatrix,sizeof(pl_Float)*16);
} else memcpy(nMatrix,obj->RotMatrix,sizeof(pl_Float)*16);
if (bnmatrix) plMatrixMultiply(nMatrix,bnmatrix);
if (obj->GenMatrix) {
plMatrixTranslate(tempMatrix, obj->Xp, obj->Yp, obj->Zp);
plMatrixMultiply(oMatrix,tempMatrix);
} else memcpy(oMatrix,obj->Matrix,sizeof(pl_Float)*16);
if (bmatrix) plMatrixMultiply(oMatrix,bmatrix);
{
int i;
for (i = 0; i < obj->Children.GetSize(); i ++)
if (obj->Children.Get(i)) RenderObject(obj->Children.Get(i),oMatrix,nMatrix);
}
if (!obj->Faces.GetSize() || !obj->Vertices.GetSize()) return;
plMatrixTranslate(tempMatrix, -X, -Y, -Z);
plMatrixMultiply(oMatrix,tempMatrix);
plMatrixMultiply(oMatrix,_cMatrix);
plMatrixMultiply(nMatrix,_cMatrix);
{
pl_Vertex *vertex = obj->Vertices.Get();
int i = obj->Vertices.GetSize();
while (i--)
{
MACRO_plMatrixApply(oMatrix,vertex->x,vertex->y,vertex->z,
vertex->xformedx, vertex->xformedy, vertex->xformedz);
MACRO_plMatrixApply(nMatrix,vertex->nx,vertex->ny,vertex->nz,
vertex->xformednx,vertex->xformedny,vertex->xformednz);
vertex++;
}
}
if (_faces.GetSize() < _numfaces + obj->Faces.GetSize()) _faces.Resize(_numfaces + obj->Faces.GetSize());
_faceInfo *facelistout = _faces.Get() + _numfaces;
pl_Face *face = obj->Faces.Get();
int facecnt = obj->Faces.GetSize();
RenderTrisIn += facecnt;
_numfaces += facecnt;
pl_Vertex *vlist = obj->Vertices.Get();
while (facecnt--)
{
double nx,ny,nz;
pl_Mat *mat=face->Material;
if (mat->BackfaceCull || (mat->Lightable && !mat->Smoothing))
{
MACRO_plMatrixApply(nMatrix,face->nx,face->ny,face->nz,nx,ny,nz);
}
pl_Vertex *v0=vlist+face->VertexIndices[0];
pl_Vertex *v1=vlist+face->VertexIndices[1];
pl_Vertex *v2=vlist+face->VertexIndices[2];
if (!mat->BackfaceCull || (MACRO_plDotProduct(nx,ny,nz, v0->xformedx, v0->xformedy, v0->xformedz) < 0.0000001)) {
if (ClipNeeded(face,obj)) {
if (!mat->Smoothing && (mat->Lightable||mat->FadeDist)) {
pl_Float val[3];
memcpy(val,face->sLighting,3*sizeof(pl_Float));
if (mat->Lightable) {
_lightInfo *inf = _lights.Get();
int i=_numlights;
while (i--)
{
pl_Light *light = inf->light;
double lightsc=0.0;
if (light->Type & PL_LIGHT_POINT_ANGLE) {
double nx2 = inf->l[0] - v0->xformedx;
double ny2 = inf->l[1] - v0->xformedy;
double nz2 = inf->l[2] - v0->xformedz;
MACRO_plNormalizeVector(nx2,ny2,nz2);
lightsc = MACRO_plDotProduct(nx,ny,nz,nx2,ny2,nz2);
}
if (light->Type & PL_LIGHT_POINT_DISTANCE) {
double nx2 = inf->l[0] - v0->xformedx;
double ny2 = inf->l[1] - v0->xformedy;
double nz2 = inf->l[2] - v0->xformedz;
if (light->Type & PL_LIGHT_POINT_ANGLE) {
nx2 = (1.0 - 0.5*((nx2*nx2+ny2*ny2+nz2*nz2)/
light->HalfDistSquared));
lightsc *= plMax(0,plMin(1.0,nx2));
} else {
lightsc = (1.0 - 0.5*((nx2*nx2+ny2*ny2+nz2*nz2)/
light->HalfDistSquared));
lightsc = plMax(0,plMin(1.0,lightsc));
}
}
if (light->Type == PL_LIGHT_VECTOR)
lightsc = MACRO_plDotProduct(nx,ny,nz,inf->l[0],inf->l[1],inf->l[2]);
if (lightsc>0.0)
{
val[0] += light->Intensity[0]*lightsc;
val[1] += light->Intensity[1]*lightsc;
val[2] += light->Intensity[2]*lightsc;
}
else if (mat->BackfaceIllumination)
{
val[0] -= light->Intensity[0]*lightsc*mat->BackfaceIllumination;
val[1] -= light->Intensity[1]*lightsc*mat->BackfaceIllumination;
val[2] -= light->Intensity[2]*lightsc*mat->BackfaceIllumination;
}
inf++;
} /* End of light loop */
} /* End of flat shading if */
if (mat->FadeDist)
{
double lightsc = 1.0 - (v0->xformedz+v1->xformedz+v2->xformedz) / (mat->FadeDist*3.0);
if (lightsc<0.0) lightsc=0.0;
else if (lightsc>1.0)lightsc=1.0;
if (mat->Lightable)
{
val[0] *= lightsc;
val[1] *= lightsc;
val[2] *= lightsc;
}
else
{
val[0]+=lightsc;
val[1]+=lightsc;
val[2]+=lightsc;
}
}
face->Shades[0][0]=mat->Ambient[0] + mat->Diffuse[0]*val[0];
face->Shades[0][1]=mat->Ambient[1] + mat->Diffuse[1]*val[1];
face->Shades[0][2]=mat->Ambient[2] + mat->Diffuse[2]*val[2];
}
else memcpy(face->Shades,mat->Ambient,sizeof(mat->Ambient)); // flat shading
if ((mat->Texture && mat->TexMapIdx<0)||(mat->Texture2 && mat->Tex2MapIdx<0)) {
face->MappingU[PLUSH_MAX_MAPCOORDS-1][0] = 0.5 + (v0->xformednx);
face->MappingV[PLUSH_MAX_MAPCOORDS-1][0] = 0.5 - (v0->xformedny);
face->MappingU[PLUSH_MAX_MAPCOORDS-1][1] = 0.5 + (v1->xformednx);
face->MappingV[PLUSH_MAX_MAPCOORDS-1][1] = 0.5 - (v1->xformedny);
face->MappingU[PLUSH_MAX_MAPCOORDS-1][2] = 0.5 + (v2->xformednx);
face->MappingV[PLUSH_MAX_MAPCOORDS-1][2] = 0.5 - (v2->xformedny);
}
if (mat->Smoothing && (mat->Lightable || mat->FadeDist))
{
int a;
for (a = 0; a < 3; a ++) {
pl_Float val[3];
memcpy(val,face->vsLighting[a],sizeof(val));
pl_Vertex *thisvert = obj->Vertices.Get()+face->VertexIndices[a];
if (mat->Lightable)
{
int i=_numlights;
_lightInfo *inf = _lights.Get();
while (i--)
{
double lightsc = 0.0;
pl_Light *light = inf->light;
if (light->Type & PL_LIGHT_POINT_ANGLE) {
double nx2 = inf->l[0] - thisvert->xformedx;
double ny2 = inf->l[1] - thisvert->xformedy;
double nz2 = inf->l[2] - thisvert->xformedz;
MACRO_plNormalizeVector(nx2,ny2,nz2);
lightsc = MACRO_plDotProduct(thisvert->xformednx,
thisvert->xformedny,
thisvert->xformednz,
nx2,ny2,nz2);
}
if (light->Type & PL_LIGHT_POINT_DISTANCE) {
double nx2 = inf->l[0] - thisvert->xformedx;
double ny2 = inf->l[1] - thisvert->xformedy;
double nz2 = inf->l[2] - thisvert->xformedz;
if (light->Type & PL_LIGHT_POINT_ANGLE) {
double t= (1.0 - 0.5*((nx2*nx2+ny2*ny2+nz2*nz2)/light->HalfDistSquared));
lightsc *= plMax(0,plMin(1.0,t));
} else {
lightsc = (1.0 - 0.5*((nx2*nx2+ny2*ny2+nz2*nz2)/light->HalfDistSquared));
lightsc = plMax(0,plMin(1.0,lightsc));
}
}
if (light->Type == PL_LIGHT_VECTOR)
lightsc = MACRO_plDotProduct(thisvert->xformednx,
thisvert->xformedny,
thisvert->xformednz,
inf->l[0],inf->l[1],inf->l[2]);
if (lightsc > 0.0)
{
val[0] += lightsc * light->Intensity[0];
val[1] += lightsc * light->Intensity[1];
val[2] += lightsc * light->Intensity[2];
}
else if (mat->BackfaceIllumination)
{
val[0] -= lightsc * light->Intensity[0]*mat->BackfaceIllumination;
val[1] -= lightsc * light->Intensity[1]*mat->BackfaceIllumination;
val[2] -= lightsc * light->Intensity[2]*mat->BackfaceIllumination;
}
inf++;
} /* End of light loop */
} /* End of gouraud shading if */
if (mat->FadeDist)
{
double lightsc = 1.0-thisvert->xformedz/mat->FadeDist;
if (lightsc<0.0) lightsc=0.0;
else if (lightsc>1.0)lightsc=1.0;
if (mat->Lightable)
{
val[0] *= lightsc;
val[1] *= lightsc;
val[2] *= lightsc;
}
else
{
val[0] += lightsc;
val[1] += lightsc;
val[2] += lightsc;
}
}
face->Shades[a][0] = mat->Ambient[0] + mat->Diffuse[0]*val[0];
face->Shades[a][1] = mat->Ambient[1] + mat->Diffuse[1]*val[1];
face->Shades[a][2] = mat->Ambient[2] + mat->Diffuse[2]*val[2];
} /* End of vertex loop for */
} /* End of gouraud shading mask if */
else // flat modes, shade all vertices
{
memcpy(&face->Shades[1][0],&face->Shades[0][0],sizeof(pl_Float)*3);
memcpy(&face->Shades[2][0],&face->Shades[0][0],sizeof(pl_Float)*3);
}
facelistout->zd = v0->xformedz+v1->xformedz+v2->xformedz;
facelistout->obj=obj;
facelistout->face = face;
facelistout++;
RenderTrisCulled++;
} /* Is it in our area Check */
} /* Backface Check */
face++;
}
_numfaces = facelistout-_faces.Get();
}
void RenderManager::RenderObjectAt(Shape& shape, const a2de::Vector2D& screen_position, bool filled) {
a2de::Vector2D old_pos(shape.GetPosition());
shape.SetPosition(screen_position);
RenderObject(shape, filled);
shape.SetPosition(old_pos);
}
// Depth test is disabled, thus the static objects (i.e. grid) will be drawn first.
// Afterwards the lanes, then the vehicles etc. are drawn, the texts are the last ones.
foreach (GLObject* staticObject, staticObjects_)
{
RenderObject(staticObject);
}
void CGameWorld::Render(Synchronizer& aSynchronizer)
{
if (myResettedGame == true)
{
return;
}
DX2D::CEngine::GetInstance()->GetLightManager().SetAmbience(myFadeIn);
RenderCommand command;
bool renderedPlayer = false;
EventManager::GetInstance()->PostRender(aSynchronizer);
if (myCurrentRoom != nullptr)
{
//std::cout << myRenderPasses.Size() << std::endl;
for (unsigned int i = 0; i < myCurrentRoom->GetObjectList()->Size(); ++i)
{
if ((*myCurrentRoom->GetObjectList())[i]->myName == "Player")
{
//RenderPlayer();
if (renderedPlayer == false)
{
myPlayer.SetColor((*myCurrentRoom->GetObjectList())[i]->myColor);
myPlayer.Render(aSynchronizer);
}
}
else if ((*myCurrentRoom->GetObjectList())[i]->myName == "Layers")
{
std::vector<ObjectData*> objects;
for (unsigned int j = 0; j < (*myCurrentRoom->GetObjectList())[i]->myChilds.Size(); ++j)
{
objects.push_back((*myCurrentRoom->GetObjectList())[i]->myChilds[j]);
}
std::sort(objects.begin(), objects.end(), [](const ObjectData* aFirstVoxel, const ObjectData* aSecondVoxel)
{
return aFirstVoxel->myY < aSecondVoxel->myY;
});
for (unsigned int j = 0; j < objects.size(); j++)
{
if (objects[j]->myY > myPlayer.GetPosition().y)
{
if (renderedPlayer == false)
{
for (unsigned int i = 0; i < myCurrentRoom->GetObjectList()->Size(); ++i)
{
if ((*myCurrentRoom->GetObjectList())[i]->myName == "Player")
{
//RenderPlayer();
if (renderedPlayer == false)
{
myPlayer.SetColor((*myCurrentRoom->GetObjectList())[i]->myColor);
myPlayer.Render(aSynchronizer);
renderedPlayer = true;
}
}
}
}
}
RenderObject(aSynchronizer, objects[j], 0, 0);
}
}
else
{
RenderObject(aSynchronizer, (*myCurrentRoom->GetObjectList())[i], 0, 0);
}
}
myPlayer.GetInventory().Render(aSynchronizer);
if (myShouldRenderFPS == true)
{
RenderCommand fps;
fps.myType = eRenderType::eText;
fps.myPosition = myTextFPS->myPosition;
fps.myText = myTextFPS;
aSynchronizer.AddRenderCommand(fps);
}
if (myDotSprites.GetIsInitialized() == true && myShouldRenderNavPoints == true)
{
CommonUtilities::GrowingArray<Node, int>& points = myCurrentRoom->GetNavPoints();
int gridSize = static_cast<int>(myCurrentRoom->GetGridSize());
float x = 0;
float y = 0;
for (int i = 0; i < points.Size(); ++i)
{
if (points[i].GetIsBlocked() == false)
{
command.myType = eRenderType::eSprite;
myDotSprites[i]->SetPivot({ 0, 0 });
if (points[i].GetPath() == true)
{
myDotSprites[i]->SetColor(DX2D::CColor(0, 0, 1, 1));
}
else if (points[i].myDrawBlue == true)
{
myDotSprites[i]->SetColor({ 0, 1, 0, 1 });
}
else if (points[i].myDrawRed == true)
{
myDotSprites[i]->SetColor({ 1, 0, 0, 1 });
}
else
{
myDotSprites[i]->SetColor(DX2D::CColor(1, 1, 1, 1));
}
command.myPosition = DX2D::Vector2f(x / 1920.0f, y / 1080.0f);
command.mySprite = myDotSprites[i];
aSynchronizer.AddRenderCommand(command);
}
x += gridSize;
if (x >= 1920.0f)
{
x = 0.0f;
y += gridSize;
}
if (i == points.Size() - 1)
{
//std::cout << x << std::endl;
}
}
}
EventManager::GetInstance()->Render(aSynchronizer);
// if options clicked in inventory
//DX2D::CEngine::GetInstance()->GetLightManager().SetAmbience(1.0f);
myOptionsMenu.Render(aSynchronizer);
MouseManager::GetInstance()->Render(aSynchronizer);
}
}
void PointCloud::Render(
const Matrix44f& aParentSpace,
const Camera& aCamera,
DX2D::CSprite* aSprite, DirectionalLight aLight)
{
toWorld = myLocalSpace * aParentSpace;
toWorld *= myOffset;
myRenderMatrix = toWorld * aCamera.GetInverse() * aCamera.GetProjection();
for (unsigned short i = 0; i < myPoints.Size(); ++i)
{
renderPos = myPoints[i] * myRenderMatrix;
if (renderPos.w < 1.0f || renderPos.w > 1000.0f)
{
continue;
}
float scale = 1 / renderPos.w;
renderPos /= renderPos.w;
Vector3f color = { myPointColors[i].myR, myPointColors[i].myG, myPointColors[i].myB };
myRenderObjs.push_back(RenderObject(renderPos, color, scale));
}
for (unsigned short i = 0; i < myVoxels.size(); ++i)
{
//CULTUR STUFFS
renderPos = myVoxels[i].myPosition * myRenderMatrix;
Vector3f diffuse, halfVector, specular;
float specularPower = 16;
halfVector = Vector3f::Normalize(-aLight.myDirection + (aCamera.GetPosition() - myVoxels[i].myPosition));
Vector3f preDiff = myVoxels[i].myColour * aLight.myColour * Vector3f::Dot(myVoxels[i].myNormal, -aLight.myDirection);
diffuse.x = RANGE(preDiff.x, 0.0f, 1.0f);
diffuse.y = RANGE(preDiff.y, 0.0f, 1.0f);
diffuse.z = RANGE(preDiff.z, 0.0f, 1.0f);
float preSpec = Vector3f::Dot(halfVector, myVoxels[i].myNormal);
preSpec = RANGE(preSpec, 0.0f, 1.0f);
preSpec = std::pow(preSpec, specularPower);
specular = preSpec * aLight.myColour;
Vector3f finalColor = specular + diffuse;
if (renderPos.w < 1.0f || renderPos.w > 1000.0f)
{
continue;
}
float scale = 1 / renderPos.w;
renderPos /= renderPos.w;
myRenderObjs.push_back(RenderObject(renderPos, finalColor, scale));
}
std::sort(myRenderObjs.begin(), myRenderObjs.end(), PointCloud::IsInfront);
for (size_t i = 0; i < myRenderObjs.size(); ++i)
{
aSprite->SetPosition(DX2D::Vector2f(myRenderObjs[i].myPos.x + 0.5f, myRenderObjs[i].myPos.y + 0.5f));
aSprite->SetColor({ myRenderObjs[i].myCol.x, myRenderObjs[i].myCol.y, myRenderObjs[i].myCol.z, 1.0f });
aSprite->SetSize(DX2D::Vector2f(myRenderObjs[i].myScale * 20, myRenderObjs[i].myScale * 20));
aSprite->Render();
}
myRenderObjs.clear();
for (unsigned short i = 0; i < myChildren.Size(); i++)
{
myChildren[i]->Render(toWorld, aCamera, aSprite, aLight);
}
}
