63b906fd63
Batch #4988 by youko: 0 byte-identical, 1 confirmed by peer review. - fn_19976 CEffectPrim::RenderSegmentSprites: logic confirmed by peer review Peer-reviewed-by: Yommy, Lumen, SapitoSucio Accepted without human review: peers confirmed the logic ("same" ahead by at least 3, with 70% of the votes).
1160 lines
38 KiB
C++
1160 lines
38 KiB
C++
#include "Contents/Effects/EffectPrim.h"
|
|
#include "Contents/Effects/EffectPrimitiveState.h"
|
|
#include "Contents/Configuration/ServiceOptions.h"
|
|
#include "Contents/MapSkyMgr.h"
|
|
#include "Render/Renderer.h"
|
|
#include "Render/SpriteGeometry.h"
|
|
#include "Render/SpriteQuad.h"
|
|
#include "Render/Textures/SpritePixels.h"
|
|
#include "Resource/Sprites/ActionResource.h"
|
|
#include "Resource/Sprites/SpriteResource.h"
|
|
#include "Utility/Math/AffineMatrix.h"
|
|
#include <cstdlib>
|
|
|
|
// OFFSET: 0x00BEBC80
|
|
// FUNCTION: fn_19972
|
|
void CEffectPrim::RenderGroundArcGlow(matrix& wtm) {
|
|
vector3d prevB{};
|
|
vector3d curB{};
|
|
vector3d curT{};
|
|
vector3d prevT{};
|
|
int rpCnt = 0;
|
|
short alpha;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1) {
|
|
continue;
|
|
}
|
|
|
|
const int step = slot.fullDisplayAngle / 20;
|
|
int i = 0;
|
|
for (int offset = 0; offset <= slot.fullDisplayAngle; offset += step) {
|
|
int angle = (slot.rotStart + offset) % 360;
|
|
if (slot.fullDisplayAngle == 360 && i == 20) {
|
|
angle = slot.rotStart;
|
|
}
|
|
|
|
const float rise = slot.height[i];
|
|
const float radius = g_sinTable[slot.rotStart] + slot.distance;
|
|
const float riseX = rise * g_cosTable[slot.riseAngle];
|
|
curB.x = radius * g_cosTable[angle];
|
|
curB.y = 0.0f;
|
|
curB.z = radius * g_sinTable[angle];
|
|
curT.x = riseX * g_cosTable[angle] + curB.x;
|
|
curT.y = -(rise * g_sinTable[slot.riseAngle]);
|
|
curT.z = riseX * g_sinTable[angle] + curB.z;
|
|
|
|
if (i > 0) {
|
|
int texture;
|
|
if (slot.alphaT == 10) {
|
|
texture = slot.process / 3 % static_cast<int>(this->state.totalTexture);
|
|
} else {
|
|
texture = slot.process % static_cast<int>(this->state.totalTexture);
|
|
this->state.size = 0.0f;
|
|
this->RenderTeiRect(&rpCnt, i - 1, slot.alphaB, slot.alphaB, prevB, curB, curT, prevT, wtm, static_cast<char>(texture));
|
|
}
|
|
|
|
if (slot.alphaT <= 2) {
|
|
this->state.size = 17.0f;
|
|
alpha = slot.alphaB * 3;
|
|
} else if (slot.alphaT == 3) {
|
|
this->state.size = 18.0f;
|
|
alpha = slot.alphaB * 3;
|
|
} else if (slot.alphaT == 4) {
|
|
this->state.size = 19.0f;
|
|
alpha = slot.alphaB * 2;
|
|
} else if (slot.alphaT == 5) {
|
|
this->state.size = 20.0f;
|
|
alpha = slot.alphaB * 2;
|
|
} else if (slot.alphaT == 7) {
|
|
this->state.size = 21.0f;
|
|
alpha = slot.alphaB * 2;
|
|
} else if (slot.alphaT == 8) {
|
|
this->state.size = 22.0f;
|
|
alpha = slot.alphaB * 2;
|
|
} else if (slot.alphaT == 9) {
|
|
this->state.size = 30.0f;
|
|
alpha = slot.alphaB;
|
|
if (!g_serviceOptions.Get(229)) {
|
|
alpha = slot.alphaB * 2;
|
|
}
|
|
} else if (slot.alphaT == 6) {
|
|
this->state.size = 5.0f;
|
|
alpha = slot.alphaB * 2;
|
|
} else if (slot.alphaT == 10) {
|
|
this->state.size = 6.0f;
|
|
alpha = slot.alphaB * 3;
|
|
} else if (slot.alphaT == 11) {
|
|
this->state.size = 32.0f;
|
|
alpha = slot.alphaB;
|
|
if (!g_serviceOptions.Get(229)) {
|
|
alpha = slot.alphaB * 2;
|
|
}
|
|
}
|
|
|
|
if (alpha > 255) {
|
|
alpha = 255;
|
|
}
|
|
this->RenderTeiRect(&rpCnt, i - 1, alpha, slot.alphaB, prevB, curB, curT, prevT, wtm, static_cast<char>(texture));
|
|
}
|
|
|
|
++i;
|
|
if (i >= 21) {
|
|
i = 20;
|
|
}
|
|
prevT = curT;
|
|
prevB = curB;
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BEC150
|
|
// FUNCTION: fn_19973
|
|
void CEffectPrim::RenderGroundArc(matrix& wtm) {
|
|
vector3d prevB{};
|
|
vector3d curB{};
|
|
vector3d curT{};
|
|
vector3d prevT{};
|
|
int rpCnt = 0;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1 || slot.process <= 0) {
|
|
continue;
|
|
}
|
|
|
|
const int step = slot.fullDisplayAngle / 20;
|
|
int i = 0;
|
|
for (int offset = 0; offset <= slot.fullDisplayAngle; offset += step) {
|
|
int angle = (slot.rotStart + offset) % 360;
|
|
if (slot.fullDisplayAngle == 360 && i == 20) {
|
|
angle = slot.rotStart;
|
|
}
|
|
|
|
const float rise = slot.height[i];
|
|
const float riseX = rise * g_cosTable[slot.riseAngle];
|
|
curB.x = slot.distance * g_cosTable[angle];
|
|
curB.y = 5.0f;
|
|
curB.z = slot.distance * g_sinTable[angle];
|
|
curT.x = riseX * g_cosTable[angle] + curB.x;
|
|
curT.z = riseX * g_sinTable[angle] + curB.z;
|
|
curT.y = 5.0f - rise * g_sinTable[slot.riseAngle];
|
|
|
|
if (i > 0) {
|
|
this->RenderTeiRect(
|
|
&rpCnt, i - 1, slot.alphaB, slot.alphaB, prevB, curB, curT, prevT, wtm,
|
|
static_cast<char>(slot.process % static_cast<int>(this->state.totalTexture))
|
|
);
|
|
}
|
|
|
|
++i;
|
|
if (i >= 21) {
|
|
i = 20;
|
|
}
|
|
prevT = curT;
|
|
prevB = curB;
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BEC3D0
|
|
// FUNCTION: fn_19974
|
|
void CEffectPrim::RenderGroundArc2(matrix& wtm) {
|
|
vector3d prevB{};
|
|
vector3d curB{};
|
|
vector3d curT{};
|
|
vector3d prevT{};
|
|
int rpCnt = 0;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1 || slot.process <= 0) {
|
|
continue;
|
|
}
|
|
|
|
const int step = slot.fullDisplayAngle / 20;
|
|
int i = 0;
|
|
for (int offset = 0; offset <= slot.fullDisplayAngle; offset += step) {
|
|
int angle = (slot.rotStart + offset) % 360;
|
|
if (slot.fullDisplayAngle == 360 && i == 20) {
|
|
angle = slot.rotStart;
|
|
}
|
|
|
|
const float rise = slot.height[i];
|
|
const float riseX = rise * g_cosTable[slot.riseAngle];
|
|
curB.x = slot.distance * g_cosTable[angle];
|
|
curB.y = 5.0f;
|
|
curB.z = slot.distance * g_sinTable[angle];
|
|
curT.x = riseX * g_cosTable[angle] + curB.x;
|
|
curT.z = riseX * g_sinTable[angle] + curB.z;
|
|
curT.y = 5.0f - rise * g_sinTable[slot.riseAngle];
|
|
|
|
if (i > 0) {
|
|
this->RenderTeiRect(
|
|
&rpCnt, i - 1, slot.alphaB, slot.alphaB, prevB, curB, curT, prevT, wtm,
|
|
static_cast<char>(slot.process % static_cast<int>(this->state.totalTexture))
|
|
);
|
|
}
|
|
|
|
++i;
|
|
if (i >= 21) {
|
|
i = 20;
|
|
}
|
|
prevT = curT;
|
|
prevB = curB;
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BEC650
|
|
// FUNCTION: fn_19975
|
|
void CEffectPrim::RenderGroundArcStep(matrix& wtm) {
|
|
vector3d prevB{};
|
|
vector3d curB{};
|
|
vector3d curT{};
|
|
vector3d prevT{};
|
|
int rpCnt = 0;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1) {
|
|
continue;
|
|
}
|
|
|
|
const int step = slot.fullDisplayAngle / 20;
|
|
int i = 0;
|
|
for (int offset = 0; offset <= slot.fullDisplayAngle; offset += step) {
|
|
int angle = (slot.rotStart + offset) % 360;
|
|
if (slot.fullDisplayAngle == 360 && i == 20) {
|
|
angle = slot.rotStart;
|
|
}
|
|
|
|
curB.x = slot.distance * g_cosTable[angle];
|
|
curB.z = slot.distance * g_sinTable[angle];
|
|
if (slot.maxHeight == 6.001f) {
|
|
curB.y = -2.0f;
|
|
} else if (slot.maxHeight == 24.001f) {
|
|
curB.y = -1.0f;
|
|
} else {
|
|
curB.y = 0.0f;
|
|
}
|
|
|
|
const float rise = slot.height[i];
|
|
const float riseX = rise * g_cosTable[slot.riseAngle];
|
|
float riseY = rise * g_sinTable[slot.riseAngle];
|
|
curT.x = riseX * g_cosTable[angle] + curB.x;
|
|
curT.z = riseX * g_sinTable[angle] + curB.z;
|
|
if (slot.maxHeight == 6.001f) {
|
|
riseY += 2.0f;
|
|
} else if (slot.maxHeight == 24.001f) {
|
|
riseY += 1.0f;
|
|
}
|
|
curT.y = -riseY;
|
|
|
|
if (i > 0) {
|
|
this->RenderTeiRect(
|
|
&rpCnt, i - 1, slot.alphaB, slot.alphaB, prevB, curB, curT, prevT, wtm,
|
|
static_cast<char>(slot.process % static_cast<int>(this->state.totalTexture))
|
|
);
|
|
}
|
|
|
|
++i;
|
|
if (i >= 21) {
|
|
i = 20;
|
|
}
|
|
prevB = curB;
|
|
prevT = curT;
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BEC960
|
|
// FUNCTION: fn_19976
|
|
void CEffectPrim::RenderSegmentSprites(matrix& wtm) {
|
|
CSprRes* sprite = this->render.sprite;
|
|
CActRes* action = this->GetActRes();
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
for (int seg = 0; seg < this->state.numSegment; ++seg) {
|
|
const EffectPrimitiveRecord& record = this->state.records[seg];
|
|
vector3d position;
|
|
position.x = record.position.x + slot.vecBNow.x;
|
|
position.y = record.position.y + slot.vecBNow.y;
|
|
position.z = record.position.z + slot.vecBNow.z;
|
|
const float depth = position.y * wtm.values[5] + position.x * wtm.values[2] + position.z * wtm.values[8] + wtm.values[11];
|
|
|
|
float screenX;
|
|
float screenY;
|
|
float reciprocalDepth;
|
|
g_renderer->ProjectViewport(&position.x, wtm.values, &screenX, &screenY, &reciprocalDepth);
|
|
const float distanceScale = g_renderer->ScaleDistance(reciprocalDepth);
|
|
|
|
const ActionFrame& frame = action->Frame(this->render.previousAnimation, this->render.curMotion);
|
|
for (int index = 0; index < frame.cellCount; ++index) {
|
|
const SpriteFrameCell& cell = frame.Cell(index);
|
|
if (cell.image == -1) {
|
|
continue;
|
|
}
|
|
|
|
const SpriteRleImage* image = sprite->images[cell.imageType][cell.image];
|
|
const double scale = record.scale;
|
|
const float top = static_cast<float>(cell.y * scale * cell.scaleY * distanceScale + screenY);
|
|
const float bottom = static_cast<float>(((static_cast<short>(image->unknown_0006) + 1) * image->height + cell.y) * scale * cell.scaleY * distanceScale + screenY);
|
|
if (top >= static_cast<float>(g_renderer->viewport.height) || bottom <= 0.0f) {
|
|
continue;
|
|
}
|
|
|
|
float left;
|
|
float right;
|
|
if ((cell.mirrored & 1) != 0) {
|
|
left = static_cast<float>(((static_cast<short>(image->unknown_0004) + 1) * image->width + cell.x) * scale * cell.scaleX * distanceScale + screenX);
|
|
right = static_cast<float>(cell.x * scale * cell.scaleX * distanceScale + screenX);
|
|
if (right >= static_cast<float>(g_renderer->viewport.width) || left <= 0.0f) {
|
|
continue;
|
|
}
|
|
} else {
|
|
left = static_cast<float>(cell.x * scale * cell.scaleX * distanceScale + screenX);
|
|
right = static_cast<float>(((static_cast<short>(image->unknown_0004) + 1) * image->width + cell.x) * scale * cell.scaleX * distanceScale + screenX);
|
|
if (left >= static_cast<float>(g_renderer->viewport.width) || right <= 0.0f) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
SpriteQuad quad;
|
|
quad.top = top;
|
|
quad.left = left;
|
|
quad.bottom = bottom;
|
|
quad.right = right;
|
|
short alpha = static_cast<short>((cell.color >> 24) * 0.85f);
|
|
quad.bottomRhw = 1.0f / ((bottom - screenY) * g_tangent + depth) + 0.0001f;
|
|
quad.topRhw = 1.0f / ((top - screenY) * g_tangent + depth) + 0.0001f;
|
|
if ((this->state.pattern & 0x200) == 0) {
|
|
quad.color = record.color;
|
|
} else if (slot.flag1[0] == 0) {
|
|
quad.color = (((((alpha << 8) + (cell.color & 0xFF)) << 8) + (cell.color >> 8 & 0xFF)) << 8) + (cell.color >> 16 & 0xFF);
|
|
} else if (slot.flag1[0] == 1) {
|
|
quad.color = (alpha << 24) + 0x3737FF;
|
|
}
|
|
quad.angle = static_cast<float>(cell.unknown_001C) + this->state.roll;
|
|
quad.image = image;
|
|
this->DrawQuad(quad, sprite->palette, 5, 0.0f, 0.0f, 0);
|
|
|
|
quad.top -= 4.0f;
|
|
quad.bottom += 4.0f;
|
|
quad.left -= 4.0f;
|
|
quad.right += 4.0f;
|
|
alpha = static_cast<short>((cell.color >> 24) * g_depthAverageHalf);
|
|
quad.bottomRhw = 1.0f / ((bottom - screenY) * g_tangent + depth) + 0.0002f;
|
|
quad.topRhw = 1.0f / ((top - screenY) * g_tangent + depth) + 0.0002f;
|
|
if ((this->state.pattern & 0x200) == 0) {
|
|
quad.color = record.color;
|
|
} else if (slot.flag1[0] == 0) {
|
|
quad.color = (((alpha << 8) + (cell.color & 0xFF)) << 16) + 0x3737;
|
|
} else if (slot.flag1[0] == 1) {
|
|
quad.color = (alpha << 24) + 0x3737FF;
|
|
}
|
|
quad.angle = static_cast<float>(cell.unknown_001C) + this->state.roll;
|
|
quad.image = image;
|
|
this->DrawQuad(quad, sprite->palette, 5, 0.0f, 0.0f, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BECEB0
|
|
// FUNCTION: fn_19977
|
|
void CEffectPrim::RenderGroundSquare(matrix& wtm) {
|
|
int rpCnt = 0;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1) {
|
|
continue;
|
|
}
|
|
|
|
const int angle0 = slot.rotStart;
|
|
const double radius = (g_sinTable[slot.riseAngle] + 1.0f) * (slot.distance * 0.1f) + slot.distance * 0.8;
|
|
const int angle1 = angle0 + (angle0 < 270 ? 90 : -270);
|
|
const int angle2 = angle1 + (angle1 + 90 < 360 ? 90 : -270);
|
|
const int angle3 = angle2 + (angle2 + 90 < 360 ? 90 : -270);
|
|
|
|
slot.vecBPre.x = static_cast<float>(g_cosTable[angle0] * radius);
|
|
slot.vecBPre.z = static_cast<float>(g_sinTable[angle0] * radius);
|
|
slot.vecBPre.y = slot.height[0];
|
|
slot.vecBNow.y = slot.height[0];
|
|
slot.vecBNow.x = static_cast<float>(g_cosTable[angle1] * radius);
|
|
slot.vecBNow.z = static_cast<float>(g_sinTable[angle1] * radius);
|
|
slot.vecTNow.y = slot.height[0];
|
|
slot.vecTNow.x = static_cast<float>(g_cosTable[angle2] * radius);
|
|
slot.vecTNow.z = static_cast<float>(g_sinTable[angle2] * radius);
|
|
slot.vecTPre.y = slot.height[0];
|
|
slot.vecTPre.x = static_cast<float>(g_cosTable[angle3] * radius);
|
|
slot.vecTPre.z = static_cast<float>(g_sinTable[angle3] * radius);
|
|
|
|
this->RenderTeiRect(
|
|
&rpCnt, slot.alphaB, slot.vecBPre, slot.vecBNow, slot.vecTNow, slot.vecTPre, wtm, slot.height[2] == 1.0f,
|
|
static_cast<char>(slot.height[1]), 0, 255, 255, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0
|
|
);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BED140
|
|
// FUNCTION: fn_19978
|
|
void CEffectPrim::RenderGroundSquareBlend(matrix& wtm) {
|
|
int rpCnt = 0;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1) {
|
|
continue;
|
|
}
|
|
|
|
const int angle0 = slot.rotStart;
|
|
const double radius = (g_sinTable[slot.riseAngle] + 1.0f) * (slot.distance * 0.1f) + slot.distance * 0.8;
|
|
const int angle1 = angle0 + (angle0 < 270 ? 90 : -270);
|
|
const int angle2 = angle1 + (angle1 + 90 < 360 ? 90 : -270);
|
|
const int angle3 = angle2 + (angle2 + 90 < 360 ? 90 : -270);
|
|
|
|
slot.vecBPre.x = static_cast<float>(g_cosTable[angle0] * radius);
|
|
slot.vecBPre.z = static_cast<float>(g_sinTable[angle0] * radius);
|
|
slot.vecBPre.y = slot.height[0];
|
|
slot.vecBNow.y = slot.height[0];
|
|
slot.vecBNow.x = static_cast<float>(g_cosTable[angle1] * radius);
|
|
slot.vecBNow.z = static_cast<float>(g_sinTable[angle1] * radius);
|
|
slot.vecTNow.y = slot.height[0];
|
|
slot.vecTNow.x = static_cast<float>(g_cosTable[angle2] * radius);
|
|
slot.vecTNow.z = static_cast<float>(g_sinTable[angle2] * radius);
|
|
slot.vecTPre.y = slot.height[0];
|
|
slot.vecTPre.x = static_cast<float>(g_cosTable[angle3] * radius);
|
|
slot.vecTPre.z = static_cast<float>(g_sinTable[angle3] * radius);
|
|
|
|
short alpha = static_cast<short>(slot.process % 256 * 2);
|
|
if (alpha > 255) {
|
|
alpha = 511 - alpha;
|
|
}
|
|
|
|
this->RenderTeiRect(
|
|
&rpCnt, alpha, slot.vecBPre, slot.vecBNow, slot.vecTNow, slot.vecTPre, wtm, 1, 0, 0, 255, 255, 255, 0.0f, 1.0f, 0.0f,
|
|
1.0f, 0
|
|
);
|
|
this->RenderTeiRect(
|
|
&rpCnt, 255 - alpha, slot.vecBPre, slot.vecBNow, slot.vecTNow, slot.vecTPre, wtm, 1, 1, 0, 255, 255, 255, 0.0f, 1.0f,
|
|
0.0f, 1.0f, 0
|
|
);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BED490
|
|
|
|
// OFFSET: 0x00BEFD80
|
|
// FUNCTION: fn_19983
|
|
void CEffectPrim::RenderFanWedge(matrix& wtm) {
|
|
vector3d tip{};
|
|
vector3d left{};
|
|
vector3d right{};
|
|
vector3d back{};
|
|
int rpCnt = 0;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1 || slot.alphaB <= 0) {
|
|
continue;
|
|
}
|
|
|
|
const int angle = slot.riseAngle;
|
|
const float dist = slot.distance;
|
|
const float base = slot.height[0];
|
|
const int leftAngle = angle + (angle >= 7 ? -7 : 353);
|
|
const float rotSin = g_sinTable[slot.rotStart];
|
|
const float rotCos = g_cosTable[slot.rotStart];
|
|
const int rightAngle = angle + (angle < 353 ? 7 : -353);
|
|
const int backAngle = angle + (angle >= 270 ? -270 : 90);
|
|
left.x = dist * g_cosTable[leftAngle] * rotCos;
|
|
left.y = dist * g_cosTable[leftAngle] * rotSin + base;
|
|
left.z = dist * g_sinTable[leftAngle];
|
|
right.x = dist * g_cosTable[rightAngle] * rotCos;
|
|
right.y = dist * g_cosTable[rightAngle] * rotSin + base;
|
|
right.z = dist * g_sinTable[rightAngle];
|
|
back.x = g_cosTable[backAngle] * 7.0f * rotCos;
|
|
back.y = g_cosTable[backAngle] * 7.0f * rotSin + base;
|
|
back.z = g_sinTable[backAngle] * 7.0f;
|
|
const int tipAngle = angle < 90 ? angle + 270 : angle - 90;
|
|
tip.x = g_cosTable[tipAngle] * 7.0f * rotCos;
|
|
tip.y = g_cosTable[tipAngle] * 7.0f * rotSin + base;
|
|
tip.z = g_sinTable[tipAngle] * 7.0f;
|
|
|
|
this->RenderTeiRect(
|
|
&rpCnt, slot.alphaB, tip, left, right, back, wtm, 0, static_cast<unsigned char>(static_cast<int>(slot.height[1])), 0, 105,
|
|
105, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0
|
|
);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BF1210
|
|
// FUNCTION: fn_19986
|
|
void CEffectPrim::RenderFanSlice(matrix& wtm) {
|
|
vector3d left{};
|
|
vector3d right{};
|
|
vector3d center{};
|
|
vector3d center2{};
|
|
int rpCnt = 0;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1 || slot.alphaB <= 0) {
|
|
continue;
|
|
}
|
|
|
|
const int angle = slot.riseAngle;
|
|
const float dist = slot.distance;
|
|
const float base = slot.height[0];
|
|
const int leftAngle = angle + (angle >= 5 ? -5 : 355);
|
|
const int rightAngle = angle + (angle < 355 ? 5 : -355);
|
|
left.x = dist * g_cosTable[leftAngle] * g_cosTable[slot.rotStart];
|
|
left.y = dist * g_cosTable[leftAngle] * g_sinTable[slot.rotStart] + base;
|
|
left.z = dist * g_sinTable[leftAngle];
|
|
right.x = dist * g_cosTable[rightAngle] * g_cosTable[slot.rotStart];
|
|
right.y = dist * g_cosTable[rightAngle] * g_sinTable[slot.rotStart] + base;
|
|
right.z = dist * g_sinTable[rightAngle];
|
|
center.x = 0.0f;
|
|
center.y = base;
|
|
center.z = 0.0f;
|
|
center2.x = 0.0f;
|
|
center2.y = base;
|
|
center2.z = 0.0f;
|
|
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, left, right, center, center2, wtm, 0, 0, 0, 0, 0, 255, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BF0010
|
|
// FUNCTION: fn_19984
|
|
void CEffectPrim::RenderFanTrail(matrix& wtm) {
|
|
int rpCnt = 0;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1 || slot.alphaB <= 0) {
|
|
continue;
|
|
}
|
|
|
|
const int angle = slot.riseAngle;
|
|
const float size = slot.maxHeight;
|
|
const float base = slot.height[0];
|
|
const int low = angle - 20;
|
|
const int high = angle + 20;
|
|
const int leftAngle = low < 0 ? low + 360 : low;
|
|
const int rightAngle = high < 360 ? high : high - 360;
|
|
const int backRightAngle = high - 180 < 0 ? high - 180 + 360 : high - 180;
|
|
const int backLeftAngle = low + 180 < 360 ? low + 180 : low + 180 - 360;
|
|
const float rotCos = g_cosTable[slot.rotStart];
|
|
const float rotSin = g_sinTable[slot.rotStart];
|
|
|
|
vector3d left;
|
|
left.x = size * g_cosTable[leftAngle] * rotCos;
|
|
left.y = size * g_cosTable[leftAngle] * rotSin + base;
|
|
left.z = size * g_sinTable[leftAngle];
|
|
vector3d right;
|
|
right.x = size * g_cosTable[rightAngle] * rotCos;
|
|
right.y = size * g_cosTable[rightAngle] * rotSin + base;
|
|
right.z = size * g_sinTable[rightAngle];
|
|
vector3d backRight;
|
|
backRight.x = size * g_cosTable[backRightAngle] * rotCos;
|
|
backRight.y = size * g_cosTable[backRightAngle] * rotSin + base;
|
|
backRight.z = size * g_sinTable[backRightAngle];
|
|
vector3d backLeft;
|
|
backLeft.x = size * g_cosTable[backLeftAngle] * rotCos;
|
|
backLeft.y = size * g_cosTable[backLeftAngle] * rotSin + base;
|
|
backLeft.z = size * g_sinTable[backLeftAngle];
|
|
|
|
const float dirCos = g_cosTable[angle];
|
|
const float dirSin = g_sinTable[angle];
|
|
|
|
for (short step = 0; step < 6; ++step) {
|
|
const float dist = step * slot.maxHeight + slot.distance;
|
|
vector3d offset;
|
|
offset.x = dist * dirCos;
|
|
offset.y = 0.0f;
|
|
offset.z = dist * dirSin;
|
|
if (dist > 100.0f) {
|
|
break;
|
|
}
|
|
|
|
if (dist > 0.0f) {
|
|
vector3d vec1;
|
|
vec1.x = backRight.x + offset.x;
|
|
vec1.y = backRight.y + offset.y;
|
|
vec1.z = backRight.z + offset.z;
|
|
vector3d vec2;
|
|
vec2.x = left.x + offset.x;
|
|
vec2.y = left.y + offset.y;
|
|
vec2.z = left.z + offset.z;
|
|
vector3d vec3;
|
|
vec3.x = right.x + offset.x;
|
|
vec3.y = right.y + offset.y;
|
|
vec3.z = right.z + offset.z;
|
|
vector3d vec4;
|
|
vec4.x = backLeft.x + offset.x;
|
|
vec4.y = backLeft.y + offset.y;
|
|
vec4.z = backLeft.z + offset.z;
|
|
this->RenderTeiRect(
|
|
&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, static_cast<unsigned char>(static_cast<int>(slot.height[1])), 0,
|
|
105, 105, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BF0370
|
|
|
|
// OFFSET: 0x00BEE900
|
|
// FUNCTION: fn_19980
|
|
void CEffectPrim::RenderTwinFacingSquares(matrix& wtm) {
|
|
int rpCnt = 0;
|
|
EffectPrimitiveSlot& slot = this->state.slots[0];
|
|
|
|
if (slot.life != 1 || slot.alphaB <= 0) {
|
|
return;
|
|
}
|
|
|
|
vector3d vec1;
|
|
vector3d vec2;
|
|
vector3d vec3;
|
|
vector3d vec4;
|
|
vec1.y = 0.0f;
|
|
vec2.y = 0.0f;
|
|
vec3.y = 0.0f;
|
|
vec4.y = 0.0f;
|
|
|
|
float radius = slot.distance * g_sinTable[static_cast<int>(slot.height[8])] * 0.05f + slot.distance;
|
|
int angle = slot.process * 2 % 360;
|
|
vec1.x = radius * g_cosTable[angle];
|
|
vec1.z = radius * g_sinTable[angle];
|
|
angle = (angle + 90) % 360;
|
|
vec2.x = radius * g_cosTable[angle];
|
|
vec2.z = radius * g_sinTable[angle];
|
|
angle = (angle + 90) % 360;
|
|
vec3.x = radius * g_cosTable[angle];
|
|
vec3.z = radius * g_sinTable[angle];
|
|
angle = (angle + 90) % 360;
|
|
vec4.x = radius * g_cosTable[angle];
|
|
vec4.z = radius * g_sinTable[angle];
|
|
this->Tei_TowardScreen(vec1, vec2, vec3, vec4, slot.alphaT, this->state.slots[1].alphaT);
|
|
|
|
vec1.x = slot.vecBNow.x + vec1.x;
|
|
vec1.y = slot.vecBNow.y + vec1.y;
|
|
vec1.z = slot.vecBNow.z + vec1.z;
|
|
vec2.x = slot.vecBNow.x + vec2.x;
|
|
vec2.y = slot.vecBNow.y + vec2.y;
|
|
vec2.z = slot.vecBNow.z + vec2.z;
|
|
vec3.x = slot.vecBNow.x + vec3.x;
|
|
vec3.y = slot.vecBNow.y + vec3.y;
|
|
vec3.z = slot.vecBNow.z + vec3.z;
|
|
vec4.x = slot.vecBNow.x + vec4.x;
|
|
vec4.y = slot.vecBNow.y + vec4.y;
|
|
vec4.z = slot.vecBNow.z + vec4.z;
|
|
|
|
if (slot.flag1[0] == 10) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 1, 0, 0, 255, 255, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
} else if (slot.flag1[0] == 11) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 200, 200, 50, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
} else if (slot.flag1[0] == 12) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 50, 50, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
} else if (slot.flag1[0] == 13) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 100, 150, 100, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
} else {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 0, 0, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
}
|
|
|
|
vec1.y = 0.0f;
|
|
vec2.y = 0.0f;
|
|
vec3.y = 0.0f;
|
|
vec4.y = 0.0f;
|
|
radius = slot.distance * g_sinTable[static_cast<int>(slot.height[8])] * 0.05f +
|
|
(g_sinTable[slot.process * 5 % 90] * 2.0f + 1.0f) * slot.distance;
|
|
angle = slot.process * 2 % 360;
|
|
vec1.x = radius * g_cosTable[angle];
|
|
vec1.z = radius * g_sinTable[angle];
|
|
angle = (angle + 90) % 360;
|
|
vec2.x = radius * g_cosTable[angle];
|
|
vec2.z = radius * g_sinTable[angle];
|
|
angle = (angle + 90) % 360;
|
|
vec3.x = radius * g_cosTable[angle];
|
|
vec3.z = radius * g_sinTable[angle];
|
|
angle = (angle + 90) % 360;
|
|
vec4.x = radius * g_cosTable[angle];
|
|
vec4.z = radius * g_sinTable[angle];
|
|
this->Tei_TowardScreen(vec1, vec2, vec3, vec4, slot.alphaT, this->state.slots[1].alphaT);
|
|
|
|
vec1.x = vec1.x + slot.vecBNow.x;
|
|
vec1.y = vec1.y + slot.vecBNow.y;
|
|
vec1.z = slot.vecBNow.z + vec1.z;
|
|
vec2.x = vec2.x + slot.vecBNow.x;
|
|
vec2.y = vec2.y + slot.vecBNow.y;
|
|
vec2.z = vec2.z + slot.vecBNow.z;
|
|
vec3.x = vec3.x + slot.vecBNow.x;
|
|
vec3.y = vec3.y + slot.vecBNow.y;
|
|
vec3.z = vec3.z + slot.vecBNow.z;
|
|
vec4.x = vec4.x + slot.vecBNow.x;
|
|
vec4.y = vec4.y + slot.vecBNow.y;
|
|
vec4.z = vec4.z + slot.vecBNow.z;
|
|
|
|
if (slot.flag1[0] == 10) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 1, 0, 255, 20, 20, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
} else if (slot.flag1[0] == 11) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 200, 200, 50, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
} else if (slot.flag1[0] == 12) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 50, 50, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
} else if (slot.flag1[0] == 13) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 100, 150, 100, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
} else {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 255, 255, 0, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BEEF80
|
|
// FUNCTION: fn_19981
|
|
void CEffectPrim::RenderPillarSquares(matrix& wtm) {
|
|
int rpCnt = 0;
|
|
EffectPrimitiveSlot& slot = this->state.slots[0];
|
|
|
|
if (slot.life != 1 || slot.alphaB <= 0) {
|
|
return;
|
|
}
|
|
|
|
vector3d vec1;
|
|
vector3d vec2;
|
|
vector3d vec3;
|
|
vector3d vec4;
|
|
vec1.y = 0.0f;
|
|
vec2.y = 0.0f;
|
|
vec3.y = 0.0f;
|
|
vec4.y = 0.0f;
|
|
|
|
float radius = slot.distance * g_sinTable[static_cast<int>(slot.height[8])] * 0.05f + slot.distance;
|
|
vec1.x = radius * g_cosTable[0];
|
|
vec1.z = radius * g_sinTable[0];
|
|
vec2.x = radius * g_cosTable[90];
|
|
vec2.z = radius * g_sinTable[90];
|
|
vec3.x = radius * g_cosTable[180];
|
|
vec3.z = radius * g_sinTable[180];
|
|
vec4.x = radius * g_cosTable[270];
|
|
vec4.z = radius * g_sinTable[270];
|
|
this->Tei_TowardScreen(vec1, vec2, vec3, vec4, slot.alphaT, this->state.slots[1].alphaT);
|
|
|
|
vec1.x = slot.vecBNow.x + vec1.x;
|
|
vec1.y = slot.vecBNow.y + vec1.y;
|
|
vec1.z = slot.vecBNow.z + vec1.z;
|
|
vec2.x = slot.vecBNow.x + vec2.x;
|
|
vec2.y = slot.vecBNow.y + vec2.y;
|
|
vec2.z = slot.vecBNow.z + vec2.z;
|
|
vec3.x = slot.vecBNow.x + vec3.x;
|
|
vec3.y = slot.vecBNow.y + vec3.y;
|
|
vec3.z = slot.vecBNow.z + vec3.z;
|
|
vec4.x = slot.vecBNow.x + vec4.x;
|
|
vec4.y = slot.vecBNow.y + vec4.y;
|
|
vec4.z = slot.vecBNow.z + vec4.z;
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 68, 42, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
|
|
vec1.y = 0.0f;
|
|
vec2.y = 0.0f;
|
|
vec3.y = 0.0f;
|
|
vec4.y = 0.0f;
|
|
radius = slot.distance * g_sinTable[static_cast<int>(slot.height[8])] * 0.05f + slot.distance * g_depthAverageHalf;
|
|
vec1.x = radius * g_cosTable[0];
|
|
vec1.z = radius * g_sinTable[0];
|
|
vec2.x = radius * g_cosTable[90];
|
|
vec2.z = radius * g_sinTable[90];
|
|
vec3.x = radius * g_cosTable[180];
|
|
vec3.z = radius * g_sinTable[180];
|
|
vec4.x = radius * g_cosTable[270];
|
|
vec4.z = radius * g_sinTable[270];
|
|
this->Tei_TowardScreen(vec1, vec2, vec3, vec4, slot.alphaT, this->state.slots[1].alphaT);
|
|
|
|
vec1.x = slot.vecBNow.x + vec1.x;
|
|
vec1.y = slot.vecBNow.y + vec1.y;
|
|
vec1.z = slot.vecBNow.z + vec1.z;
|
|
vec2.x = slot.vecBNow.x + vec2.x;
|
|
vec2.y = slot.vecBNow.y + vec2.y;
|
|
vec2.z = slot.vecBNow.z + vec2.z;
|
|
vec3.x = slot.vecBNow.x + vec3.x;
|
|
vec3.y = slot.vecBNow.y + vec3.y;
|
|
vec3.z = slot.vecBNow.z + vec3.z;
|
|
vec4.x = slot.vecBNow.x + vec4.x;
|
|
vec4.y = slot.vecBNow.y + vec4.y;
|
|
vec4.z = slot.vecBNow.z + vec4.z;
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, vec1, vec2, vec3, vec4, wtm, 0, 0, 0, 155, 155, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
EffectPrimitiveSlot& pillar = this->state.slots[ec];
|
|
const int angle = pillar.rotStart;
|
|
const float height = pillar.height[12] * g_depthAverageHalf;
|
|
const int opposite = angle + (angle < 180 ? 180 : -180);
|
|
|
|
pillar.vecTPre.y = height;
|
|
pillar.vecTPre.z = g_sinTable[angle] * height + g_cosTable[angle] * 0.0f;
|
|
pillar.vecTPre.x = g_cosTable[angle] * height - g_sinTable[angle] * 0.0f;
|
|
pillar.vecTNow.y = height;
|
|
pillar.vecTNow.x = g_cosTable[opposite] * height - g_sinTable[opposite] * 0.0f;
|
|
pillar.vecTNow.z = g_sinTable[opposite] * height + g_cosTable[opposite] * 0.0f;
|
|
|
|
pillar.vecTPre.x = pillar.vecTPre.x + slot.vecBNow.x;
|
|
pillar.vecTPre.y = slot.vecBNow.y + pillar.vecTPre.y;
|
|
pillar.vecTPre.z = slot.vecBNow.z + pillar.vecTPre.z;
|
|
pillar.vecTNow.x = slot.vecBNow.x + pillar.vecTNow.x;
|
|
pillar.vecTNow.y = slot.vecBNow.y + pillar.vecTNow.y;
|
|
pillar.vecTNow.z = slot.vecBNow.z + pillar.vecTNow.z;
|
|
|
|
vector3d lowNow;
|
|
lowNow.x = pillar.vecTNow.x;
|
|
lowNow.y = pillar.vecTNow.y - pillar.height[12];
|
|
lowNow.z = pillar.vecTNow.z;
|
|
vector3d lowPre;
|
|
lowPre.x = pillar.vecTPre.x;
|
|
lowPre.y = pillar.vecTPre.y - pillar.height[12];
|
|
lowPre.z = pillar.vecTPre.z;
|
|
|
|
unsigned char shade;
|
|
if (ec == 0) {
|
|
shade = 105;
|
|
} else if (ec == 1) {
|
|
shade = 35;
|
|
} else {
|
|
shade = ec == 2 ? 75 : 5;
|
|
}
|
|
|
|
if (pillar.height[12] > 0.0f) {
|
|
this->RenderTeiRect(
|
|
&rpCnt, pillar.riseAngle, pillar.vecTPre, pillar.vecTNow, lowNow, lowPre, wtm, 0, 1, 0, shade, shade, 255, 0.0f, 1.0f, 0.0f,
|
|
1.0f, 0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BEF6C0
|
|
// FUNCTION: fn_19982
|
|
void CEffectPrim::RenderBladeFins(matrix& wtm) {
|
|
vector3d base{};
|
|
vector3d outer{};
|
|
vector3d inner{};
|
|
vector3d base2{};
|
|
int rpCnt = 0;
|
|
unsigned char red;
|
|
unsigned char green;
|
|
unsigned char blue;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1 || slot.alphaB <= 0) {
|
|
continue;
|
|
}
|
|
|
|
base2.x = 0.0f;
|
|
base2.y = -6.0f;
|
|
base2.z = 0.0f;
|
|
base.x = 0.0f;
|
|
base.y = -6.0f;
|
|
base.z = 0.0f;
|
|
outer.y = -6.0f;
|
|
inner.y = -6.0f;
|
|
|
|
int angle = slot.riseAngle - 25;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
inner.x = slot.height[0] * g_cosTable[angle];
|
|
inner.z = slot.height[0] * g_sinTable[angle];
|
|
angle -= 90;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
outer.x = slot.maxHeight * g_cosTable[angle] + inner.x;
|
|
outer.z = slot.maxHeight * g_sinTable[angle] + inner.z;
|
|
|
|
if (slot.flag1[0] == 1) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB / 4, base, outer, inner, base2, wtm, 1, 0, 0, 255, 89, 182, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
red = 255;
|
|
green = 25;
|
|
blue = 25;
|
|
} else if (slot.flag1[0] == 2) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB / 4, base, outer, inner, base2, wtm, 1, 0, 0, 255, 255, 255, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
red = 255;
|
|
green = 255;
|
|
blue = 255;
|
|
} else {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB / 4, base, outer, inner, base2, wtm, 1, 0, 0, 255, 255, 255, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
red = 25;
|
|
green = 25;
|
|
blue = 255;
|
|
}
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, base, outer, inner, base2, wtm, 0, 0, 0, red, green, blue, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
|
|
angle = slot.riseAngle + 25;
|
|
if (angle >= 360) {
|
|
angle -= 360;
|
|
}
|
|
inner.x = slot.height[0] * g_cosTable[angle];
|
|
inner.z = slot.height[0] * g_sinTable[angle];
|
|
angle -= 90;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
outer.x = slot.maxHeight * g_cosTable[angle] + inner.x;
|
|
outer.z = slot.maxHeight * g_sinTable[angle] + inner.z;
|
|
|
|
if (slot.flag1[0] == 1) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB / 4, base, outer, inner, base2, wtm, 1, 0, 0, 255, 89, 182, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
red = 255;
|
|
green = 25;
|
|
blue = 25;
|
|
} else if (slot.flag1[0] == 2) {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB / 4, base, outer, inner, base2, wtm, 1, 0, 0, 255, 255, 255, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
red = 255;
|
|
green = 255;
|
|
blue = 255;
|
|
} else {
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB / 4, base, outer, inner, base2, wtm, 1, 0, 0, 255, 255, 255, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
red = 25;
|
|
green = 25;
|
|
blue = 255;
|
|
}
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, base, outer, inner, base2, wtm, 0, 0, 0, red, green, blue, 0.0f, 1.0f, 0.0f, 1.0f, 1);
|
|
}
|
|
}
|
|
|
|
// OFFSET: 0x00BF1400
|
|
// FUNCTION: fn_19987
|
|
void CEffectPrim::RenderPolygonFrames(matrix& wtm) {
|
|
vector3d p0{};
|
|
vector3d p1{};
|
|
vector3d p2{};
|
|
vector3d p3{};
|
|
int rpCnt = 0;
|
|
float radius;
|
|
float top;
|
|
int angle;
|
|
|
|
for (int ec = 0; ec < 4; ++ec) {
|
|
const EffectPrimitiveSlot& slot = this->state.slots[ec];
|
|
|
|
if (slot.life != 1 || slot.alphaB <= 0) {
|
|
continue;
|
|
}
|
|
|
|
radius = slot.distance;
|
|
angle = slot.fullDisplayAngle;
|
|
p0.x = radius * g_cosTable[angle];
|
|
p0.y = 0.0f;
|
|
p0.z = radius * g_sinTable[angle];
|
|
if (slot.height[10] == 0.0f) {
|
|
angle -= 90;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 1.0f) {
|
|
angle -= 60;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 2.0f) {
|
|
angle -= 130;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
}
|
|
p1.x = radius * g_cosTable[angle];
|
|
p1.y = 0.0f;
|
|
p1.z = radius * g_sinTable[angle];
|
|
if (slot.height[10] == 0.0f) {
|
|
angle -= 90;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 1.0f) {
|
|
angle -= 120;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 2.0f) {
|
|
angle -= 50;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
}
|
|
p2.x = radius * g_cosTable[angle];
|
|
p2.y = 0.0f;
|
|
p2.z = radius * g_sinTable[angle];
|
|
if (slot.height[10] == 0.0f) {
|
|
angle -= 90;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 1.0f) {
|
|
angle -= 60;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 2.0f) {
|
|
angle -= 130;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
}
|
|
p3.x = radius * g_cosTable[angle];
|
|
p3.y = 0.0f;
|
|
p3.z = radius * g_sinTable[angle];
|
|
|
|
top = p1.z > p0.z ? p1.z : p0.z;
|
|
top = p2.z > top ? p2.z : top;
|
|
top = p3.z > top ? p3.z : top;
|
|
p0.z -= top;
|
|
p1.z -= top;
|
|
p2.z -= top;
|
|
p3.z -= top;
|
|
this->Tei_TowardScreen(p0, p1, p2, p3, this->state.slots[0].alphaT, this->state.slots[1].alphaT);
|
|
|
|
p0.x = slot.vecBNow.x + p0.x;
|
|
p0.y = slot.vecBNow.y + p0.y;
|
|
p0.z = slot.vecBNow.z + p0.z;
|
|
p1.x = slot.vecBNow.x + p1.x;
|
|
p1.y = slot.vecBNow.y + p1.y;
|
|
p1.z = slot.vecBNow.z + p1.z;
|
|
p2.x = slot.vecBNow.x + p2.x;
|
|
p2.y = slot.vecBNow.y + p2.y;
|
|
p2.z = slot.vecBNow.z + p2.z;
|
|
p3.x = slot.vecBNow.x + p3.x;
|
|
p3.y = slot.vecBNow.y + p3.y;
|
|
p3.z = slot.vecBNow.z + p3.z;
|
|
|
|
switch (slot.flag1[2]) {
|
|
case 0:
|
|
case 3:
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p0, p1, p2, p3, wtm, 1, slot.flag1[0], 1, 255, 255, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
break;
|
|
case 19:
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p1, p0, p3, p2, wtm, 0, slot.flag1[0], 1, 205, 255, 205, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
break;
|
|
case 20:
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p1, p0, p3, p2, wtm, 0, slot.flag1[0], 1, 255, 5, 5, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p1, p0, p3, p2, wtm, 0, slot.flag1[0], 1, 255, 155, 155, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
break;
|
|
case 21:
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p1, p0, p3, p2, wtm, 1, slot.flag1[0], 1, 225, 255, 225, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
break;
|
|
}
|
|
|
|
radius = slot.distance * g_sinTable[static_cast<int>(slot.height[8])] * 0.05f + slot.distance;
|
|
angle = slot.fullDisplayAngle;
|
|
p0.x = radius * g_cosTable[angle];
|
|
p0.y = 0.0f;
|
|
p0.z = radius * g_sinTable[angle];
|
|
if (slot.height[10] == 0.0f) {
|
|
angle -= 90;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 1.0f) {
|
|
angle -= 60;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 2.0f) {
|
|
angle -= 130;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
}
|
|
p1.x = radius * g_cosTable[angle];
|
|
p1.y = 0.0f;
|
|
p1.z = radius * g_sinTable[angle];
|
|
if (slot.height[10] == 0.0f) {
|
|
angle -= 90;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 1.0f) {
|
|
angle -= 120;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 2.0f) {
|
|
angle -= 50;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
}
|
|
p2.x = radius * g_cosTable[angle];
|
|
p2.y = 0.0f;
|
|
p2.z = radius * g_sinTable[angle];
|
|
if (slot.height[10] == 0.0f) {
|
|
angle -= 90;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 1.0f) {
|
|
angle -= 60;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
} else if (slot.height[10] == 2.0f) {
|
|
angle -= 130;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
}
|
|
p3.x = radius * g_cosTable[angle];
|
|
p3.y = 0.0f;
|
|
p3.z = radius * g_sinTable[angle];
|
|
|
|
top = p1.z > p0.z ? p1.z : p0.z;
|
|
top = p2.z > top ? p2.z : top;
|
|
top = p3.z > top ? p3.z : top;
|
|
p0.z -= top;
|
|
p1.z -= top;
|
|
p2.z -= top;
|
|
p3.z -= top;
|
|
this->Tei_TowardScreen(p0, p1, p2, p3, this->state.slots[0].alphaT, this->state.slots[1].alphaT);
|
|
|
|
p0.x = slot.vecBNow.x + p0.x;
|
|
p0.y = slot.vecBNow.y + p0.y;
|
|
p0.z = slot.vecBNow.z + p0.z;
|
|
p1.x = slot.vecBNow.x + p1.x;
|
|
p1.y = slot.vecBNow.y + p1.y;
|
|
p1.z = slot.vecBNow.z + p1.z;
|
|
p2.x = slot.vecBNow.x + p2.x;
|
|
p2.y = slot.vecBNow.y + p2.y;
|
|
p2.z = slot.vecBNow.z + p2.z;
|
|
p3.x = slot.vecBNow.x + p3.x;
|
|
p3.y = slot.vecBNow.y + p3.y;
|
|
p3.z = slot.vecBNow.z + p3.z;
|
|
|
|
switch (slot.flag1[2]) {
|
|
case 0:
|
|
case 3:
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p0, p1, p2, p3, wtm, 1, slot.flag1[0], 1, 255, 255, 255, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
break;
|
|
case 19:
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p1, p0, p3, p2, wtm, 0, slot.flag1[0], 1, 105, 255, 105, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
break;
|
|
case 20:
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p1, p0, p3, p2, wtm, 0, slot.flag1[0], 1, 255, 5, 5, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
this->RenderTeiRect(&rpCnt, slot.alphaB, p1, p0, p3, p2, wtm, 0, slot.flag1[0], 1, 255, 155, 155, 0.0f, 1.0f, 0.0f, 1.0f, 0);
|
|
break;
|
|
}
|
|
}
|
|
}
|