Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
1142 lines
33 KiB
C++
1142 lines
33 KiB
C++
#include "ElementRendererHeaders.hpp"
|
|
#include <MLR\MLRInfiniteLightWithFalloff.hpp>
|
|
|
|
//#define HUNT_FOR_THE_MISSING_SHADOW "micgaert"
|
|
|
|
#if defined (LAB_ONLY) && defined (HUNT_FOR_THE_MISSING_SHADOW)
|
|
#include <MLR\MLRTexturePool.hpp>
|
|
#endif
|
|
|
|
int ElementRenderer::ShapeElement::s_MaxLightsPerShape=MidLevelRenderer::Limits::Max_Number_Of_Lights_Per_Primitive;
|
|
|
|
static bool __stdcall Check2() {return ElementRenderer::ShapeElement::s_MaxLightsPerShape == 2;}
|
|
static bool __stdcall Check4() {return ElementRenderer::ShapeElement::s_MaxLightsPerShape == 4;}
|
|
|
|
static void __stdcall Enable2()
|
|
{
|
|
ElementRenderer::ShapeElement::s_MaxLightsPerShape = (ElementRenderer::ShapeElement::s_MaxLightsPerShape == 2) ? MidLevelRenderer::Limits::Max_Number_Of_Lights_Per_Primitive : 2;
|
|
}
|
|
static void __stdcall Enable4()
|
|
{
|
|
ElementRenderer::ShapeElement::s_MaxLightsPerShape = (ElementRenderer::ShapeElement::s_MaxLightsPerShape == 4) ? MidLevelRenderer::Limits::Max_Number_Of_Lights_Per_Primitive : 4;
|
|
}
|
|
|
|
bool ElementRenderer::ShapeElement::s_ShowClippedBounds = false;
|
|
static bool __stdcall Greyed() {return ElementRenderer::Element::GetCallbackSet() != NULL;}
|
|
static bool __stdcall Check_ShowShapeBounds() {return ElementRenderer::ShapeElement::s_ShowClippedBounds;}
|
|
static void __stdcall Activate_ShowShapeBounds() {ElementRenderer::ShapeElement::s_ShowClippedBounds = !ElementRenderer::ShapeElement::s_ShowClippedBounds;}
|
|
|
|
bool ElementRenderer::ShapeElement::s_CheckBounds = false;
|
|
bool ElementRenderer::ShapeElement::s_BoundsWereBad = false;
|
|
static bool __stdcall Check_CheckBounds() {return ElementRenderer::ShapeElement::s_CheckBounds;}
|
|
static void __stdcall Activate_CheckBounds() {ElementRenderer::ShapeElement::s_CheckBounds = !ElementRenderer::ShapeElement::s_CheckBounds;}
|
|
|
|
//############################################################################
|
|
//############################ ShapeElement ################################
|
|
//############################################################################
|
|
|
|
HGOSHEAP ElementRenderer::ShapeElement::s_Heap = NULL;
|
|
|
|
ElementRenderer::ShapeElement::ClassData* ElementRenderer::ShapeElement::DefaultData = NULL;
|
|
|
|
ElementRenderer::Element::SyncMethod ElementRenderer::ShapeElement::SyncMethods[SyncStateCount]=
|
|
{
|
|
//
|
|
// Root mode
|
|
//
|
|
SYNC_METHOD(ShapeElement, Clean),
|
|
SYNC_METHOD(ShapeElement, DirtyRoot),
|
|
SYNC_METHOD(ShapeElement, Clean),
|
|
SYNC_METHOD(ShapeElement, DirtyRoot),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
SYNC_METHOD(ShapeElement, Clean),
|
|
SYNC_METHOD(ShapeElement, DirtyRoot),
|
|
SYNC_METHOD(ShapeElement, Clean),
|
|
SYNC_METHOD(ShapeElement, DirtyRoot),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
|
|
//
|
|
// Sphere Cull
|
|
//
|
|
SYNC_METHOD(ShapeElement, CleanSphere),
|
|
SYNC_METHOD(ShapeElement, DirtySphere),
|
|
SYNC_METHOD(ShapeElement, CleanSphere),
|
|
SYNC_METHOD(ShapeElement, DirtySphere),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
|
|
//
|
|
// OBB Cull
|
|
//
|
|
SYNC_METHOD(ShapeElement, CleanOBB),
|
|
SYNC_METHOD(ShapeElement, DirtyOBB),
|
|
SYNC_METHOD(ShapeElement, CleanOBB),
|
|
SYNC_METHOD(ShapeElement, DirtyOBB),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
|
|
//
|
|
// Never Cull
|
|
//
|
|
SYNC_METHOD(ShapeElement, Clean),
|
|
SYNC_METHOD(ShapeElement, Dirty),
|
|
SYNC_METHOD(ShapeElement, Clean),
|
|
SYNC_METHOD(ShapeElement, Dirty),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
SYNC_METHOD(ShapeElement, Clean),
|
|
SYNC_METHOD(ShapeElement, Dirty),
|
|
SYNC_METHOD(ShapeElement, Clean),
|
|
SYNC_METHOD(ShapeElement, Dirty),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, Defer),
|
|
|
|
//
|
|
// Always Cull
|
|
//
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None),
|
|
SYNC_METHOD(Element, None)
|
|
};
|
|
|
|
ElementRenderer::Element::DrawMethod ElementRenderer::ShapeElement::DrawMethods[DrawStateCount]=
|
|
{
|
|
//
|
|
// No billboarding
|
|
//
|
|
DRAW_METHOD(ShapeElement, Inherit),
|
|
DRAW_METHOD(ShapeElement, Override)
|
|
};
|
|
|
|
DECLARE_TIMER(static, Light_Culling_Time);
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::InitializeClass(Stuff::NotationFile *startup_ini)
|
|
{
|
|
Verify(!s_Heap);
|
|
s_Heap = gos_CreateMemoryHeap("Shape", 0, g_LibraryHeap);
|
|
Check_Pointer(s_Heap);
|
|
|
|
Verify(!DefaultData);
|
|
DefaultData =
|
|
new ClassData(
|
|
ShapeElementClassID,
|
|
"ElementRenderer::ShapeElement",
|
|
BaseClass::DefaultData,
|
|
reinterpret_cast<Factory>(&Make)
|
|
);
|
|
Check_Object(DefaultData);
|
|
|
|
s_MaxLightsPerShape = MidLevelRenderer::Limits::Max_Number_Of_Lights_Per_Primitive;
|
|
s_ShowClippedBounds = false;
|
|
s_CheckBounds = false;
|
|
s_BoundsWereBad = false;
|
|
|
|
Initialize_Timer(Light_Culling_Time, "Light Culling");
|
|
AddDebuggerMenuItem("Libraries\\Graphics Options\\2 Lights/Shape", Check2, Enable2, 0 );
|
|
AddDebuggerMenuItem("Libraries\\Graphics Options\\4 Lights/Shape", Check4, Enable4, 0 );
|
|
AddDebuggerMenuItem("Libraries\\ElementRenderer\\Show Clipped Shape Bounds", Check_ShowShapeBounds, Activate_ShowShapeBounds, Greyed );
|
|
AddDebuggerMenuItem("Libraries\\ElementRenderer\\Check Bounds", Check_CheckBounds, Activate_CheckBounds, NULL );
|
|
|
|
if (startup_ini)
|
|
{
|
|
Check_Object(startup_ini);
|
|
Stuff::Page *page = startup_ini->FindPage("Graphics Options");
|
|
if (page)
|
|
{
|
|
Check_Object(page);
|
|
page->GetEntry("MaxLights", &s_MaxLightsPerShape);
|
|
Min_Clamp(s_MaxLightsPerShape, 2);
|
|
}
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::TerminateClass(Stuff::NotationFile *startup_ini)
|
|
{
|
|
if (startup_ini)
|
|
{
|
|
Check_Object(startup_ini);
|
|
Stuff::Page *page = startup_ini->SetPage("Graphics Options");
|
|
Check_Object(page);
|
|
page->SetEntry("MaxLights", s_MaxLightsPerShape);
|
|
}
|
|
|
|
Check_Object(DefaultData);
|
|
delete DefaultData;
|
|
DefaultData = NULL;
|
|
|
|
Check_Pointer(s_Heap);
|
|
gos_DestroyMemoryHeap(s_Heap);
|
|
s_Heap = NULL;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
ElementRenderer::ShapeElement::ShapeElement(
|
|
ClassData *class_data,
|
|
Stuff::MemoryStream *stream,
|
|
int version,
|
|
ShapeHolder shapes
|
|
):
|
|
Element(class_data, stream, version)
|
|
{
|
|
Check_Pointer(this);
|
|
Check_Object(stream);
|
|
|
|
unsigned index = (m_state>>SyncStateBit) & SyncStateMask;
|
|
Verify(index < SyncStateCount);
|
|
m_sync = SyncMethods[index];
|
|
index = (m_state>>CullStateBit) & CullStateMask;
|
|
Verify(index < CullStateCount);
|
|
m_cameraCull = CullMethods[index].m_cameraCull;
|
|
m_rayCull = CullMethods[index].m_rayCull;
|
|
m_sphereTest = CullMethods[index].m_sphereTest;
|
|
index = (m_state>>DrawStateBit) & DrawStateMask;
|
|
Verify(index < DrawStateCount);
|
|
m_draw = DrawMethods[index];
|
|
|
|
//
|
|
//---------------------------------
|
|
// Create the shape from the stream
|
|
//---------------------------------
|
|
//
|
|
m_worldToLocal = Stuff::LinearMatrix4D::Identity;
|
|
int mlr_version = MidLevelRenderer::ReadMLRVersion(stream);
|
|
if (mlr_version == -1)
|
|
mlr_version = version;
|
|
|
|
if (version<13)
|
|
{
|
|
if(mlr_version<14)
|
|
m_MLRShape = MidLevelRenderer::MLRShape::Make(stream, mlr_version);
|
|
else
|
|
{
|
|
RegisteredClass::ClassID class_id;
|
|
*stream >> class_id;
|
|
|
|
switch(class_id)
|
|
{
|
|
case MidLevelRenderer::MLRShapeClassID:
|
|
m_MLRShape = MidLevelRenderer::MLRShape::Make(stream, mlr_version);
|
|
break;
|
|
case MidLevelRenderer::MLRCulturShapeClassID:
|
|
m_MLRShape = MidLevelRenderer::MLRCulturShape::Make(stream, mlr_version);
|
|
break;
|
|
default:
|
|
STOP(("Don't know what this is"));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int length;
|
|
*stream >> length;
|
|
if (shapes)
|
|
m_MLRShape = (*shapes)(stream, mlr_version, length);
|
|
else
|
|
{
|
|
RegisteredClass::ClassID class_id;
|
|
*stream >> class_id;
|
|
switch(class_id)
|
|
{
|
|
case MidLevelRenderer::MLRShapeClassID:
|
|
m_MLRShape = MidLevelRenderer::MLRShape::Make(stream, mlr_version);
|
|
break;
|
|
case MidLevelRenderer::MLRCulturShapeClassID:
|
|
m_MLRShape = MidLevelRenderer::MLRCulturShape::Make(stream, mlr_version);
|
|
break;
|
|
default:
|
|
STOP(("Don't know what this is"));
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//------------------------------------------------
|
|
// Bump the OBB a tad to help with clipping errors
|
|
//------------------------------------------------
|
|
//
|
|
if (IsBoundedBySphere())
|
|
m_localOBB.sphereRadius *= 1.01f;
|
|
else
|
|
{
|
|
m_localOBB.axisExtents *= 1.01f;
|
|
m_localOBB.sphereRadius = m_localOBB.axisExtents.GetLength();
|
|
}
|
|
if (s_CheckBounds && !CheckBounds())
|
|
s_BoundsWereBad = true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
ElementRenderer::ShapeElement::ShapeElement(
|
|
ShapeElement *shape,
|
|
ClassData *class_data
|
|
):
|
|
Element(class_data, shape)
|
|
{
|
|
Check_Pointer(this);
|
|
|
|
unsigned index = (m_state>>SyncStateBit) & SyncStateMask;
|
|
Verify(index < SyncStateCount);
|
|
m_sync = SyncMethods[index];
|
|
index = (m_state>>CullStateBit) & CullStateMask;
|
|
Verify(index < CullStateCount);
|
|
m_cameraCull = CullMethods[index].m_cameraCull;
|
|
m_rayCull = CullMethods[index].m_rayCull;
|
|
m_sphereTest = CullMethods[index].m_sphereTest;
|
|
index = (m_state>>DrawStateBit) & DrawStateMask;
|
|
Verify(index < DrawStateCount);
|
|
m_draw = DrawMethods[index];
|
|
|
|
m_worldToLocal = Stuff::LinearMatrix4D::Identity;
|
|
Check_Object(shape->m_MLRShape);
|
|
m_MLRShape = shape->m_MLRShape;
|
|
m_MLRShape->AttachReference();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
ElementRenderer::ShapeElement::ShapeElement(ClassData *class_data):
|
|
Element(class_data)
|
|
{
|
|
Check_Pointer(this);
|
|
|
|
unsigned index = (m_state>>SyncStateBit) & SyncStateMask;
|
|
Verify(index < SyncStateCount);
|
|
m_sync = SyncMethods[index];
|
|
index = (m_state>>CullStateBit) & CullStateMask;
|
|
Verify(index < CullStateCount);
|
|
m_cameraCull = CullMethods[index].m_cameraCull;
|
|
m_rayCull = CullMethods[index].m_rayCull;
|
|
m_sphereTest = CullMethods[index].m_sphereTest;
|
|
index = (m_state>>DrawStateBit) & DrawStateMask;
|
|
Verify(index < DrawStateCount);
|
|
m_draw = DrawMethods[index];
|
|
|
|
m_worldToLocal = Stuff::LinearMatrix4D::Identity;
|
|
|
|
gos_PushCurrentHeap(MidLevelRenderer::ShapeHeap);
|
|
m_MLRShape = new MidLevelRenderer::MLRShape(0);
|
|
Check_Object(m_MLRShape);
|
|
gos_PopCurrentHeap();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
ElementRenderer::ShapeElement::~ShapeElement()
|
|
{
|
|
Check_Object(this);
|
|
m_MLRShape->DetachReference();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
ElementRenderer::ShapeElement* ElementRenderer::ShapeElement::Make(
|
|
Stuff::MemoryStream *stream,
|
|
int version,
|
|
ShapeHolder shapes
|
|
)
|
|
{
|
|
Check_Object(stream);
|
|
|
|
gos_PushCurrentHeap(s_Heap);
|
|
ShapeElement *element = new ShapeElement(DefaultData, stream, version, shapes);
|
|
gos_PopCurrentHeap();
|
|
|
|
return element;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::Save(Stuff::MemoryStream *stream)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(stream);
|
|
BaseClass::Save(stream);
|
|
|
|
//
|
|
//-----------------------------
|
|
// Save the shape to the stream
|
|
//-----------------------------
|
|
//
|
|
Check_Object(m_MLRShape);
|
|
MidLevelRenderer::WriteMLRVersion(stream);
|
|
*stream << (int)0;
|
|
unsigned index = stream->GetIndex();
|
|
m_MLRShape->Save(stream);
|
|
unsigned length = stream->GetIndex() - index;
|
|
stream->RewindPointer(length + sizeof(int));
|
|
*stream << length;
|
|
stream->AdvancePointer(length);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::TestInstance()
|
|
{
|
|
Verify(IsDerivedFrom(DefaultData));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool ElementRenderer::ShapeElement::CheckBounds()
|
|
{
|
|
Check_Object(this);
|
|
|
|
return (IsBoundedBySphere()) ? CheckSphereBounds(m_MLRShape, m_localOBB) : CheckOBBBounds(m_MLRShape, m_localOBB);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool ElementRenderer::ShapeElement::CheckSphereBounds(
|
|
MidLevelRenderer::MLRShape *shape,
|
|
const Stuff::OBB &sphere
|
|
)
|
|
{
|
|
Stuff::Point3D center(sphere.localToParent);
|
|
Stuff::Scalar radius_squared = sphere.sphereRadius*sphere.sphereRadius;
|
|
int meshes = shape->GetNum();
|
|
for (int m=0; m<meshes; m++)
|
|
{
|
|
MidLevelRenderer::MLRPrimitiveBase *mesh = shape->Find(m);
|
|
Check_Object(mesh);
|
|
const Stuff::Point3D *verts;
|
|
int count;
|
|
mesh->GetCoordData(&verts, &count);
|
|
for (int v=0; v<count; ++v)
|
|
{
|
|
Stuff::Vector3D diff;
|
|
diff.Subtract(verts[v], center);
|
|
if (diff.GetLengthSquared() > radius_squared)
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool ElementRenderer::ShapeElement::CheckOBBBounds(
|
|
MidLevelRenderer::MLRShape *shape,
|
|
const Stuff::OBB &obb
|
|
)
|
|
{
|
|
int meshes = shape->GetNum();
|
|
for (int m=0; m<meshes; m++)
|
|
{
|
|
MidLevelRenderer::MLRPrimitiveBase *mesh = shape->Find(m);
|
|
Check_Object(mesh);
|
|
const Stuff::Point3D *verts;
|
|
int count;
|
|
mesh->GetCoordData(&verts, &count);
|
|
for (int v=0; v<count; ++v)
|
|
{
|
|
if (!obb.Contains(verts[v]))
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::AttachChild(Element *child)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(child);
|
|
STOP(("Shape elements can't have children!"));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::DetachChild(Element *child)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(child);
|
|
STOP(("Shape elements can't have children!"));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::SetSyncState()
|
|
{
|
|
Check_Object(this);
|
|
|
|
Verify(
|
|
GetCullMode() != VolumeCullMode
|
|
|| AreBoundsWrong()
|
|
|| IsSyncDeferred()
|
|
|| (
|
|
m_localOBB.sphereRadius>0.0f
|
|
&& (IsMatrixDirty() || m_worldOBB.sphereRadius>0.0f
|
|
)
|
|
)
|
|
);
|
|
Verify(
|
|
GetCullMode() == RootMode || m_parent != NULL || AreBoundsWrong()
|
|
);
|
|
unsigned index = (m_state>>SyncStateBit) & SyncStateMask;
|
|
Verify(index < SyncStateCount);
|
|
m_sync = SyncMethods[index];
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::SetDrawState()
|
|
{
|
|
Check_Object(this);
|
|
unsigned index = (m_state>>DrawStateBit) & DrawStateMask;
|
|
Verify(index < DrawStateCount);
|
|
m_draw = DrawMethods[index];
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::DirtyRootSyncMethod()
|
|
{
|
|
Check_Object(this);
|
|
Verify(IsMatrixDirty() && GetCullMode()==RootMode);
|
|
SYNC_LOGIC("Root::Dirty::Shape");
|
|
|
|
//
|
|
//--------------------
|
|
// Update our matrices
|
|
//--------------------
|
|
//
|
|
m_localToParent = m_localToWorld = m_newLocalToParent;
|
|
m_worldToLocal.Invert(m_localToWorld);
|
|
MatrixIsClean();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::DirtySyncMethod()
|
|
{
|
|
Check_Object(this);
|
|
Verify(IsMatrixDirty() && GetCullMode()==NeverCullMode);
|
|
SYNC_LOGIC("Dirty::Shape");
|
|
|
|
//
|
|
//--------------------
|
|
// Update our matrices
|
|
//--------------------
|
|
//
|
|
m_localToParent = m_newLocalToParent;
|
|
Check_Object(m_parent);
|
|
if (!IsLocalToParentIdentity())
|
|
m_localToWorld.Multiply(m_localToParent, m_parent->GetLocalToWorld());
|
|
else
|
|
m_localToWorld = m_parent->GetLocalToWorld();
|
|
m_worldToLocal.Invert(m_localToWorld);
|
|
MatrixIsClean();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::CleanSphereSyncMethod()
|
|
{
|
|
Check_Object(this);
|
|
Verify(m_localOBB.sphereRadius > 0.0f);
|
|
Verify(
|
|
!IsMatrixDirty() && GetCullMode()==VolumeCullMode && IsBoundedBySphere()
|
|
);
|
|
SYNC_LOGIC("Sphere::Clean::Shape");
|
|
|
|
//
|
|
//-------------------------------
|
|
// Update our m_localToWorld matrix
|
|
//-------------------------------
|
|
//
|
|
Check_Object(m_parent);
|
|
if (!IsLocalToParentIdentity())
|
|
m_localToWorld.Multiply(m_localToParent, m_parent->GetLocalToWorld());
|
|
else
|
|
m_localToWorld = m_parent->GetLocalToWorld();
|
|
m_worldToLocal.Invert(m_localToWorld);
|
|
|
|
//
|
|
//------------------------------
|
|
// Transform the bounding sphere
|
|
//------------------------------
|
|
//
|
|
m_worldOBB.MultiplySphereOnly(m_localOBB, m_localToWorld);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::DirtySphereSyncMethod()
|
|
{
|
|
Check_Object(this);
|
|
Verify(m_localOBB.sphereRadius > 0.0f);
|
|
Verify(
|
|
IsMatrixDirty() && GetCullMode()==VolumeCullMode && IsBoundedBySphere()
|
|
);
|
|
SYNC_LOGIC("Sphere::Dirty::Shape");
|
|
|
|
//
|
|
//--------------------
|
|
// Update our matrices
|
|
//--------------------
|
|
//
|
|
m_localToParent = m_newLocalToParent;
|
|
Check_Object(m_parent);
|
|
if (!IsLocalToParentIdentity())
|
|
m_localToWorld.Multiply(m_localToParent, m_parent->GetLocalToWorld());
|
|
else
|
|
m_localToWorld = m_parent->GetLocalToWorld();
|
|
m_worldToLocal.Invert(m_localToWorld);
|
|
|
|
//
|
|
//------------------------------
|
|
// Transform the bounding sphere
|
|
//------------------------------
|
|
//
|
|
m_worldOBB.MultiplySphereOnly(m_localOBB, m_localToWorld);
|
|
MatrixIsClean();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::CleanOBBSyncMethod()
|
|
{
|
|
Check_Object(this);
|
|
Verify(
|
|
!IsMatrixDirty() && GetCullMode()==VolumeCullMode && IsBoundedByOBB()
|
|
);
|
|
Verify(Stuff::Close_Enough(m_localOBB.sphereRadius, m_localOBB.axisExtents.GetLength(), m_localOBB.sphereRadius*0.02f));
|
|
SYNC_LOGIC("OBB::Clean::Shape");
|
|
|
|
//
|
|
//-------------------------------
|
|
// Update our m_localToWorld matrix
|
|
//-------------------------------
|
|
//
|
|
Check_Object(m_parent);
|
|
if (!IsLocalToParentIdentity())
|
|
m_localToWorld.Multiply(m_localToParent, m_parent->GetLocalToWorld());
|
|
else
|
|
m_localToWorld = m_parent->GetLocalToWorld();
|
|
m_worldToLocal.Invert(m_localToWorld);
|
|
|
|
//
|
|
//------------------------------
|
|
// Transform the bounding sphere
|
|
//------------------------------
|
|
//
|
|
m_worldOBB.Multiply(m_localOBB, m_localToWorld);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::DirtyOBBSyncMethod()
|
|
{
|
|
Check_Object(this);
|
|
Verify(
|
|
IsMatrixDirty() && GetCullMode()==VolumeCullMode && IsBoundedByOBB()
|
|
);
|
|
Verify(Stuff::Close_Enough(m_localOBB.sphereRadius, m_localOBB.axisExtents.GetLength(), m_localOBB.sphereRadius*0.02f));
|
|
SYNC_LOGIC("OBB::Dirty::Shape");
|
|
|
|
//
|
|
//--------------------
|
|
// Update our matrices
|
|
//--------------------
|
|
//
|
|
m_localToParent = m_newLocalToParent;
|
|
Check_Object(m_parent);
|
|
if (!IsLocalToParentIdentity())
|
|
m_localToWorld.Multiply(m_localToParent, m_parent->GetLocalToWorld());
|
|
else
|
|
m_localToWorld = m_parent->GetLocalToWorld();
|
|
m_worldToLocal.Invert(m_localToWorld);
|
|
|
|
//
|
|
//------------------------------
|
|
// Transform the bounding sphere
|
|
//------------------------------
|
|
//
|
|
m_worldOBB.Multiply(m_localOBB, m_localToWorld);
|
|
MatrixIsClean();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool ElementRenderer::ShapeElement::CastCulledRay(CollisionQuery *query)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(query);
|
|
Verify(!query->m_data);
|
|
|
|
//
|
|
//-----------------------------------
|
|
// Figure out the local m_line equation
|
|
//-----------------------------------
|
|
//
|
|
const Stuff::LinearMatrix4D &world_to_local = GetWorldToLocal();
|
|
Check_Object(&world_to_local);
|
|
Stuff::Line3D local_line;
|
|
Check_Object(query->m_line);
|
|
local_line.m_origin.Multiply(query->m_line->m_origin, world_to_local);
|
|
local_line.m_direction.Multiply(query->m_line->m_direction, world_to_local);
|
|
local_line.m_length = query->m_line->m_length;
|
|
|
|
//
|
|
//-----------------------------
|
|
// Test it against the MidLevelRenderer::MLRShape
|
|
//-----------------------------
|
|
//
|
|
Stuff::Normal3D local_normal;
|
|
if (m_MLRShape)
|
|
{
|
|
Check_Object(m_MLRShape);
|
|
if (m_MLRShape->CastRay(&local_line, &local_normal))
|
|
{
|
|
query->m_line->m_length = local_line.m_length;
|
|
const Stuff::LinearMatrix4D &local_to_world = GetLocalToWorld();
|
|
Check_Object(&local_to_world);
|
|
Check_Pointer(query->m_normal);
|
|
query->m_normal->Multiply(local_normal, local_to_world);
|
|
Verify(*query->m_normal * query->m_line->m_direction <= -Stuff::SMALL);
|
|
query->m_data = m_data;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
ElementRenderer::Element* ElementRenderer::ShapeElement::FindSmallestElementContainingCulled(SphereTest *test)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(test);
|
|
return this;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::InheritDrawMethod(
|
|
CameraElement *camera,
|
|
const StateChange *inherited_state,
|
|
int culling_state
|
|
)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(inherited_state);
|
|
Check_Object(camera);
|
|
Verify(culling_state != -1);
|
|
#if defined(_ARMOR)
|
|
if (!culling_state)
|
|
Verify(!Cull(camera));
|
|
#endif
|
|
|
|
//
|
|
//--------------------------------------
|
|
// Draw our bounds if we are supposed to
|
|
//--------------------------------------
|
|
//
|
|
#if defined(LAB_ONLY)
|
|
Callback *callback = GetCallbackSet();
|
|
unsigned index = GetCallbackIndex();
|
|
if (callback && callback[index])
|
|
{
|
|
Check_Pointer(callback[index]);
|
|
(*callback[index])(camera, inherited_state, culling_state, this);
|
|
}
|
|
else if (s_ShowClippedBounds && GetCullMode() == VolumeCullMode && culling_state)
|
|
{
|
|
Stuff::RGBAColor color(1.0f, 0.5f, 0.5f, 0.3f);
|
|
if (IsBoundedBySphere())
|
|
DrawSphere(m_worldOBB, color, camera, inherited_state, culling_state);
|
|
else
|
|
DrawOBB(m_worldOBB, color, camera, inherited_state, culling_state);
|
|
}
|
|
#endif
|
|
|
|
//
|
|
//----------------------------
|
|
// Set up the draw information
|
|
//----------------------------
|
|
//
|
|
MidLevelRenderer::DrawShapeInformation info;
|
|
Check_Object(m_MLRShape);
|
|
info.shape = m_MLRShape;
|
|
info.clippingFlags.SetClippingState(culling_state);
|
|
Check_Object(&m_localToWorld);
|
|
info.shapeToWorld = &m_localToWorld;
|
|
Check_Object(&m_worldToLocal);
|
|
info.worldToShape = &m_worldToLocal;
|
|
info.state = inherited_state->GetMLRState();
|
|
info.paintMeColor = &FadeColor;
|
|
|
|
#if defined (LAB_ONLY) && defined (HUNT_FOR_THE_MISSING_SHADOW)
|
|
if(m_MLRShape->GetNum()>0)
|
|
{
|
|
MidLevelRenderer::MLRTexture *tex = (*MidLevelRenderer::MLRTexturePool::Instance)[&m_MLRShape->Find(0)->GetReferenceState()];
|
|
MidLevelRenderer::GOSImage *image = tex->GetImage();
|
|
const char *tex_name = gos_GetTextureName(image->GetHandle());
|
|
|
|
SPEW((HUNT_FOR_THE_MISSING_SHADOW, "D: %s", tex_name));
|
|
}
|
|
#endif
|
|
|
|
LightList culled_lights;
|
|
info.nrOfActiveLights = CullLights(culled_lights, inherited_state->m_lights);
|
|
info.activeLights = (info.nrOfActiveLights>0) ? &culled_lights[0] : NULL;
|
|
|
|
//
|
|
//---------------
|
|
// Draw the shape
|
|
//---------------
|
|
//
|
|
MidLevelRenderer::MLRClipper *clipper = camera->GetClipper();
|
|
Check_Object(clipper);
|
|
|
|
Stop_Timer(Graph_Traversal);
|
|
ELEMENT_RENDER("Culling::Shape::Inherited");
|
|
Start_Timer(Draw_Shapes);
|
|
clipper->DrawShape(&info);
|
|
Stop_Timer(Draw_Shapes);
|
|
Start_Timer(Graph_Traversal);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::OverrideDrawMethod(
|
|
CameraElement *camera,
|
|
const StateChange *inherited_state,
|
|
int culling_state
|
|
)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(inherited_state);
|
|
Check_Object(camera);
|
|
Verify(culling_state != -1);
|
|
#if defined(_ARMOR)
|
|
if (!culling_state)
|
|
Verify(!Cull(camera));
|
|
#endif
|
|
|
|
//
|
|
//-------------------
|
|
// Mix the properties
|
|
//-------------------
|
|
//
|
|
Check_Object(m_stateChange);
|
|
StateChange mixed;
|
|
mixed.Mix(*inherited_state, *m_stateChange);
|
|
MixLights(
|
|
mixed.m_lights,
|
|
inherited_state->m_lights,
|
|
m_stateChange->m_lights
|
|
);
|
|
|
|
//
|
|
//--------------------------------------
|
|
// Draw our bounds if we are supposed to
|
|
//--------------------------------------
|
|
//
|
|
#if defined(LAB_ONLY)
|
|
Callback *callback = GetCallbackSet();
|
|
unsigned index = GetCallbackIndex();
|
|
if (callback && callback[index])
|
|
{
|
|
Check_Pointer(callback[index]);
|
|
(*callback[index])(camera, &mixed, culling_state, this);
|
|
}
|
|
else if (s_ShowClippedBounds && GetCullMode() == VolumeCullMode && culling_state)
|
|
{
|
|
Stuff::RGBAColor color(1.0f, 0.5f, 0.5f, 0.3f);
|
|
if (IsBoundedBySphere())
|
|
DrawSphere(m_worldOBB, color, camera, &mixed, culling_state);
|
|
else
|
|
DrawOBB(m_worldOBB, color, camera, &mixed, culling_state);
|
|
}
|
|
#endif
|
|
|
|
//
|
|
//----------------------------
|
|
// Set up the draw information
|
|
//----------------------------
|
|
//
|
|
MidLevelRenderer::DrawShapeInformation info;
|
|
Check_Object(m_MLRShape);
|
|
info.shape = m_MLRShape;
|
|
info.clippingFlags.SetClippingState(culling_state);
|
|
Check_Object(&m_localToWorld);
|
|
info.shapeToWorld = &m_localToWorld;
|
|
Check_Object(&m_worldToLocal);
|
|
info.worldToShape = &m_worldToLocal;
|
|
info.state = mixed.GetMLRState();
|
|
info.paintMeColor = &FadeColor;
|
|
LightList culled_lights;
|
|
|
|
#if defined (LAB_ONLY) && defined (HUNT_FOR_THE_MISSING_SHADOW)
|
|
MidLevelRenderer::MLRTexture *tex = (*MidLevelRenderer::MLRTexturePool::Instance)[&m_MLRShape->Find(0)->GetReferenceState()];
|
|
MidLevelRenderer::GOSImage *image = tex->GetImage();
|
|
const char *tex_name = gos_GetTextureName(image->GetHandle());
|
|
|
|
SPEW((HUNT_FOR_THE_MISSING_SHADOW, "D: %s", tex_name));
|
|
#endif
|
|
|
|
info.nrOfActiveLights = CullLights(culled_lights, mixed.m_lights);
|
|
info.activeLights = (info.nrOfActiveLights>0) ? &culled_lights[0] : NULL;
|
|
|
|
//
|
|
//---------------
|
|
// Draw the shape
|
|
//---------------
|
|
//
|
|
MidLevelRenderer::MLRClipper *clipper = camera->GetClipper();
|
|
Check_Object(clipper);
|
|
|
|
Stop_Timer(Graph_Traversal);
|
|
ELEMENT_RENDER("Culling::Shape::Overridden");
|
|
Start_Timer(Draw_Shapes);
|
|
clipper->DrawShape(&info);
|
|
Stop_Timer(Draw_Shapes);
|
|
Start_Timer(Graph_Traversal);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::SetMLRShape(MidLevelRenderer::MLRShape *shape)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(shape);
|
|
|
|
if (m_MLRShape)
|
|
{
|
|
Check_Object(m_MLRShape);
|
|
m_MLRShape->DetachReference();
|
|
}
|
|
m_MLRShape = shape;
|
|
m_MLRShape->AttachReference();
|
|
}
|
|
|
|
extern DWORD Disable_Lights;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
int ElementRenderer::ShapeElement::CullLights(
|
|
LightList culled_lights,
|
|
const LightList lights
|
|
)
|
|
{
|
|
Check_Object(this);
|
|
|
|
//
|
|
//----------------------------------------------------------------
|
|
// Set up the destination light array and start copying the lights
|
|
//----------------------------------------------------------------
|
|
//
|
|
if (Disable_Lights)
|
|
return 0;
|
|
|
|
ELEMENT_RENDER("Culling::ShapeLOD::Lights");
|
|
Start_Timer(Light_Culling_Time);
|
|
int new_count = 0;
|
|
Stuff::Point3D center(m_worldOBB.localToParent);
|
|
for (int i=0; i<MidLevelRenderer::Limits::Max_Number_Of_Lights_Per_Primitive && lights[i]; ++i)
|
|
{
|
|
MidLevelRenderer::MLRLight *light = lights[i];
|
|
Check_Object(light);
|
|
Verify(new_count < MidLevelRenderer::Limits::Max_Number_Of_Lights_Per_Primitive);
|
|
if (light->GetIntensity() < Stuff::SMALL)
|
|
continue;
|
|
|
|
//
|
|
//--------------------------------------------------------------------
|
|
// If we are copying a light with a range, check it against the bounds
|
|
// of this node and only copy if it would hit the bounds
|
|
//--------------------------------------------------------------------
|
|
//
|
|
if (light->IsDerivedFrom(MidLevelRenderer::MLRInfiniteLightWithFalloff::DefaultData))
|
|
{
|
|
MidLevelRenderer::MLRInfiniteLightWithFalloff *bounded_light =
|
|
Cast_Object(MidLevelRenderer::MLRInfiniteLightWithFalloff*, light);
|
|
Stuff::Point3D lc(bounded_light->GetLightToWorldMatrix());
|
|
Stuff::Vector3D diff;
|
|
diff.Subtract(center, lc);
|
|
Stuff::Scalar range =
|
|
m_worldOBB.sphereRadius + bounded_light->GetFalloffFar();
|
|
if (diff.GetLengthSquared() < range*range)
|
|
culled_lights[new_count++] = light;
|
|
}
|
|
|
|
//
|
|
//---------------------------------
|
|
// Otherwise it is automatically in
|
|
//---------------------------------
|
|
//
|
|
else
|
|
culled_lights[new_count++] = light;
|
|
if (new_count >= s_MaxLightsPerShape)
|
|
{
|
|
#if defined (LAB_ONLY) && defined (HUNT_FOR_THE_MISSING_SHADOW)
|
|
SPEW((HUNT_FOR_THE_MISSING_SHADOW, "L: %d+", new_count));
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
#if defined (LAB_ONLY) && defined (HUNT_FOR_THE_MISSING_SHADOW)
|
|
SPEW((HUNT_FOR_THE_MISSING_SHADOW, "L: %d", new_count));
|
|
#endif
|
|
Verify(new_count <= MidLevelRenderer::Limits::Max_Number_Of_Lights_Per_Primitive);
|
|
Stop_Timer(Light_Culling_Time);
|
|
return new_count;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
int ElementRenderer::ShapeElement::CountTriangles()
|
|
{
|
|
Check_Object(this);
|
|
|
|
if (m_MLRShape)
|
|
{
|
|
Check_Object(m_MLRShape);
|
|
return m_MLRShape->GetNumPrimitives();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::CleanDamage()
|
|
{
|
|
Check_Object(this);
|
|
|
|
Check_Object(m_MLRShape);
|
|
Verify(m_MLRShape->GetReferenceCount() == 1);
|
|
m_MLRShape->CleanMe();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::ApplyDamage(
|
|
const Stuff::LinearMatrix4D &damage_spot,
|
|
Stuff::Scalar radius
|
|
)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(&damage_spot);
|
|
|
|
Check_Object(m_MLRShape);
|
|
Verify(m_MLRShape->GetReferenceCount() == 1);
|
|
m_MLRShape->HurtMe(damage_spot, radius);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::ApplyDamageDecal(
|
|
const Stuff::LinearMatrix4D &damage_spot,
|
|
Stuff::Scalar radius,
|
|
MidLevelRenderer::MLRTexture *texture
|
|
)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(&damage_spot);
|
|
|
|
Check_Object(m_MLRShape);
|
|
Verify(m_MLRShape->GetReferenceCount() == 1);
|
|
m_MLRShape->HurtMe(damage_spot, radius, texture);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::CastShadow(
|
|
const Stuff::LinearMatrix4D &shadow_to_world,
|
|
const Stuff::UnitVector3D &sun_in_world,
|
|
Stuff::Scalar radius
|
|
)
|
|
{
|
|
if (!IsShadowed())
|
|
return;
|
|
MidLevelRenderer::MLRShape *mlr_shape = GetMLRShape();
|
|
Stuff::LinearMatrix4D world_to_object;
|
|
world_to_object.Invert(GetLocalToWorld());
|
|
Stuff::UnitVector3D sun_in_object;
|
|
sun_in_object.Multiply(sun_in_world, world_to_object);
|
|
Stuff::LinearMatrix4D shadow_to_object;
|
|
shadow_to_object.Multiply(shadow_to_world, world_to_object);
|
|
|
|
mlr_shape->DrawMyShadow(shadow_to_object, sun_in_object, radius);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void ElementRenderer::ShapeElement::MakeFootStep(
|
|
MidLevelRenderer::MLRShape *shape,
|
|
const Stuff::LinearMatrix4D &foot,
|
|
Stuff::Scalar radius,
|
|
MidLevelRenderer::MLRTexture *tex
|
|
)
|
|
{
|
|
MidLevelRenderer::MLRShape *mlr_shape = GetMLRShape();
|
|
|
|
Stuff::LinearMatrix4D world_to_object;
|
|
world_to_object.Invert(GetLocalToWorld());
|
|
|
|
Stuff::LinearMatrix4D foot_to_object;
|
|
foot_to_object.Multiply(foot, world_to_object);
|
|
|
|
mlr_shape->StepOnMe(shape, foot_to_object, radius, tex);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Returns array of vertex coordinates and number of vertices
|
|
void ElementRenderer::ShapeElement::GetCoordData(Stuff::DynamicArrayOf<Stuff::Point3D> *array)
|
|
{
|
|
Check_Object(this);
|
|
array->SetLength(0);
|
|
|
|
int meshes = m_MLRShape->GetNum();
|
|
for(int m=0; m<meshes; m++)
|
|
{
|
|
MidLevelRenderer::MLRPrimitiveBase *mesh = m_MLRShape->Find(m);
|
|
Check_Object(mesh);
|
|
const Stuff::Point3D *verts;
|
|
int count;
|
|
mesh->GetCoordData(&verts, &count);
|
|
|
|
int point_count = array->GetLength();
|
|
array->SetLength(point_count+count);
|
|
for (int v=0; v<count; ++v)
|
|
{
|
|
(*array)[point_count+v]=verts[v];
|
|
}
|
|
}
|
|
}
|