Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-05-01 09:18:00 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions
TombEngine/TR5Main/Renderer/Renderer11DrawEffect.cpp

1225 lines
43 KiB
C++
Raw Blame History

#include "framework.h"
#include "Renderer11.h"
#include "footprint.h"
#include "effect2.h"
#include "sphere.h"
#include "tomb4fx.h"
#include "lara.h"
#include "draw.h"
#include "camera.h"
#include "debris.h"
#include "setup.h"
#include "bubble.h"
#include "level.h"
#include "effect.h"
#include "smoke.h"
#include "spark.h"
#include "drip.h"
#include "explosion.h"
#include "Quad/RenderQuad.h"
extern BLOOD_STRUCT Blood[MAX_SPARKS_BLOOD];
extern FIRE_SPARKS FireSparks[MAX_SPARKS_FIRE];
extern SMOKE_SPARKS SmokeSparks[MAX_SPARKS_SMOKE];
extern DRIP_STRUCT Drips[MAX_DRIPS];
extern SHOCKWAVE_STRUCT ShockWaves[MAX_SHOCKWAVE];
extern FIRE_LIST Fires[MAX_FIRE_LIST];
extern GUNFLASH_STRUCT Gunflashes[MAX_GUNFLASH]; // offset 0xA31D8
extern SPARKS Sparks[MAX_SPARKS];
extern SPLASH_STRUCT Splashes[MAX_SPLASHES];
extern RIPPLE_STRUCT Ripples[MAX_RIPPLES];
extern ENERGY_ARC EnergyArcs[MAX_ENERGYARCS];
namespace T5M::Renderer {
using namespace T5M::Effects::Footprints;
using std::vector;
void Renderer11::AddSprite3D(RendererSprite* sprite, Vector3 vtx1, Vector3 vtx2, Vector3 vtx3, Vector3 vtx4, Vector4 color, float rotation, float scale, float width, float height, BLEND_MODES blendMode) {
if (m_nextSprite >= MAX_SPRITES)
return;
scale = 1.0f;
width *= scale;
height *= scale;
RendererSpriteToDraw* spr = &m_spritesBuffer[m_nextSprite++];
spr->Type = RENDERER_SPRITE_TYPE::SPRITE_TYPE_3D;
spr->Sprite = sprite;
spr->vtx1 = vtx1;
spr->vtx2 = vtx2;
spr->vtx3 = vtx3;
spr->vtx4 = vtx4;
spr->color = color;
spr->Rotation = rotation;
spr->Scale = scale;
spr->Width = width;
spr->Height = height;
spr->BlendMode = blendMode;
m_spritesToDraw.push_back(spr);
}
void Renderer11::drawEnergyArcs() {
for (int i = 0; i < MAX_GUNFLASH; i++) {
ENERGY_ARC* arc = &EnergyArcs[i];
if (arc->life > 0) {
Vector3 start = Vector3(arc->pos1.x, arc->pos1.y, arc->pos1.z);
Vector3 end = Vector3(arc->pos4.x, arc->pos4.y, arc->pos4.z);
if (!(arc->flags & ENERGY_ARC_NO_RANDOMIZE)) {
start += Vector3(rand() % 32 - 16, rand() % 32 - 16, rand() % 32 - 16);
end += Vector3(rand() % 64 - 32, rand() % 64 - 32, rand() % 64 - 32);
}
Vector3 direction = (end - start);
direction.Normalize();
float length = Vector3::Distance(start, end);
int numSegments = (length / arc->segmentSize) + 1;
Vector3 pos1 = start;
float delta = 2 * PI / numSegments;
float deltaAmplitude = arc->sAmplitude / 2 / 5;
float amplitude = arc->amplitude + deltaAmplitude * arc->direction;
if (amplitude > arc->sAmplitude / 2) {
amplitude = arc->sAmplitude / 2;
arc->direction = -1;
} else if (amplitude < -arc->sAmplitude / 2) {
amplitude = -arc->sAmplitude / 2;
arc->direction = 1;
}
arc->amplitude = amplitude;
float alpha = (float)arc->life / (float)arc->sLife;
Matrix rotationMatrix = Matrix::CreateFromAxisAngle(direction, TO_RAD(arc->rotation));
for (int j = 0; j < numSegments; j++) {
float shift1 = arc->amplitude / 2 * sin(delta * j);
float shift2 = arc->amplitude / 2 * sin(delta * (j + 1));
Vector3 sv1 = Vector3(0, shift1, 0);
Vector3 sv2 = Vector3(0, shift2, 0);
sv1 = Vector3::Transform(sv1, rotationMatrix);
sv2 = Vector3::Transform(sv2, rotationMatrix);
Vector3 pos1 = start + direction * (length / numSegments) * j + sv1;
Vector3 pos2 = start + direction * (length / numSegments) * (j + 1) + sv2;
Vector3 c = (pos1 + pos2) / 2.0f;
Vector3 d = pos2 - pos1;
d.Normalize();
AddSpriteBillboardConstrained(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + SPR_LIGHTHING],
c,
Vector4(arc->r / 255.0f, arc->g / 255.0f, arc->b / 255.0f, alpha),
SPRITE_ROTATION_90_DEGREES,
1.0f,
32.0f,
Vector3::Distance(pos1, pos2),
BLENDMODE_ALPHABLEND,
d);
}
}
}
}
void Renderer11::drawSmokes() {
for (int i = 0; i < 32; i++) {
SMOKE_SPARKS* spark = &SmokeSparks[i];
if (spark->on) {
AddSpriteBillboard(&m_sprites[spark->def],
Vector3(spark->x, spark->y, spark->z),
Vector4(spark->shade / 255.0f, spark->shade / 255.0f, spark->shade / 255.0f, 1.0f),
TO_RAD(spark->rotAng), spark->scalar, spark->size * 4.0f, spark->size * 4.0f,
BLENDMODE_ALPHABLEND);
}
}
}
void Renderer11::AddSpriteBillboard(RendererSprite* sprite, Vector3 pos, Vector4 color, float rotation, float scale, float width, float height, BLEND_MODES blendMode) {
if (m_nextSprite >= MAX_SPRITES)
return;
scale = 1.0f;
width *= scale;
height *= scale;
RendererSpriteToDraw* spr = &m_spritesBuffer[m_nextSprite++];
spr->Type = RENDERER_SPRITE_TYPE::SPRITE_TYPE_BILLBOARD;
spr->Sprite = sprite;
spr->pos = pos;
spr->color = color;
spr->Rotation = rotation;
spr->Scale = scale;
spr->Width = width;
spr->Height = height;
spr->BlendMode = blendMode;
m_spritesToDraw.push_back(spr);
}
void Renderer11::AddSpriteBillboardConstrained(RendererSprite* sprite, Vector3 pos, Vector4 color, float rotation, float scale, float width, float height, BLEND_MODES blendMode, Vector3 constrainAxis) {
if (m_nextSprite >= MAX_SPRITES)
return;
scale = 1.0f;
width *= scale;
height *= scale;
RendererSpriteToDraw* spr = &m_spritesBuffer[m_nextSprite++];
spr->Type = RENDERER_SPRITE_TYPE::SPRITE_TYPE_BILLBOARD_CUSTOM;
spr->Sprite = sprite;
spr->pos = pos;
spr->color = color;
spr->Rotation = rotation;
spr->Scale = scale;
spr->Width = width;
spr->Height = height;
spr->BlendMode = blendMode;
spr->ConstrainAxis = constrainAxis;
m_spritesToDraw.push_back(spr);
}
void Renderer11::AddSpriteBillboardConstrainedLookAt(RendererSprite* sprite, DirectX::SimpleMath::Vector3 pos, DirectX::SimpleMath::Vector4 color, float rotation, float scale, float width, float height, BLEND_MODES blendMode, DirectX::SimpleMath::Vector3 lookAtAxis) {
if (m_nextSprite >= MAX_SPRITES)
return;
scale = 1.0f;
width *= scale;
height *= scale;
RendererSpriteToDraw* spr = &m_spritesBuffer[m_nextSprite++];
spr->Type = RENDERER_SPRITE_TYPE::SPRITE_TYPE_BILLBOARD_LOOKAT;
spr->Sprite = sprite;
spr->pos = pos;
spr->color = color;
spr->Rotation = rotation;
spr->Scale = scale;
spr->Width = width;
spr->Height = height;
spr->BlendMode = blendMode;
spr->LookAtAxis = lookAtAxis;
m_spritesToDraw.push_back(spr);
}
void Renderer11::drawFires() {
for (int k = 0; k < MAX_FIRE_LIST; k++) {
FIRE_LIST* fire = &Fires[k];
if (fire->on) {
for (int i = 0; i < MAX_SPARKS_FIRE; i++) {
FIRE_SPARKS* spark = &FireSparks[i];
if (spark->on)
AddSpriteBillboard(&m_sprites[spark->def], Vector3(fire->x + spark->x, fire->y + spark->y, fire->z + spark->z), Vector4(spark->r / 255.0f, spark->g / 255.0f, spark->b / 255.0f, 1.0f), TO_RAD(spark->rotAng), spark->scalar, spark->size * 4.0f, spark->size * 4.0f, BLENDMODE_ALPHABLEND);
}
}
}
}
void Renderer11::drawSparks() {
PHD_VECTOR nodePos;
for (int i = 0; i < MAX_NODE; i++)
NodeOffsets[i].gotIt = false;
for (int i = 0; i < MAX_SPARKS; i++) {
SPARKS* spark = &Sparks[i];
if (spark->on) {
if (spark->flags & SP_DEF) {
Vector3 pos = Vector3(spark->x, spark->y, spark->z);
if (spark->flags & SP_FX) {
FX_INFO* fx = &EffectList[spark->fxObj];
pos.x += fx->pos.xPos;
pos.y += fx->pos.yPos;
pos.z += fx->pos.zPos;
if ((spark->sLife - spark->life) > (rand() & 7) + 4) {
spark->flags &= ~SP_FX;
spark->x = pos.x;
spark->y = pos.y;
spark->z = pos.z;
}
} else if (!(spark->flags & SP_ITEM)) {
pos.x = spark->x;
pos.y = spark->y;
pos.z = spark->z;
} else {
ITEM_INFO* item = &g_Level.Items[spark->fxObj];
if (spark->flags & SP_NODEATTACH) {
if (NodeOffsets[spark->nodeNumber].gotIt) {
nodePos.x = NodeVectors[spark->nodeNumber].x;
nodePos.y = NodeVectors[spark->nodeNumber].y;
nodePos.z = NodeVectors[spark->nodeNumber].z;
} else {
nodePos.x = NodeOffsets[spark->nodeNumber].x;
nodePos.y = NodeOffsets[spark->nodeNumber].y;
nodePos.z = NodeOffsets[spark->nodeNumber].z;
int meshNum = NodeOffsets[spark->nodeNumber].meshNum;
if (meshNum >= 0)
GetJointAbsPosition(item, &nodePos, meshNum);
else
GetLaraJointPosition(&nodePos, -meshNum);
NodeOffsets[spark->nodeNumber].gotIt = true;
NodeVectors[spark->nodeNumber].x = nodePos.x;
NodeVectors[spark->nodeNumber].y = nodePos.y;
NodeVectors[spark->nodeNumber].z = nodePos.z;
}
pos.x += nodePos.x;
pos.y += nodePos.y;
pos.z += nodePos.z;
if (spark->sLife - spark->life > (rand() & 3) + 8) {
spark->flags &= ~SP_ITEM;
spark->x = pos.x;
spark->y = pos.y;
spark->z = pos.z;
}
} else {
pos.x += item->pos.xPos;
pos.y += item->pos.yPos;
pos.z += item->pos.zPos;
}
}
AddSpriteBillboard(&m_sprites[spark->def],
pos,
Vector4(spark->r / 255.0f, spark->g / 255.0f, spark->b / 255.0f, 1.0f),
TO_RAD(spark->rotAng), spark->scalar, spark->size, spark->size,
BLENDMODE_ALPHABLEND);
} else {
Vector3 pos = Vector3(spark->x, spark->y, spark->z);
Vector3 v = Vector3(spark->xVel, spark->yVel, spark->zVel);
v.Normalize();
//AddSpriteBillboardConstrained(m_sprites[Objects[ID_SPARK_SPRITE].meshIndex], pos, Vector4(spark->r / 255.0f, spark->g / 255.0f, spark->b / 255.0f, 1.0f), TO_RAD(spark->rotAng), spark->scalar, spark., spark->size, BLENDMODE_ALPHABLEND, v);
AddLine3D(Vector3(spark->x, spark->y, spark->z), Vector3(spark->x + v.x * 24.0f, spark->y + v.y * 24.0f, spark->z + v.z * 24.0f), Vector4(spark->r / 255.0f, spark->g / 255.0f, spark->b / 255.0f, 1.0f));
}
}
}
}
void Renderer11::drawSplahes() {
constexpr size_t NUM_POINTS = 9;
for (int i = 0; i < MAX_SPLASHES; i++) {
SPLASH_STRUCT& splash = Splashes[i];
if (splash.isActive) {
constexpr float alpha = 360 / NUM_POINTS;
byte color = (splash.life >= 32 ? 128 : (byte)((splash.life / 32.0f) * 128));
if (!splash.isRipple) {
if (splash.heightSpeed < 0 && splash.height < 1024) {
float multiplier = splash.height / 1024.0f;
color = (float)color * multiplier;
}
}
float innerRadius = splash.innerRad;
float outerRadius = splash.outerRad;
float xInner;
float zInner;
float xOuter;
float zOuter;
float x2Inner;
float z2Inner;
float x2Outer;
float z2Outer;
float yInner = splash.y;
float yOuter = splash.y - splash.height;
for (int i = 0; i < NUM_POINTS; i++) {
xInner = innerRadius * sin(alpha * i * PI / 180);
zInner = innerRadius * cos(alpha * i * PI / 180);
xOuter = outerRadius * sin(alpha * i * PI / 180);
zOuter = outerRadius * cos(alpha * i * PI / 180);
xInner += splash.x;
zInner += splash.z;
xOuter += splash.x;
zOuter += splash.z;
int j = (i + 1) % NUM_POINTS;
x2Inner = innerRadius * sin(alpha * j * PI / 180);
x2Inner += splash.x;
z2Inner = innerRadius * cos(alpha * j * PI / 180);
z2Inner += splash.z;
x2Outer = outerRadius * sin(alpha * j * PI / 180);
x2Outer += splash.x;
z2Outer = outerRadius * cos(alpha * j * PI / 180);
z2Outer += splash.z;
AddSprite3D(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + splash.spriteSequenceStart + (int)splash.animationPhase], Vector3(xOuter, yOuter, zOuter), Vector3(x2Outer, yOuter, z2Outer), Vector3(x2Inner, yInner, z2Inner), Vector3(xInner, yInner, zInner), Vector4(color / 255.0f, color / 255.0f, color / 255.0f, 1.0f), 0, 1, 0, 0, BLENDMODE_ALPHABLEND);
}
}
}
}
void Renderer11::drawBubbles() {
for (int i = 0; i < MAX_BUBBLES; i++) {
BUBBLE_STRUCT* bubble = &Bubbles[i];
if (bubble->active)
AddSpriteBillboard(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + bubble->spriteNum], Vector3(bubble->worldPosition.x, bubble->worldPosition.y, bubble->worldPosition.z), bubble->color, bubble->rotation, 1.0f, bubble->size * 0.5f, bubble->size * 0.5f, BLENDMODE_ALPHABLEND);
}
}
void Renderer11::drawDrips() {
for (int i = 0; i < MAX_DRIPS; i++) {
DRIP_STRUCT* drip = &Drips[i];
if (drip->on) {
AddLine3D(Vector3(drip->x, drip->y, drip->z), Vector3(drip->x, drip->y + 24.0f, drip->z), Vector4(drip->r / 255.0f, drip->g / 255.0f, drip->b / 255.0f, 1.0f));
}
}
}
void Renderer11::drawRipples() {
for (int i = 0; i < MAX_RIPPLES; i++) {
RIPPLE_STRUCT* ripple = &Ripples[i];
if (ripple->active) {
float y = ripple->worldPos.y;
if (ripple->isBillboard) {
AddSpriteBillboard(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + ripple->SpriteID], ripple->worldPos, ripple->currentColor, ripple->rotation, 1, ripple->size, ripple->size, BLENDMODE_ALPHABLEND);
} else {
AddSpriteBillboardConstrainedLookAt(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + ripple->SpriteID], ripple->worldPos, ripple->currentColor, ripple->rotation, 1, ripple->size*2, ripple->size*2, BLENDMODE_ALPHABLEND, Vector3(0,-1,0));
//AddSprite3D(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + ripple->SpriteID], Vector3(x1, y, z2), Vector3(x2, y, z2), Vector3(x2, y, z1), Vector3(x1, y, z1), ripple->currentColor, 0.0f, 1.0f, ripple->size, ripple->size, BLENDMODE_ALPHABLEND);
}
}
}
}
void Renderer11::drawShockwaves() {
for (int i = 0; i < MAX_SHOCKWAVE; i++) {
SHOCKWAVE_STRUCT* shockwave = &ShockWaves[i];
if (shockwave->life) {
byte color = shockwave->life * 8;
int dl = shockwave->outerRad - shockwave->innerRad;
Matrix rotationMatrix = Matrix::CreateRotationX(TO_RAD(shockwave->xRot));
Vector3 pos = Vector3(shockwave->x, shockwave->y, shockwave->z);
// Inner circle
float angle = PI / 32.0f;
float c = cos(angle);
float s = sin(angle);
float x1 = (shockwave->innerRad * c);
float z1 = (shockwave->innerRad * s);
float x4 = (shockwave->outerRad * c);
float z4 = (shockwave->outerRad * s);
angle -= PI / 8.0f;
Vector3 p1 = Vector3(x1, 0, z1);
Vector3 p4 = Vector3(x4, 0, z4);
p1 = Vector3::Transform(p1, rotationMatrix);
p4 = Vector3::Transform(p4, rotationMatrix);
for (int j = 0; j < 16; j++) {
c = cos(angle);
s = sin(angle);
float x2 = (shockwave->innerRad * c);
float z2 = (shockwave->innerRad * s);
float x3 = (shockwave->outerRad * c);
float z3 = (shockwave->outerRad * s);
angle -= PI / 8.0f;
Vector3 p2 = Vector3(x2, 0, z2);
Vector3 p3 = Vector3(x3, 0, z3);
p2 = Vector3::Transform(p2, rotationMatrix);
p3 = Vector3::Transform(p3, rotationMatrix);
AddSprite3D(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + SPR_SPLASH],
pos + p1,
pos + p2,
pos + p3,
pos + p4,
Vector4(
shockwave->r * shockwave->life / 255.0f / 64.0f,
shockwave->g * shockwave->life / 255.0f / 64.0f,
shockwave->b * shockwave->life / 255.0f / 64.0f,
1.0f),
0, 1, 0, 0, BLENDMODE_ALPHABLEND);
p1 = p2;
p4 = p3;
}
}
}
}
void Renderer11::drawBlood() {
for (int i = 0; i < 32; i++) {
BLOOD_STRUCT* blood = &Blood[i];
if (blood->on) {
AddSpriteBillboard(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + SPR_BLOOD],
Vector3(blood->x, blood->y, blood->z),
Vector4(blood->shade / 255.0f, blood->shade * 0, blood->shade * 0, 1.0f),
TO_RAD(blood->rotAng), 1.0f, blood->size * 8.0f, blood->size * 8.0f,
BLENDMODE_ALPHABLEND);
}
}
}
bool Renderer11::drawGunFlashes() {
if (!Lara.rightArm.flash_gun && !Lara.leftArm.flash_gun)
return true;
Matrix world;
Matrix translation;
Matrix rotation;
RendererObject& laraObj = *m_moveableObjects[ID_LARA];
RendererObject& laraSkin = *m_moveableObjects[ID_LARA_SKIN];
OBJECT_INFO* obj = &Objects[0];
RendererRoom& const room = m_rooms[LaraItem->roomNumber];
RendererItem* item = &m_items[Lara.itemNumber];
m_stItem.AmbientLight = room.AmbientLight;
memcpy(m_stItem.BonesMatrices, &Matrix::Identity, sizeof(Matrix));
m_stLights.NumLights = item->Lights.size();
for (int j = 0; j < item->Lights.size(); j++)
memcpy(&m_stLights.Lights[j], item->Lights[j], sizeof(ShaderLight));
updateConstantBuffer<CLightBuffer>(m_cbLights, m_stLights);
m_context->PSSetConstantBuffers(2, 1, &m_cbLights);
m_stMisc.AlphaTest = true;
updateConstantBuffer<CMiscBuffer>(m_cbMisc, m_stMisc);
m_context->PSSetConstantBuffers(3, 1, &m_cbMisc);
short length = 0;
short zOffset = 0;
short rotationX = 0;
m_context->OMSetBlendState(m_states->Additive(), NULL, 0xFFFFFFFF);
m_context->OMSetDepthStencilState(m_states->DepthRead(), 0);
if (Lara.weaponItem != WEAPON_FLARE && Lara.weaponItem != WEAPON_SHOTGUN && Lara.weaponItem != WEAPON_CROSSBOW) {
switch (Lara.weaponItem) {
case WEAPON_REVOLVER:
length = 192;
zOffset = 68;
rotationX = -14560;
break;
case WEAPON_UZI:
length = 190;
zOffset = 50;
break;
case WEAPON_HK:
length = 300;
zOffset = 92;
rotationX = -14560;
break;
default:
case WEAPON_PISTOLS:
length = 180;
zOffset = 40;
rotationX = -16830;
break;
}
OBJECT_INFO* flashObj = &Objects[ID_GUN_FLASH];
RendererObject& flashMoveable = *m_moveableObjects[ID_GUN_FLASH];
RendererMesh* flashMesh = flashMoveable.ObjectMeshes[0];
for (int b = 0; b < NUM_BUCKETS; b++) {
RendererBucket* flashBucket = &flashMesh->Buckets[b];
if (flashBucket->Vertices.size() != 0) {
Matrix offset = Matrix::CreateTranslation(0, length, zOffset);
Matrix rotation2 = Matrix::CreateRotationX(TO_RAD(rotationX));
if (Lara.leftArm.flash_gun) {
world = laraObj.AnimationTransforms[LM_LHAND] * m_LaraWorldMatrix;
world = offset * world;
world = rotation2 * world;
m_stItem.World = world;
updateConstantBuffer<CItemBuffer>(m_cbItem, m_stItem);
m_context->VSSetConstantBuffers(1, 1, &m_cbItem);
m_context->DrawIndexed(flashBucket->Indices.size(), flashBucket->StartIndex, 0);
m_numDrawCalls++;
}
if (Lara.rightArm.flash_gun) {
world = laraObj.AnimationTransforms[LM_RHAND] * m_LaraWorldMatrix;
world = offset * world;
world = rotation2 * world;
m_stItem.World = world;
updateConstantBuffer<CItemBuffer>(m_cbItem, m_stItem);
m_context->VSSetConstantBuffers(1, 1, &m_cbItem);
m_context->DrawIndexed(flashBucket->Indices.size(), flashBucket->StartIndex, 0);
m_numDrawCalls++;
}
}
}
}
m_context->OMSetBlendState(m_states->Opaque(), NULL, 0xFFFFFFFF);
m_context->OMSetDepthStencilState(m_states->DepthDefault(), 0);
return true;
}
bool Renderer11::drawBaddieGunflashes() {
rand();
rand();
rand();
rand();
for (int i = 0; i < m_itemsToDraw.size(); i++) {
RendererItem* item = m_itemsToDraw[i];
// Does the item need gunflash?
OBJECT_INFO* obj = &Objects[item->Item->objectNumber];
if (obj->biteOffset == -1 || !item->Item->firedWeapon)
continue;
RendererRoom& const room = m_rooms[item->Item->roomNumber];
RendererObject& flashMoveable = *m_moveableObjects[ID_GUN_FLASH];
m_stItem.AmbientLight = room.AmbientLight;
memcpy(m_stItem.BonesMatrices, &Matrix::Identity, sizeof(Matrix));
m_stLights.NumLights = item->Lights.size();
for (int j = 0; j < item->Lights.size(); j++)
memcpy(&m_stLights.Lights[j], item->Lights[j], sizeof(ShaderLight));
updateConstantBuffer<CLightBuffer>(m_cbLights, m_stLights);
m_context->PSSetConstantBuffers(2, 1, &m_cbLights);
m_stMisc.AlphaTest = true;
updateConstantBuffer<CMiscBuffer>(m_cbMisc, m_stMisc);
m_context->PSSetConstantBuffers(3, 1, &m_cbMisc);
m_context->OMSetBlendState(m_states->Additive(), NULL, 0xFFFFFFFF);
m_context->OMSetDepthStencilState(m_states->DepthRead(), 0);
BITE_INFO* bites[2] = {
&EnemyBites[obj->biteOffset],
&EnemyBites[obj->biteOffset + 1]
};
int numBites = (bites[0]->meshNum < 0) + 1;
for (int k = 0; k < numBites; k++) {
int joint = abs(bites[k]->meshNum);
RendererMesh* flashMesh = flashMoveable.ObjectMeshes[0];
for (int b = 0; b < NUM_BUCKETS; b++) {
RendererBucket* flashBucket = &flashMesh->Buckets[b];
if (flashBucket->Vertices.size() != 0) {
Matrix offset = Matrix::CreateTranslation(bites[k]->x, bites[k]->y, bites[k]->z);
Matrix rotationX = Matrix::CreateRotationX(TO_RAD(49152));
Matrix rotationZ = Matrix::CreateRotationZ(TO_RAD(2 * GetRandomControl()));
Matrix world = item->AnimationTransforms[joint] * item->World;
world = rotationX * world;
world = offset * world;
world = rotationZ * world;
m_stItem.World = world;
updateConstantBuffer<CItemBuffer>(m_cbItem, m_stItem);
m_context->VSSetConstantBuffers(1, 1, &m_cbItem);
m_context->DrawIndexed(flashBucket->Indices.size(), flashBucket->StartIndex, 0);
m_numDrawCalls++;
}
}
}
}
m_context->OMSetBlendState(m_states->Opaque(), NULL, 0xFFFFFFFF);
m_context->OMSetDepthStencilState(m_states->DepthDefault(), 0);
return true;
}
Texture2D Renderer11::CreateDefaultNormalTexture() {
vector<byte> data = {128,128,255,1};
return Texture2D(m_device,1,1,data.data());
}
void Renderer11::drawFootprints() {
const int spriteIndex = Objects[ID_MISC_SPRITES].meshIndex + 1;
if (g_Level.Sprites.size() > spriteIndex) {
for (auto i = footprints.begin(); i != footprints.end(); i++) {
FOOTPRINT_STRUCT& footprint = *i;
if (footprint.active) {
Matrix rot = Matrix::CreateRotationY(TO_RAD(footprint.pos.yRot) + PI);
Vector3 p1 = Vector3(-64, 0, -64);
Vector3 p2 = Vector3(64, 0, -64);
Vector3 p3 = Vector3(64, 0, 64);
Vector3 p4 = Vector3(-64, 0, 64);
p1 = XMVector3Transform(p1, rot);
p2 = XMVector3Transform(p2, rot);
p3 = XMVector3Transform(p3, rot);
p4 = XMVector3Transform(p4, rot);
p1 += Vector3(footprint.pos.xPos, footprint.pos.yPos, footprint.pos.zPos);
p2 += Vector3(footprint.pos.xPos, footprint.pos.yPos, footprint.pos.zPos);
p3 += Vector3(footprint.pos.xPos, footprint.pos.yPos, footprint.pos.zPos);
p4 += Vector3(footprint.pos.xPos, footprint.pos.yPos, footprint.pos.zPos);
AddSprite3D(&m_sprites[spriteIndex], p1, p2, p3, p4, Vector4(footprint.opacity / 255.0f, footprint.opacity / 255.0f, footprint.opacity / 255.0f, footprint.opacity / 255.0f), 0, 1, 1, 1, BLENDMODE_SUBTRACTIVE);
}
}
}
}
void Renderer11::drawUnderwaterDust() {
if (m_firstUnderwaterDustParticles) {
for (int i = 0; i < NUM_UNDERWATER_DUST_PARTICLES; i++)
m_underwaterDustParticles[i].Reset = true;
}
for (int i = 0; i < NUM_UNDERWATER_DUST_PARTICLES; i++) {
RendererUnderwaterDustParticle* dust = &m_underwaterDustParticles[i];
if (dust->Reset) {
dust->X = LaraItem->pos.xPos + rand() % UNDERWATER_DUST_PARTICLES_RADIUS - UNDERWATER_DUST_PARTICLES_RADIUS / 2.0f;
dust->Y = LaraItem->pos.yPos + rand() % UNDERWATER_DUST_PARTICLES_RADIUS - UNDERWATER_DUST_PARTICLES_RADIUS / 2.0f;
dust->Z = LaraItem->pos.zPos + rand() % UNDERWATER_DUST_PARTICLES_RADIUS - UNDERWATER_DUST_PARTICLES_RADIUS / 2.0f;
// Check if water room
short roomNumber = Camera.pos.roomNumber;
FLOOR_INFO* floor = GetFloor(dust->X, dust->Y, dust->Z, &roomNumber);
if (!isRoomUnderwater(roomNumber))
continue;
if (!isInRoom(dust->X, dust->Y, dust->Z, roomNumber)) {
dust->Reset = true;
continue;
}
dust->Life = 0;
dust->Reset = false;
}
dust->Life++;
byte color = (dust->Life > 16 ? 32 - dust->Life : dust->Life) * 4;
AddSpriteBillboard(&m_sprites[Objects[ID_DEFAULT_SPRITES].meshIndex + SPR_UNDERWATERDUST], Vector3(dust->X, dust->Y, dust->Z), Vector4(color / 255.0f, color / 255.0f, color / 255.0f, 1.0f), 0.0f, 1.0f, 12, 12, BLENDMODE_ALPHABLEND);
if (dust->Life >= 32)
dust->Reset = true;
}
m_firstUnderwaterDustParticles = false;
return;
}
bool Renderer11::drawSprites() {
UINT stride = sizeof(RendererVertex);
UINT offset = 0;
m_context->RSSetState(m_states->CullNone());
m_context->OMSetDepthStencilState(m_states->DepthRead(), 0);
m_context->VSSetShader(m_vsSprites, NULL, 0);
m_context->PSSetShader(m_psSprites, NULL, 0);
m_stMisc.AlphaTest = true;
updateConstantBuffer<CMiscBuffer>(m_cbMisc, m_stMisc);
m_context->PSSetConstantBuffers(3, 1, &m_cbMisc);
m_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
m_context->IASetInputLayout(m_inputLayout);
m_context->IASetVertexBuffers(0, 1, quadVertexBuffer.GetAddressOf(), &stride, &offset);
for (int b = 0; b < 4; b++) {
BLEND_MODES currentBlendMode = (BLEND_MODES)b;
int numSpritesToDraw = m_spritesToDraw.size();
int lastSprite = 0;
switch (currentBlendMode) {
case BLENDMODE_ALPHABLEND:
m_context->OMSetBlendState(m_states->Additive(), NULL, 0xFFFFFFFF);
break;
case BLENDMODE_ALPHATEST:
m_context->OMSetBlendState(m_states->Additive(), NULL, 0xFFFFFFFF);
break;
case BLENDMODE_OPAQUE:
m_context->OMSetBlendState(m_states->Opaque(), NULL, 0xFFFFFFFF);
break;
case BLENDMODE_SUBTRACTIVE:
m_context->OMSetBlendState(m_subtractiveBlendState, NULL, 0xFFFFFFFF);
break;
}
for (int i = 0; i < numSpritesToDraw; i++) {
Matrix billboardMatrix;
RendererSpriteToDraw* spr = m_spritesToDraw[i];
if (spr->BlendMode != currentBlendMode)
continue;
m_context->PSSetShaderResources(0, 1, spr->Sprite->Texture->ShaderResourceView.GetAddressOf());
ID3D11SamplerState* sampler = m_states->AnisotropicClamp();
m_context->PSSetSamplers(0, 1, &sampler);
Matrix scale = Matrix::CreateScale((spr->Width)*spr->Scale, (spr->Height) * spr->Scale, 1);
if (spr->Type == RENDERER_SPRITE_TYPE::SPRITE_TYPE_BILLBOARD) {
Matrix rotation = Matrix::CreateRotationZ(spr->Rotation);
//Extract Camera Up Vector and create Billboard matrix.
Vector3 cameraUp = Vector3(View._12, View._22, View._32);
Matrix billboardMatrix = scale* rotation *Matrix::CreateBillboard(spr->pos, Vector3(Camera.pos.x, Camera.pos.y, Camera.pos.z), cameraUp);
m_stSprite.billboardMatrix = billboardMatrix;
m_stSprite.color = spr->color;
m_stSprite.isBillboard = true;
updateConstantBuffer<CSpriteBuffer>(m_cbSprite, m_stSprite);
m_context->VSSetConstantBuffers(4, 1, &m_cbSprite);
m_context->Draw(4, 0);
} else if (spr->Type == RENDERER_SPRITE_TYPE::SPRITE_TYPE_BILLBOARD_CUSTOM) {
Matrix rotation = Matrix::CreateRotationZ(spr->Rotation);
Vector3 quadForward = Vector3(0, 0, 1);
billboardMatrix = scale*rotation * Matrix::CreateConstrainedBillboard(
spr->pos,
Vector3(Camera.pos.x, Camera.pos.y, Camera.pos.z),
spr->ConstrainAxis,
NULL,
&quadForward);
m_stSprite.billboardMatrix = billboardMatrix;
m_stSprite.color = spr->color;
m_stSprite.isBillboard = true;
updateConstantBuffer<CSpriteBuffer>(m_cbSprite, m_stSprite);
m_context->VSSetConstantBuffers(4, 1, &m_cbSprite);
m_context->Draw(4, 0);
} else if (spr->Type == RENDERER_SPRITE_TYPE::SPRITE_TYPE_BILLBOARD_LOOKAT) {
Matrix translation = Matrix::CreateTranslation(spr->pos);
Matrix rotation = Matrix::CreateLookAt(Vector3::Zero,spr->LookAtAxis,Vector3::UnitZ);
billboardMatrix = scale * rotation * translation;
m_stSprite.billboardMatrix = billboardMatrix;
m_stSprite.color = spr->color;
m_stSprite.isBillboard = true;
updateConstantBuffer<CSpriteBuffer>(m_cbSprite, m_stSprite);
m_context->VSSetConstantBuffers(4, 1, &m_cbSprite);
m_context->Draw(4, 0);
}else if (spr->Type == RENDERER_SPRITE_TYPE::SPRITE_TYPE_3D) {
m_primitiveBatch->Begin();
Vector3 p0t = spr->vtx1;
Vector3 p1t = spr->vtx2;
Vector3 p2t = spr->vtx3;
Vector3 p3t = spr->vtx4;
RendererVertex v0;
v0.Position.x = p0t.x;
v0.Position.y = p0t.y;
v0.Position.z = p0t.z;
v0.UV.x = spr->Sprite->UV[0].x;
v0.UV.y = spr->Sprite->UV[0].y;
v0.Color = spr->color;
RendererVertex v1;
v1.Position.x = p1t.x;
v1.Position.y = p1t.y;
v1.Position.z = p1t.z;
v1.UV.x = spr->Sprite->UV[1].x;
v1.UV.y = spr->Sprite->UV[1].y;
v1.Color = spr->color;
RendererVertex v2;
v2.Position.x = p2t.x;
v2.Position.y = p2t.y;
v2.Position.z = p2t.z;
v2.UV.x = spr->Sprite->UV[2].x;
v2.UV.y = spr->Sprite->UV[2].y;
v2.Color = spr->color;
RendererVertex v3;
v3.Position.x = p3t.x;
v3.Position.y = p3t.y;
v3.Position.z = p3t.z;
v3.UV.x = spr->Sprite->UV[3].x;
v3.UV.y = spr->Sprite->UV[3].y;
v3.Color = spr->color;
m_stSprite.color = spr->color;
m_stSprite.isBillboard = false;
updateConstantBuffer<CSpriteBuffer>(m_cbSprite, m_stSprite);
m_context->VSSetConstantBuffers(4, 1, &m_cbSprite);
m_primitiveBatch->DrawQuad(v0, v1, v2, v3);
m_primitiveBatch->End();
}
}
}
m_context->RSSetState(m_states->CullCounterClockwise());
m_context->OMSetDepthStencilState(m_states->DepthDefault(), 0);
return true;
}
bool Renderer11::drawEffect(RendererEffect* effect, bool transparent) {
UINT stride = sizeof(RendererVertex);
UINT offset = 0;
int firstBucket = (transparent ? 2 : 0);
int lastBucket = (transparent ? 4 : 2);
RendererRoom& const room = m_rooms[effect->Effect->roomNumber];
//RendererObject * moveableObj = m_moveableObjects[effect->Effect->objectNumber];
m_stItem.World = effect->World;
m_stItem.Position = Vector4(effect->Effect->pos.xPos, effect->Effect->pos.yPos, effect->Effect->pos.zPos, 1.0f);
m_stItem.AmbientLight = room.AmbientLight;
Matrix matrices[1] = { Matrix::Identity };
memcpy(m_stItem.BonesMatrices, matrices, sizeof(Matrix));
updateConstantBuffer<CItemBuffer>(m_cbItem, m_stItem);
m_context->VSSetConstantBuffers(1, 1, &m_cbItem);
m_stLights.NumLights = effect->Lights.size();
for (int j = 0; j < effect->Lights.size(); j++)
memcpy(&m_stLights.Lights[j], effect->Lights[j], sizeof(ShaderLight));
updateConstantBuffer<CLightBuffer>(m_cbLights, m_stLights);
m_context->PSSetConstantBuffers(2, 1, &m_cbLights);
m_stMisc.AlphaTest = !transparent;
updateConstantBuffer<CMiscBuffer>(m_cbMisc, m_stMisc);
m_context->PSSetConstantBuffers(3, 1, &m_cbMisc);
RendererMesh* mesh = effect->Mesh;
for (int j = firstBucket; j < lastBucket; j++) {
RendererBucket* bucket = &mesh->Buckets[j];
if (bucket->Vertices.size() == 0)
continue;
// Draw vertices
m_context->DrawIndexed(bucket->Indices.size(), bucket->StartIndex, 0);
m_numDrawCalls++;
}
return true;
}
bool Renderer11::drawEffects(bool transparent) {
UINT stride = sizeof(RendererVertex);
UINT offset = 0;
int firstBucket = (transparent ? 2 : 0);
int lastBucket = (transparent ? 4 : 2);
m_context->IASetVertexBuffers(0, 1, m_moveablesVertexBuffer.Buffer.GetAddressOf(), &stride, &offset);
m_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
m_context->IASetInputLayout(m_inputLayout);
m_context->IASetIndexBuffer(m_moveablesIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
for (int i = 0; i < m_effectsToDraw.size(); i++) {
RendererEffect* effect = m_effectsToDraw[i];
RendererRoom& const room = m_rooms[effect->Effect->roomNumber];
OBJECT_INFO* obj = &Objects[effect->Effect->objectNumber];
if (obj->drawRoutine && obj->loaded)
drawEffect(effect, transparent);
}
return true;
}
bool Renderer11::drawWaterfalls() {
UINT stride = sizeof(RendererVertex);
UINT offset = 0;
// Draw waterfalls
m_context->RSSetState(m_states->CullCounterClockwise());
for (int i = 0; i < m_itemsToDraw.size(); i++) {
RendererItem* item = m_itemsToDraw[i];
RendererRoom& const room = m_rooms[item->Item->roomNumber];
RendererObject& moveableObj = *m_moveableObjects[item->Item->objectNumber];
short objectNumber = item->Item->objectNumber;
if (objectNumber >= ID_WATERFALL1 && objectNumber <= ID_WATERFALLSS2) {
RendererRoom& const room = m_rooms[item->Item->roomNumber];
RendererObject& moveableObj = *m_moveableObjects[item->Item->objectNumber];
m_stItem.World = item->World;
m_stItem.Position = Vector4(item->Item->pos.xPos, item->Item->pos.yPos, item->Item->pos.zPos, 1.0f);
m_stItem.AmbientLight = room.AmbientLight; //Vector4::One * 0.1f; // room->AmbientLight;
memcpy(m_stItem.BonesMatrices, item->AnimationTransforms, sizeof(Matrix) * 32);
updateConstantBuffer<CItemBuffer>(m_cbItem, m_stItem);
m_context->VSSetConstantBuffers(1, 1, &m_cbItem);
m_stLights.NumLights = item->Lights.size();
for (int j = 0; j < item->Lights.size(); j++)
memcpy(&m_stLights.Lights[j], item->Lights[j], sizeof(ShaderLight));
updateConstantBuffer<CLightBuffer>(m_cbLights, m_stLights);
m_context->PSSetConstantBuffers(2, 1, &m_cbLights);
m_stMisc.AlphaTest = false;
updateConstantBuffer<CMiscBuffer>(m_cbMisc, m_stMisc);
m_context->PSSetConstantBuffers(3, 1, &m_cbMisc);
m_primitiveBatch->Begin();
for (int k = 0; k < moveableObj.ObjectMeshes.size(); k++) {
RendererMesh* mesh = moveableObj.ObjectMeshes[k];
for (int b = 0; b < NUM_BUCKETS; b++) {
RendererBucket* bucket = &mesh->Buckets[b];
if (bucket->Vertices.size() == 0)
continue;
for (int p = 0; p < bucket->Polygons.size(); p++) {
RendererPolygon* poly = &bucket->Polygons[p];
OBJECT_TEXTURE* texture = &g_Level.ObjectTextures[poly->TextureId];
int tile = texture->tileAndFlag & 0x7FFF;
if (poly->Shape == SHAPE_RECTANGLE) {
bucket->Vertices[poly->Indices[0]].UV.y = (texture->vertices[0].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
bucket->Vertices[poly->Indices[1]].UV.y = (texture->vertices[1].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
bucket->Vertices[poly->Indices[2]].UV.y = (texture->vertices[2].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
bucket->Vertices[poly->Indices[3]].UV.y = (texture->vertices[3].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
m_primitiveBatch->DrawQuad(bucket->Vertices[poly->Indices[0]],
bucket->Vertices[poly->Indices[1]],
bucket->Vertices[poly->Indices[2]],
bucket->Vertices[poly->Indices[3]]);
} else {
bucket->Vertices[poly->Indices[0]].UV.y = (texture->vertices[0].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
bucket->Vertices[poly->Indices[1]].UV.y = (texture->vertices[1].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
bucket->Vertices[poly->Indices[2]].UV.y = (texture->vertices[2].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
m_primitiveBatch->DrawTriangle(bucket->Vertices[poly->Indices[0]],
bucket->Vertices[poly->Indices[1]],
bucket->Vertices[poly->Indices[2]]);
}
}
}
}
m_primitiveBatch->End();
} else {
continue;
}
}
return true;
}
bool Renderer11::drawDebris(bool transparent) {
/*UINT cPasses = 1;
// First collect debrises
vector<RendererVertex> vertices;
for (int i = 0; i < NUM_DEBRIS; i++)
{
DEBRIS_STRUCT* debris = &Debris[i];
if (debris->on)
{
Matrix translation = Matrix::CreateTranslation(debris->x, debris->y, debris->z);
Matrix rotation = Matrix::CreateFromYawPitchRoll(TO_RAD(debris->yRot), TO_RAD(debris->xRot), 0);
Matrix world = rotation * translation;
OBJECT_TEXTURE* texture = &ObjectTextures[(int)(debris->textInfo) & 0x7FFF];
int tile = texture->tileAndFlag & 0x7FFF;
// Draw only debris of the current bucket
if (texture->attribute == 0 && transparent ||
texture->attribute == 1 && transparent ||
texture->attribute == 2 && !transparent)
continue;
RendererVertex vertex;
// Prepare the triangle
Vector3 p = Vector3(debris->xyzOffsets1[0], debris->xyzOffsets1[1], debris->xyzOffsets1[2]);
p = Vector3::Transform(p, world);
vertex.Position.x = p.x;
vertex.Position.y = p.y;
vertex.Position.z = p.z;
vertex.UV.x = (texture->vertices[0].x * 256.0f + 0.5f + GET_ATLAS_PAGE_X(tile)) / (float)TEXTURE_ATLAS_SIZE;
vertex.UV.y = (texture->vertices[0].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
vertex.Color.x = debris->pad[2] / 255.0f;
vertex.Color.y = debris->pad[3] / 255.0f;
vertex.Color.z = debris->pad[4] / 255.0f;
vertices.push_back(vertex);
p = Vector3(debris->xyzOffsets2[0], debris->xyzOffsets2[1], debris->xyzOffsets2[2]);
p = Vector3::Transform(p, world);
vertex.Position.x = p.x;
vertex.Position.y = p.y;
vertex.Position.z = p.z;
vertex.UV.x = (texture->vertices[1].x * 256.0f + 0.5f + GET_ATLAS_PAGE_X(tile)) / (float)TEXTURE_ATLAS_SIZE;
vertex.UV.y = (texture->vertices[1].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
vertex.Color.x = debris->pad[6] / 255.0f;
vertex.Color.y = debris->pad[7] / 255.0f;
vertex.Color.z = debris->pad[8] / 255.0f;
vertices.push_back(vertex);
p = Vector3(debris->xyzOffsets3[0], debris->xyzOffsets3[1], debris->xyzOffsets3[2]);
p = Vector3::Transform(p, world);
vertex.Position.x = p.x;
vertex.Position.y = p.y;
vertex.Position.z = p.z;
vertex.UV.x = (texture->vertices[2].x * 256.0f + 0.5f + GET_ATLAS_PAGE_X(tile)) / (float)TEXTURE_ATLAS_SIZE;
vertex.UV.y = (texture->vertices[2].y * 256.0f + 0.5f + GET_ATLAS_PAGE_Y(tile)) / (float)TEXTURE_ATLAS_SIZE;
vertex.Color.x = debris->pad[10] / 255.0f;
vertex.Color.y = debris->pad[11] / 255.0f;
vertex.Color.z = debris->pad[12] / 255.0f;
vertices.push_back(vertex);
}
}
// Check if no debris have to be drawn
if (vertices.size() == 0)
return true;
m_primitiveBatch->Begin();
// Set shaders
m_context->VSSetShader(m_vsStatics, NULL, 0);
m_context->PSSetShader(m_psStatics, NULL, 0);
// Set texture
m_context->PSSetShaderResources(0, 1, &m_textureAtlas->ShaderResourceView);
ID3D11SamplerState * sampler = m_states->AnisotropicClamp();
m_context->PSSetSamplers(0, 1, &sampler);
// Set camera matrices
m_stCameraMatrices.View = View.Transpose();
m_stCameraMatrices.Projection = Projection.Transpose();
updateConstantBuffer(m_cbCameraMatrices, &m_stCameraMatrices, sizeof(CCameraMatrixBuffer));
m_context->VSSetConstantBuffers(0, 1, &m_cbCameraMatrices);
m_stMisc.AlphaTest = !transparent;
updateConstantBuffer(m_cbMisc, &m_stMisc, sizeof(CMiscBuffer));
m_context->PSSetConstantBuffers(3, 1, &m_cbMisc);
m_stStatic.World = Matrix::Identity;
m_stStatic.Color = Vector4::One;
updateConstantBuffer(m_cbStatic, &m_stStatic, sizeof(CStaticBuffer));
m_context->VSSetConstantBuffers(1, 1, &m_cbStatic);
// Draw vertices
m_primitiveBatch->Draw(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST, vertices.data(), vertices.size());
m_numDrawCalls++;
m_primitiveBatch->End();
return true;
*/
extern vector<DebrisFragment> DebrisFragments;
vector<RendererVertex> vertices;
for (auto deb = DebrisFragments.begin(); deb != DebrisFragments.end(); deb++) {
if (deb->active) {
//AddLine3D(deb->worldPosition, deb->worldPosition + Vector3(0, 100, 0), Vector4(1, 1, 1, 1));
Matrix translation = Matrix::CreateTranslation(deb->worldPosition.x, deb->worldPosition.y, deb->worldPosition.z);
Matrix rotation = Matrix::CreateFromQuaternion(deb->rotation);
Matrix world = rotation * translation;
m_primitiveBatch->Begin();
m_context->VSSetShader(m_vsStatics, NULL, 0);
m_context->PSSetShader(m_psStatics, NULL, 0);
m_context->PSSetShaderResources(0, 1, (std::get<0>(m_staticsTextures[0])).ShaderResourceView.GetAddressOf());
ID3D11SamplerState* sampler = m_states->AnisotropicClamp();
m_context->PSSetSamplers(0, 1, &sampler);
//m_stCameraMatrices.View = View.Transpose();
//m_stCameraMatrices.Projection = Projection.Transpose();
//updateConstantBuffer(m_cbCameraMatrices, &m_stCameraMatrices, sizeof(CCameraMatrixBuffer));
//m_context->VSSetConstantBuffers(0, 1, &m_cbCameraMatrices);
m_stMisc.AlphaTest = !transparent;
updateConstantBuffer<CMiscBuffer>(m_cbMisc, m_stMisc);
m_context->PSSetConstantBuffers(3, 1, &m_cbMisc);
m_stStatic.World = world;
m_stStatic.Color = Vector4::One;
updateConstantBuffer<CStaticBuffer>(m_cbStatic, m_stStatic);
m_context->VSSetConstantBuffers(1, 1, &m_cbStatic);
RendererVertex vtx0 = deb->mesh.vertices[0];
RendererVertex vtx1 = deb->mesh.vertices[1];
RendererVertex vtx2 = deb->mesh.vertices[2];
vtx0.Color = m_rooms[deb->roomNumber].AmbientLight;
vtx1.Color = m_rooms[deb->roomNumber].AmbientLight;
vtx2.Color = m_rooms[deb->roomNumber].AmbientLight;
m_context->RSSetState(m_states->CullNone());
m_primitiveBatch->DrawTriangle(vtx0, vtx1, vtx2);
m_numDrawCalls++;
m_primitiveBatch->End();
}
}
return true;
}
bool Renderer11::drawSmokeParticles() {
using T5M::Effects::Smoke::SmokeParticles;
using T5M::Effects::Smoke::SmokeParticle;
for (int i = 0; i < SmokeParticles.size(); i++) {
SmokeParticle& s = SmokeParticles[i];
if (!s.active) continue;
AddSpriteBillboard(&m_sprites[Objects[ID_SMOKE_SPRITES].meshIndex + s.sprite], s.position, s.color, s.rotation, 1.0f, s.size, s.size, BLENDMODE_ALPHABLEND);
}
return true;
}
bool Renderer11::drawSparkParticles() {
using T5M::Effects::Spark::SparkParticle;
using T5M::Effects::Spark::SparkParticles;
extern std::array<SparkParticle, 64> SparkParticles;
for (int i = 0; i < SparkParticles.size(); i++) {
SparkParticle& s = SparkParticles[i];
if (!s.active) continue;
Vector3 v;
s.velocity.Normalize(v);
AddSpriteBillboardConstrained(&m_sprites[Objects[ID_SPARK_SPRITE].meshIndex], s.pos, s.color, 0, 1, s.width, s.height, BLENDMODE_ALPHABLEND, v);
}
return true;
}
bool Renderer11::drawDripParticles() {
using T5M::Effects::Drip::DripParticle;
using T5M::Effects::Drip::dripParticles;
using T5M::Effects::Drip::DRIP_WIDTH;
for (int i = 0; i < dripParticles.size(); i++) {
DripParticle& d = dripParticles[i];
if (!d.active) continue;
Vector3 v;
d.velocity.Normalize(v);
AddSpriteBillboardConstrained(&m_sprites[Objects[ID_DRIP_SPRITE].meshIndex], d.pos, d.color, 0, 1, DRIP_WIDTH, d.height, BLENDMODE_ALPHABLEND, v);
}
return true;
}
bool Renderer11::drawExplosionParticles() {
using T5M::Effects::Explosion::explosionParticles;
using T5M::Effects::Explosion::ExplosionParticle;
for (int i = 0; i < explosionParticles.size(); i++) {
ExplosionParticle& e = explosionParticles[i];
if (!e.active) continue;
AddSpriteBillboard(&m_sprites[Objects[ID_EXPLOSION_SPRITES].meshIndex + e.sprite], e.pos, e.tint, e.rotation, 1.0f, e.size, e.size, BLENDMODE_ALPHABLEND);
}
return true;
}
}
Reference in a new issue View git blame Copy permalink