void DrawEERIEInter_ViewProjectTransform(EERIE_3DOBJ *eobj) {
for(size_t i = 0 ; i < eobj->vertexlist.size(); i++) {
Vec3f tempWorld;
EE_RT(eobj->vertexlist3[i].v, tempWorld);
EE_P(&tempWorld, &eobj->vertexlist[i].vert);
}
}
void drawLineSphere(const Sphere & sphere, Color color) {
if(sphere.radius <= 0)
return;
static const size_t sections = 64;
size_t rings = sphere.radius / 10;
if(rings < 7)
rings = 7;
std::vector<TexturedVertex> vertices;
bool skip = false;
for(size_t i = 1; i < rings - 1; i++) {
float a = i * (glm::pi<float>() / (rings - 1));
for(size_t j = 0; j <= sections; j++) {
float b = j * ((2 * glm::pi<float>()) / sections);
Vec3f pos;
pos.x = glm::cos(b) * glm::sin(a);
pos.y = glm::sin(b) * glm::sin(a);
pos.z = glm::cos(a);
pos *= sphere.radius;
pos += sphere.origin;
TexturedVertex out;
Vec3f temp = EE_RT(pos);
EE_P(temp, out);
if(skip) {
skip = false;
out.color = Color(0, 0, 0, 0).toRGBA();
vertices.push_back(out);
}
out.color = color.toRGBA();
vertices.push_back(out);
if(j == sections) {
skip = true;
out.color = Color(0, 0, 0, 0).toRGBA();
vertices.push_back(out);
}
}
}
GRenderer->ResetTexture(0);
EERIEDRAWPRIM(Renderer::LineStrip, &vertices[0], vertices.size());
}
void renderLightFlares() {
ARX_PROFILE_FUNC();
if(g_debugToggles[6]) {
RaycastDebugDraw();
}
GRenderer->SetFogColor(Color::none);
UseRenderState state(render3D().blend(BlendOne, BlendOne).depthWrite(false).depthTest(false));
for(size_t i = 0; i < g_culledDynamicLightsCount; i++) {
const EERIE_LIGHT & el = *g_culledDynamicLights[i];
if(!el.m_exists || !el.m_isVisible || !(el.extras & EXTRAS_FLARE) || el.m_flareFader <= 0.f) {
continue;
}
float v = el.m_flareFader;
if(FADEDIR) {
v *= 1.f - LAST_FADEVALUE;
}
float size = -el.ex_flaresize;
if(el.extras & EXTRAS_FIXFLARESIZE) {
// This is only used for one light in the whole game and makes it's flare gigantic when up close
// TODO Is this part of some puzze or a bug / obsolete workaround?
size = el.ex_flaresize;
}
EERIEDrawSprite(el.pos, size, tflare, Color(el.rgb * v), EE_RT(el.pos).z);
}
}
void ARXDRAW_DrawInterShadows() {
ARX_PROFILE_FUNC();
g_shadowBatch.clear();
GRenderer->SetFogColor(Color::none);
GRenderer->SetDepthBias(1);
for(long i=0; i<TREATZONE_CUR; i++) {
if(treatio[i].show != 1 || !treatio[i].io)
continue;
Entity *io = treatio[i].io;
if( !io->obj
|| (io->ioflags & IO_JUST_COLLIDE)
|| (io->ioflags & IO_NOSHADOW)
|| (io->ioflags & IO_GOLD)
|| !(io->show == SHOW_FLAG_IN_SCENE)
) {
continue;
}
EERIE_BKG_INFO * bkgData = getFastBackgroundData(io->pos.x, io->pos.z);
if(bkgData && !bkgData->treat) { //TODO is that correct ?
continue;
}
TexturedVertex ltv[4];
ltv[0] = TexturedVertex(Vec3f(0, 0, 0.001f), 1.f, ColorRGBA(0), Vec2f(0.3f, 0.3f));
ltv[1] = TexturedVertex(Vec3f(0, 0, 0.001f), 1.f, ColorRGBA(0), Vec2f(0.7f, 0.3f));
ltv[2] = TexturedVertex(Vec3f(0, 0, 0.001f), 1.f, ColorRGBA(0), Vec2f(0.7f, 0.7f));
ltv[3] = TexturedVertex(Vec3f(0, 0, 0.001f), 1.f, ColorRGBA(0), Vec2f(0.3f, 0.7f));
if(io->obj->grouplist.size() <= 1) {
for(size_t k = 0; k < io->obj->vertexlist.size(); k += 9) {
EERIEPOLY *ep = CheckInPoly(io->obj->vertexlist3[k].v);
if(!ep)
continue;
Vec3f in;
in.y = ep->min.y - 3.f;
float r = 0.5f - ((float)glm::abs(io->obj->vertexlist3[k].v.y - in.y)) * (1.f/500);
r -= io->invisibility;
r *= io->scale;
if(r <= 0.f)
continue;
float s1 = 16.f * io->scale;
float s2 = s1 * (1.f/2);
in.x = io->obj->vertexlist3[k].v.x - s2;
in.z = io->obj->vertexlist3[k].v.z - s2;
r *= 255.f;
long lv = r;
ltv[0].color = ltv[1].color = ltv[2].color = ltv[3].color = Color(lv, lv, lv, 255).toRGBA();
ltv[0].p = EE_RT(in);
in.x += s1;
ltv[1].p = EE_RT(in);
in.z += s1;
ltv[2].p = EE_RT(in);
in.x -= s1;
ltv[3].p = EE_RT(in);
if(ltv[0].p.z > 0.f && ltv[1].p.z > 0.f && ltv[2].p.z > 0.f) {
AddToShadowBatch(<v[0], <v[1], <v[2]);
AddToShadowBatch(<v[0], <v[2], <v[3]);
}
}
} else {
for(size_t k = 0; k < io->obj->grouplist.size(); k++) {
long origin = io->obj->grouplist[k].origin;
EERIEPOLY *ep = CheckInPoly(io->obj->vertexlist3[origin].v);
if(!ep)
continue;
Vec3f in;
in.y = ep->min.y - 3.f;
float r = 0.8f - ((float)glm::abs(io->obj->vertexlist3[origin].v.y - in.y)) * (1.f/500);
r *= io->obj->grouplist[k].siz;
r -= io->invisibility;
if(r <= 0.f)
continue;
float s1 = io->obj->grouplist[k].siz * 44.f;
float s2 = s1 * (1.f/2);
in.x = io->obj->vertexlist3[origin].v.x - s2;
in.z = io->obj->vertexlist3[origin].v.z - s2;
r *= 255.f;
long lv = r;
ltv[0].color = ltv[1].color = ltv[2].color = ltv[3].color = Color(lv, lv, lv, 255).toRGBA();
ltv[0].p = EE_RT(in);
in.x += s1;
ltv[1].p = EE_RT(in);
in.z += s1;
ltv[2].p = EE_RT(in);
in.x -= s1;
ltv[3].p = EE_RT(in);
AddToShadowBatch(<v[0], <v[1], <v[2]);
AddToShadowBatch(<v[0], <v[2], <v[3]);
}
}
}
if(g_shadowBatch.size() > 0)
{
GRenderer->SetRenderState(Renderer::DepthWrite, false);
GRenderer->SetBlendFunc(Renderer::BlendZero, Renderer::BlendInvSrcColor);
GRenderer->SetRenderState(Renderer::AlphaBlending, true);
GRenderer->SetTexture(0, Boom);
EERIEDRAWPRIM(Renderer::TriangleList, &g_shadowBatch[0], g_shadowBatch.size());
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
GRenderer->SetRenderState(Renderer::DepthWrite, true);
GRenderer->SetDepthBias(0);
GRenderer->SetFogColor(ulBKGColor);
}
}
void ARXDRAW_DrawPolyBoom() {
ARX_PROFILE_FUNC();
TexturedVertex ltv[4];
GRenderer->SetFogColor(Color::none); // TODO: not handled by RenderMaterial
unsigned long tim = (unsigned long)(arxtime);
RenderMaterial mat = RenderMaterial::getCurrent();
mat.setDepthBias(8);
mat.setLayer(RenderMaterial::Decal);
std::vector<POLYBOOM>::iterator pb = polyboom.begin();
while (pb != polyboom.end()) {
if(pb->type & 128) {
if(pb->timecreation - framedelay > 0) {
float fCalc = pb->timecreation - framedelay;
pb->timecreation = checked_range_cast<unsigned long>(fCalc);
}
if(pb->timecreation - framedelay > 0) {
float fCalc = pb->timecreation - framedelay;
pb->timecreation = checked_range_cast<unsigned long>(fCalc);
}
}
float t = (float)pb->timecreation + (float)pb->tolive - (float)tim;
if(t <= 0) {
pb = polyboom.erase(pb);
continue;
}
long typp = pb->type;
typp &= ~128;
switch(typp) {
case 0: {
float tt = t / (float)pb->tolive * 0.8f;
IncrementPolyWithNormalOutput(pb->ep,ltv);
for(long k = 0; k < pb->nbvert; k++) {
ltv[k].p = EE_RT(ltv[k].p);
ltv[k].uv.x=pb->u[k];
ltv[k].uv.y=pb->v[k];
ltv[k].color = (player.m_improve ? (Color3f::red * (tt*.5f)) : Color3f::gray(tt)).toRGB();
}
if(player.m_improve) {
mat.setBlendType(RenderMaterial::Additive);
} else {
mat.setBlendType(RenderMaterial::Subtractive);
}
mat.setTexture(Boom);
drawTriangle(mat, <v[0]);
if(pb->nbvert & 4) {
drawTriangle(mat, <v[1]);
}
break;
}
case 1: { // Blood
float div = 1.f / (float)pb->tolive;
float tt = t * div;
float tr = std::max(1.f, tt * 2 - 0.5f);
ColorRGBA col = (pb->rgb * tt).toRGB(glm::clamp(tt * 1.5f, 0.f, 1.f) * 255);
IncrementPolyWithNormalOutput(pb->ep, ltv);
for(long k = 0; k < pb->nbvert; k++) {
ltv[k].p = EE_RT(ltv[k].p);
ltv[k].uv.x=(pb->u[k]-0.5f)*(tr)+0.5f;
ltv[k].uv.y=(pb->v[k]-0.5f)*(tr)+0.5f;
ltv[k].color = col;
}
mat.setWrapMode(TextureStage::WrapClamp);
mat.setBlendType(RenderMaterial::Subtractive2);
mat.setTexture(pb->tc);
drawTriangle(mat, <v[0]);
if(pb->nbvert & 4) {
drawTriangle(mat, <v[1]);
}
break;
}
case 2: { // Water
float div = 1.f / (float)pb->tolive;
float tt = t * div;
float tr = std::max(1.f, tt * 2 - 0.5f);
float ttt = tt * 0.5f;
ColorRGBA col = (pb->rgb * ttt).toRGB();
IncrementPolyWithNormalOutput(pb->ep,ltv);
for(long k = 0; k < pb->nbvert; k++) {
ltv[k].p = EE_RT(ltv[k].p);
ltv[k].uv.x=(pb->u[k]-0.5f)*(tr)+0.5f;
ltv[k].uv.y=(pb->v[k]-0.5f)*(tr)+0.5f;
ltv[k].color=col;
}
if ( (ltv[0].uv.x<0.f)
&& (ltv[1].uv.x<0.f)
&& (ltv[2].uv.x<0.f)
&& (ltv[3].uv.x<0.f) )
break;
if ( (ltv[0].uv.y<0.f)
&& (ltv[1].uv.y<0.f)
&& (ltv[2].uv.y<0.f)
&& (ltv[3].uv.y<0.f) )
break;
if ( (ltv[0].uv.x>1.f)
&& (ltv[1].uv.x>1.f)
&& (ltv[2].uv.x>1.f)
&& (ltv[3].uv.x>1.f) )
break;
if ( (ltv[0].uv.y>1.f)
&& (ltv[1].uv.y>1.f)
&& (ltv[2].uv.y>1.f)
&& (ltv[3].uv.y>1.f) )
break;
mat.setWrapMode(TextureStage::WrapClamp);
mat.setBlendType(RenderMaterial::Screen);
mat.setTexture(pb->tc);
drawTriangle(mat, <v[0]);
if(pb->nbvert & 4) {
drawTriangle(mat, <v[1]);
}
break;
}
}
++pb;
}
GRenderer->SetFogColor(ulBKGColor);
}
// TODO copy-paste spell effect Fissure
void CSummonCreature::RenderFissure()
{
int i;
float ff;
Vec3f vt[4];
TexturedVertex vr[4];
Vec3f target;
Vec3f etarget;
etarget.x = fBetaRadCos;
etarget.y = 0;
etarget.z = fBetaRadSin;
RenderMaterial mat;
mat.setCulling(Renderer::CullNone);
mat.setDepthTest(false);
mat.setWrapMode(TextureStage::WrapClamp);
mat.setBlendType(RenderMaterial::Opaque);
mat.setLayer(RenderMaterial::EffectForeground);
//-------------------------------------------------------------------------
// computation des sommets
for(i = 0; i <= std::min(end, int(fSizeIntro)); i++) {
if(i <= end * 0.5f)
ff = i / (end * 0.5f);
else
ff = 1.0f - ((i - (end + 1) * 0.5f) / (end * 0.5f));
float fTempCos = ff * fBetaRadCos;
float fTempSin = ff * fBetaRadSin;
va[i].x = v1a[i].x + sizeF * fTempCos;
va[i].y = v1a[i].y;
va[i].z = v1a[i].z + sizeF * fTempSin;
vb[i].x = v1b[i].x - sizeF * fTempCos;
vb[i].y = v1b[i].y;
vb[i].z = v1b[i].z - sizeF * fTempSin;
va[i].x += rnd() * 0.5f * fTempCos;
va[i].z += rnd() * 0.5f * fTempSin;
vb[i].x -= rnd() * 0.5f * fTempCos;
vb[i].z -= rnd() * 0.5f * fTempSin;
}
//-------------------------------------------------------------------------
// rendu de la fissure
mat.setBlendType(RenderMaterial::Opaque);
vr[0].color = vr[1].color = vr[2].color = vr[3].color = Color::black.toRGB();
if(bIntro) {
for(i = 0; i < std::min(end, (int)fSizeIntro); i++) {
vr[0].p = EE_RT(v1a[i]);
vr[1].p = EE_RT(v1b[i]);
vr[2].p = EE_RT(v1a[i+1]);
vr[3].p = EE_RT(v1b[i+1]);
drawTriangle(mat, &vr[0]);
drawTriangle(mat, &vr[1]);
}
} else {
for(i = 0; i < std::min(end, (int)fSizeIntro); i++) {
vr[0].p = EE_RT(va[i]);
vr[1].p = EE_RT(vb[i]);
vr[2].p = EE_RT(va[i+1]);
vr[3].p = EE_RT(vb[i+1]);
drawTriangle(mat, &vr[0]);
drawTriangle(mat, &vr[1]);
}
}
//-------------------------------------------------------------------------
// rendu de la bordure
mat.setBlendType(RenderMaterial::Additive);
vr[0].color = vr[1].color = Color::black.toRGB();
vr[2].color = vr[3].color = fColorBorder.toRGB();
for(i = 0; i < std::min(end, (int)fSizeIntro); i++) {
vt[2] = va[i] - (va[i] - eSrc) * 0.2f;
vt[3] = va[i + 1] - (va[i + 1] - eSrc) * 0.2f;
vr[0].p = EE_RT(vt[3]);
vr[1].p = EE_RT(vt[2]);
vr[2].p = EE_RT(va[i+1]);
vr[3].p = EE_RT(va[i]);
drawTriangle(mat, &vr[0]);
drawTriangle(mat, &vr[1]);
vt[2] = vb[i] - (vb[i] - eSrc) * 0.2f;
vt[3] = vb[i + 1] - (vb[i + 1] - eSrc) * 0.2f;
vr[3].p = EE_RT(vb[i]);
vr[2].p = EE_RT(vb[i+1]);
vr[1].p = EE_RT(vt[2]);
vr[0].p = EE_RT(vt[3]);
drawTriangle(mat, &vr[0]);
drawTriangle(mat, &vr[1]);
}
//-------------------------------------------------------------------------
// rendu des faisceaux
// blend additif ou mul
// smooth sur les cotés ou pas ..
// texture sympa avec glow au milieu ou uv wrap
mat.setWrapMode(TextureStage::WrapMirror);
mat.setTexture(tex_light);
target.x = eSrc.x + -fBetaRadSin * (1.5f * sizeF);
target.y = eSrc.y;
target.z = eSrc.z + fBetaRadCos * (1.5f * sizeF);
EE_RTP(vt[1], &vr[0]);
vr[0].color = vr[1].color = fColorRays1.toRGB();
vr[2].color = vr[3].color = fColorRays2.toRGB();
vr[0].uv.x = fTexWrap;
vr[0].uv.y = 1;
vr[1].uv.x = 1.0f + fTexWrap;
vr[1].uv.y = 1;
vr[2].uv.x = fTexWrap;
vr[2].uv.y = 0;
vr[3].uv.x = 1.0f + fTexWrap;
vr[3].uv.y = 0;
for(i = 0; i < end - 1; i++) {
if(i < fSizeIntro) {
vt[0] = va[i];
vt[1] = va[i + 1];
vt[2] = va[i] + (va[i] - target) * 2.f;
vt[3] = va[i + 1] + (va[i + 1] - target) * 2.f;
vr[0].color = (fColorRays1 * tfRaysa[i]).toRGB();
vr[1].color = (fColorRays1 * tfRaysa[i + 1]).toRGB();
vr[2].color = (fColorRays2 * tfRaysa[i]).toRGB();
vr[3].color = (fColorRays2 * tfRaysa[i + 1]).toRGB();
vr[3].p = EE_RT(vt[0]);
vr[2].p = EE_RT(vt[1]);
vr[1].p = EE_RT(vt[2]);
vr[0].p = EE_RT(vt[3]);
drawTriangle(mat, &vr[0]);
drawTriangle(mat, &vr[1]);
}
if(i < fSizeIntro) {
vt[0] = vb[i + 1];
vt[1] = vb[i];
vt[2] = vb[i + 1] + (vb[i + 1] - target) * 2.f;
vt[3] = vb[i] + (vb[i] - target) * 2.f;
vr[0].color = (fColorRays1 * tfRaysb[i]).toRGB();
vr[1].color = (fColorRays1 * tfRaysb[i + 1]).toRGB();
vr[2].color = (fColorRays2 * tfRaysb[i]).toRGB();
vr[3].color = (fColorRays2 * tfRaysb[i + 1]).toRGB();
vr[3].p = EE_RT(vt[0]);
vr[2].p = EE_RT(vt[1]);
vr[1].p = EE_RT(vt[2]);
vr[0].p = EE_RT(vt[3]);
drawTriangle(mat, &vr[0]);
drawTriangle(mat, &vr[1]);
}
}
}
static void drawDebugMaterials() {
if(!ACTIVEBKG || !ACTIVEBKG->exist) {
return;
}
PolyType skip = POLY_NODRAW | POLY_HIDE;
if(GInput->isKeyPressed(Keyboard::Key_LeftShift)) {
skip |= POLY_TRANS | POLY_WATER;
}
Vec2f point(DANAEMouse);
Entity * owner = GetFirstInterAtPos(Vec2s(point));
TextureContainer * material = NULL;
size_t count = 0;
Vec2f pp[4];
Vec2f puv[4];
PolyType flags;
float minz = std::numeric_limits<float>::max();
for(size_t k = 1; k < entities.size(); k++) {
EntityHandle h = EntityHandle(k);
if(!entities[h] || !entities[h]->obj) {
continue;
}
Entity * entity = entities[h];
if((entity->ioflags & IO_CAMERA) || (entity->ioflags & IO_MARKER))
continue;
if(!(entity->gameFlags & GFLAG_ISINTREATZONE))
continue;
if((entity->gameFlags & GFLAG_INVISIBILITY))
continue;
if((entity->gameFlags & GFLAG_MEGAHIDE))
continue;
switch(entity->show) {
case SHOW_FLAG_DESTROYED: continue;
case SHOW_FLAG_IN_INVENTORY: continue;
case SHOW_FLAG_ON_PLAYER: continue;
case SHOW_FLAG_LINKED: break;
case SHOW_FLAG_NOT_DRAWN: continue;
case SHOW_FLAG_HIDDEN: continue;
case SHOW_FLAG_MEGAHIDE: continue;
case SHOW_FLAG_KILLED: continue;
case SHOW_FLAG_IN_SCENE: break;
case SHOW_FLAG_TELEPORTING: break;
}
if(!entity->bbox2D.valid()) {
continue;
}
for(size_t j = 0; j < entity->obj->facelist.size(); j++) {
const EERIE_FACE & face = entity->obj->facelist[j];
if(face.facetype & skip) {
continue;
}
bool valid = true;
bool bvalid = false;
Vec3f p[3];
Vec2f uv[3];
for(size_t i = 0; i < 3; i++) {
unsigned short v = face.vid[i];
valid = valid && v < entity->obj->vertexlist3.size();
if(valid) {
if(entity->animlayer[0].cur_anim) {
p[i] = entity->obj->vertexlist3[v].vert.p;
uv[i] = entity->obj->vertexlist3[v].vert.uv;
} else {
p[i] = entity->obj->vertexlist[v].vert.p;
uv[i] = entity->obj->vertexlist[v].vert.uv;
}
valid = valid && (p[i].z > 0.000001f);
bvalid = bvalid || (p[i].x >= g_size.left && p[i].x < g_size.right
&& p[i].y >= g_size.top && p[i].y < g_size.bottom);
}
}
if(!valid || !bvalid) {
continue;
}
float z = pointInTriangle(point, p[0], p[1], p[2]);
if(z > 0 && z <= minz) {
count = 3;
for(size_t i = 0; i < count; i++) {
pp[i] = Vec2f(p[i].x, p[i].y);
puv[i] = uv[i];
}
if(face.texid >= 0 && size_t(face.texid) < entity->obj->texturecontainer.size()) {
material = entity->obj->texturecontainer[face.texid];
} else {
material = NULL;
}
owner = entity;
minz = z;
flags = face.facetype & ~(POLY_WATER | POLY_LAVA);
}
}
}
for(short z = 0; z < ACTIVEBKG->Zsize; z++)
for(short x = 0; x < ACTIVEBKG->Xsize; x++) {
const EERIE_BKG_INFO & feg = ACTIVEBKG->fastdata[x][z];
if(!feg.treat) {
continue;
}
for(long l = 0; l < feg.nbpolyin; l++) {
EERIEPOLY * ep = feg.polyin[l];
if(!ep) {
continue;
}
if(ep->type & skip) {
continue;
}
bool valid = true;
bool bvalid = false;
Vec3f p[4];
for(size_t i = 0; i < ((ep->type & POLY_QUAD) ? 4u : 3u); i++) {
TexturedVertex tv;
tv.p = EE_RT(ep->v[i].p);
valid = valid && (tv.p.z > 0.000001f);
EE_P(tv.p, tv);
bvalid = bvalid || (tv.p.x >= g_size.left && tv.p.x < g_size.right
&& tv.p.y >= g_size.top && tv.p.y < g_size.bottom);
p[i] = tv.p;
}
if(!valid || !bvalid) {
continue;
}
float z = pointInTriangle(point, p[0], p[1], p[2]);
if(z <= 0 && (ep->type & POLY_QUAD)) {
z = pointInTriangle(point, p[1], p[3], p[2]);
}
if(z > 0 && z <= minz) {
count = ((ep->type & POLY_QUAD) ? 4 : 3);
for(size_t i = 0; i < count; i++) {
pp[i] = Vec2f(p[i].x, p[i].y);
puv[i] = ep->v[i].uv;
}
material = ep->tex;
owner = NULL;
minz = z;
flags = ep->type;
}
}
}
if(count) {
GRenderer->SetRenderState(Renderer::DepthTest, false);
drawLine2D(pp[0], pp[1], 0.1f, Color::magenta);
drawLine2D(pp[2], pp[0], 0.1f, Color::magenta);
if(count == 4) {
drawLine2D(pp[2], pp[3], 0.1f, Color::magenta);
drawLine2D(pp[3], pp[1], 0.1f, Color::magenta);
} else {
drawLine2D(pp[1], pp[2], 0.1f, Color::magenta);
}
Vec2f c = Vec2f(0.f);
float miny = std::numeric_limits<float>::max();
float maxy = std::numeric_limits<float>::min();
for(size_t i = 0; i < count; i++) {
c += pp[i];
miny = std::min(miny, pp[i].y);
maxy = std::max(maxy, pp[i].y);
}
c *= 1.f / count;
Vec2f textpos(c.x, miny - 2 * hFontDebug->getLineHeight());
std::ostringstream oss;
if(owner) {
textpos.y -= hFontDebug->getLineHeight();
}
if(material && material->m_pTexture) {
textpos.y -= hFontDebug->getLineHeight();
}
if((flags & (POLY_WATER | POLY_LAVA)) && enviro && enviro->m_pTexture) {
textpos.y -= hFontDebug->getLineHeight();
}
if(textpos.y < g_size.top + 5) {
textpos.y = maxy + 2 * hFontDebug->getLineHeight();
}
if(owner) {
drawTextCentered(hFontDebug, textpos, owner->idString(), Color::cyan);
textpos.y += hFontDebug->getLineHeight();
}
if(material && material->m_pTexture) {
drawDebugMaterialTexture(textpos, "Diffuse: ", *material->m_pTexture, Color::green);
}
if((flags & (POLY_WATER | POLY_LAVA)) && enviro && enviro->m_pTexture) {
oss.str(std::string());
oss << "Animation: ";
oss << ((flags & (POLY_LAVA)) ? "lava" : "water");
if(flags & POLY_FALL) {
oss << " (flowing)";
}
drawDebugMaterialTexture(textpos, oss.str(), *enviro->m_pTexture, Color::yellow);
}
(void)textpos;
for(size_t i = 0; i < count; i++) {
oss.str(std::string());
oss.setf(std::ios_base::fixed, std::ios_base::floatfield);
oss.precision(2);
oss << '(' << puv[i].x << ',' << puv[i].y << ')';
std::string text = oss.str();
Vec2f textpos = pp[i];
if(pp[i].y < c.y) {
textpos.y -= hFontDebug->getLineHeight();
}
if(pp[i].x < c.x) {
Vec2i size = hFontDebug->getTextSize(text);
textpos.x -= size.x;
}
hFontDebug->draw(textpos.x, textpos.y, text, Color::gray(0.7f));
}
GRenderer->SetRenderState(Renderer::DepthTest, true);
}
}
void CLevitate::Render()
{
if(this->key > 1)
return;
//calcul du cone
TexturedVertex *d3dv;
Vec3f * vertex;
int nb, nbc, col;
float ddu = this->ang;
float u = ddu, du = .99999999f / (float)this->def;
switch(this->key) {
case 0:
nbc = 2;
while(nbc--) {
vertex = this->cone[nbc].conevertex;
d3dv = this->cone[nbc].coned3d;
nb = (this->cone[nbc].conenbvertex) >> 1;
while(nb) {
Vec3f d3dvs;
d3dvs.x = m_pos.x + (vertex + 1)->x + ((vertex->x - (vertex + 1)->x) * m_coneScale);
d3dvs.y = m_pos.y + (vertex + 1)->y + ((vertex->y - (vertex + 1)->y) * m_coneScale);
d3dvs.z = m_pos.z + (vertex + 1)->z + ((vertex->z - (vertex + 1)->z) * m_coneScale);
d3dv->p = EE_RT(d3dvs);
col = Random::get(0, 80);
if(!arxtime.is_paused())
d3dv->color = Color::grayb(col).toRGB(col);
d3dv->uv.x = u;
d3dv->uv.y = 0.f;
vertex++;
d3dv++;
d3dvs.x = m_pos.x + vertex->x;
d3dvs.y = m_pos.y;
d3dvs.z = m_pos.z + vertex->z;
d3dv->p = EE_RT(d3dvs);
col = Random::get(0, 80);
if(!arxtime.is_paused())
d3dv->color = Color::black.toRGB(col);
d3dv->uv.x = u;
d3dv->uv.y = 1.f;
vertex++;
d3dv++;
u += du;
nb--;
}
u = ddu;
du = -du;
}
break;
case 1:
nbc = 2;
while(nbc--) {
vertex = this->cone[nbc].conevertex;
d3dv = this->cone[nbc].coned3d;
nb = (this->cone[nbc].conenbvertex) >> 1;
while(nb) {
Vec3f d3dvs = m_pos + *vertex;
d3dv->p = EE_RT(d3dvs);
col = Random::get(0, 80);
if(!arxtime.is_paused())
d3dv->color = Color::grayb(col).toRGB(col);
d3dv->uv.x = u;
d3dv->uv.y = 0.f;
vertex++;
d3dv++;
d3dvs.x = m_pos.x + vertex->x;
d3dvs.y = m_pos.y;
d3dvs.z = m_pos.z + vertex->z;
d3dv->p = EE_RT(d3dvs);
col = Random::get(0, 80);
if(!arxtime.is_paused())
d3dv->color = Color::black.toRGB(col);
d3dv->uv.x = u;
d3dv->uv.y = 1.f;
vertex++;
d3dv++;
u += du;
nb--;
}
u = ddu;
du = -du;
}
break;
}
//tracé du cone back
RenderMaterial mat;
mat.setDepthTest(true);
mat.setBlendType(RenderMaterial::Additive);
mat.setWrapMode(TextureStage::WrapMirror);
mat.setTexture(tsouffle);
mat.setCulling(Renderer::CullCW);
int i = cone[1].conenbfaces - 2;
int j = 0;
while(i--) {
drawTriangle(mat, &cone[1].coned3d[j]);
j++;
}
i = cone[0].conenbfaces - 2;
j = 0;
while(i--) {
drawTriangle(mat, &cone[0].coned3d[j]);
j++;
}
//tracé du cone front
mat.setCulling(Renderer::CullCCW);
i = cone[1].conenbfaces - 2;
j = 0;
while(i--) {
drawTriangle(mat, &cone[1].coned3d[j]);
j++;
}
i = cone[0].conenbfaces - 2;
j = 0;
while(i--) {
drawTriangle(mat, &cone[0].coned3d[j]);
j++;
}
this->DrawStone();
}
