596 lines
20 KiB
C++
596 lines
20 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include <cmath>
|
|
#include "scene3d/scene_debug.h"
|
|
#include "scene3d/scene.h"
|
|
#include "scene3d/mobject.h"
|
|
#include "scene3d/mlight.h"
|
|
#include "scene3d/mcamera.h"
|
|
#include "scene3d/mtrigger.h"
|
|
#include "scene3d/mconstraint.h"
|
|
#include "scene3d/instance.h"
|
|
#include "scene3d/group.h"
|
|
#include "physic/physic_constraint.h"
|
|
#include "core/renderer_toolbox.h"
|
|
#include "metafile/nml_object.h"
|
|
#include "core/path_kdtree.h"
|
|
|
|
using namespace GS;
|
|
using namespace GS::Core;
|
|
using namespace GS::S3D;
|
|
using namespace GS::Units;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void SceneDebugger::DrawItemBoundingVolume(Renderer &render, MItem *i, uint display_flags)
|
|
{
|
|
if (i && (i->GetItemType() == Type_Object))
|
|
{
|
|
if (display_flags & SceneDebugDisplayBoundingVolumes)
|
|
{
|
|
MObject *mobj = (MObject *)i;
|
|
|
|
MinMax pinmax;
|
|
mobj->ComputeLocalMinMax(pinmax);
|
|
OBB obb = OBB::FromMinMax(pinmax);
|
|
obb.Transform(i->GetBaseItem()->GetMatrix());
|
|
|
|
Color color(1, 1, 0, 0.35f);
|
|
RendererToolbox::DrawOBB(render, obb, &color, Material::Blend_Alpha);
|
|
}
|
|
|
|
if (display_flags & SceneDebugDisplayOctreeVolumes)
|
|
{
|
|
/// TODO
|
|
}
|
|
}
|
|
}
|
|
void SceneDebugger::DrawItem(Renderer &render, MItem *pitem, uint display_flags, Color *draw_color)
|
|
{
|
|
if (!pitem)
|
|
return;
|
|
|
|
Color item_color = draw_color ? *draw_color : Color(0.75f, 0.75f, 0.75f);
|
|
Color bone_color = item_color;
|
|
bone_color.w = 0.5f;
|
|
|
|
render.SetWorldMatrix(Matrix4::IdentityMatrix(), &Matrix4::IdentityMatrix());
|
|
|
|
if (pitem->GetBaseItem()->item_flags.IsSet(ItemFlagBoneHint) && pitem->GetBaseItem()->GetParent())
|
|
{
|
|
if (display_flags & SceneDebugDisplayBones)
|
|
{
|
|
Item *link = pitem->GetBaseItem()->GetParent();
|
|
Vector4 w = pitem->GetBaseItem()->GetMatrix().GetRow(3) - link->GetMatrix().GetRow(3);
|
|
float k = w.Len();
|
|
Vector4 row = link->GetMatrix().GetRow(1);
|
|
Matrix4 m = Matrix4::FromMatrix3(Matrix3::FromOrthonormalBasis(w, &row));
|
|
m.SetRow(3, link->GetMatrix().GetRow(3));
|
|
|
|
Vector4 p[6] =
|
|
{
|
|
Vector4(0, 0, 0),
|
|
Vector4(-k * 0.1f, k * 0.1f, k * 0.2f),
|
|
Vector4( k * 0.1f, k * 0.1f, k * 0.2f),
|
|
Vector4( k * 0.1f, -k * 0.1f, k * 0.2f),
|
|
Vector4(-k * 0.1f, -k * 0.1f, k * 0.2f),
|
|
Vector4( 0, 0, k)
|
|
}, wp[6];
|
|
|
|
m.Apply(wp, p, 6);
|
|
|
|
RendererToolbox::Line3D(render, wp[0], wp[1], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[0], wp[2], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[0], wp[3], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[0], wp[4], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
|
|
RendererToolbox::Line3D(render, wp[1], wp[5], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[2], wp[5], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[3], wp[5], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[4], wp[5], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
|
|
RendererToolbox::Line3D(render, wp[1], wp[2], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[2], wp[3], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[3], wp[4], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
RendererToolbox::Line3D(render, wp[4], wp[1], &bone_color, Material::Blend_Alpha, Material::RenderWord(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
}
|
|
}
|
|
|
|
// Display item motions.
|
|
if (display_flags & SceneDebugDisplayMotions)
|
|
if (pitem->automation_player && pitem->automation_player->GetMotionList().GetCount() && pitem->GetBaseItem())
|
|
{
|
|
bool found = true;
|
|
Matrix4 m = pitem->GetBaseItem()->GetMatrix();
|
|
|
|
for (int index=0; index< pitem->automation_player->GetMotionList().GetCount(); ++index)
|
|
{
|
|
Motion* motion = pitem->automation_player->GetMotionFromIndex(index);
|
|
|
|
// if(found)
|
|
{
|
|
found = false;
|
|
if(render.GetCamera())
|
|
{
|
|
Vector4 view_position = render.GetCamera()->GetPosition();
|
|
Vector4 view_position_closest_point(0, 0, 0);
|
|
float closest_t;
|
|
motion->GetClosestPoint(view_position * pitem->GetBaseItem()->GetInverseMatrix(), view_position_closest_point, &closest_t);
|
|
|
|
Vector4 sample(0, 0, 0);
|
|
motion->EvaluatePosition(Time::fromSec(closest_t+1), sample, Curve::Constant);
|
|
|
|
Color color(1,1,0);
|
|
if(sample == view_position_closest_point)
|
|
RendererToolbox::DrawCross(render, view_position_closest_point * m, Units::Mtr(1), &color);
|
|
else
|
|
{
|
|
Vector4 OrthoVec = ((view_position_closest_point - sample).Normalized()).Cross(Vector4(0.0,1.0,0.0));
|
|
|
|
RendererToolbox::Line3D(render, sample * m, (view_position_closest_point-OrthoVec) * m, &color);
|
|
RendererToolbox::Line3D(render, sample * m, (view_position_closest_point+OrthoVec) * m, &color);
|
|
}
|
|
|
|
// if(motion->quadtree.IsValid())
|
|
// motion->quadtree->draw_scene_debug(render, m);
|
|
}
|
|
}
|
|
|
|
MotionChannel *c[3];
|
|
motion->GetTransformationChannels(c, NULL, NULL);
|
|
|
|
// check all 3 channel has the same number of point, because it's a vector
|
|
// if not just continue to the next
|
|
if( c[0]->GetPoints().GetCount() != c[1]->GetPoints().GetCount()||
|
|
c[0]->GetPoints().GetCount() != c[2]->GetPoints().GetCount()||
|
|
c[1]->GetPoints().GetCount() != c[2]->GetPoints().GetCount()||
|
|
c[1]->GetPoints().GetCount() <= 1)
|
|
continue;
|
|
|
|
ArrayList <CurvePoint *> ::Iterator iteratorX(c[0]->GetPoints());
|
|
ArrayList <CurvePoint *> ::Iterator iteratorY(c[1]->GetPoints());
|
|
ArrayList <CurvePoint *> ::Iterator iteratorZ(c[2]->GetPoints());
|
|
|
|
Vector4 vec;
|
|
|
|
Array<Vector4> v;
|
|
v.Allocate(c[0]->GetPointCount()*2);
|
|
Vector4 prev_vec;
|
|
int count = 0;
|
|
|
|
for ( ; iteratorX.ObjectPtr(); ) // need to test iterator validity prior to access in case the motion has no point
|
|
{
|
|
vec.x = iteratorX.ObjectPtr()->v;
|
|
vec.y = iteratorY.ObjectPtr()->v;
|
|
vec.z = iteratorZ.ObjectPtr()->v;
|
|
|
|
if(count != 0)
|
|
{
|
|
v[(count++)-1] = prev_vec;
|
|
v[(count++)-1] = vec*m;
|
|
}
|
|
else
|
|
++count;
|
|
|
|
prev_vec = vec*m;
|
|
|
|
++iteratorX;
|
|
++iteratorY;
|
|
++iteratorZ;
|
|
}
|
|
|
|
render.DrawLine(c[0]->GetPointCount()-1, v);
|
|
|
|
// draw cross for the first and the last point
|
|
if ((c[0]->GetPoints().GetCount() > 1) && (c[1]->GetPoints().GetCount() > 1) && (c[2]->GetPoints().GetCount() > 1))
|
|
{
|
|
RendererToolbox::DrawCross(render, Vector4(c[0]->GetPoints()[0]->v, c[1]->GetPoints()[0]->v, c[2]->GetPoints()[0]->v)*m, Mtr(1), &Color::Green);
|
|
RendererToolbox::DrawCross(render, Vector4(c[0]->GetPoints()[c[0]->GetPointCount()-1]->v, c[1]->GetPoints()[c[1]->GetPointCount()-1]->v, c[2]->GetPoints()[c[2]->GetPointCount()-1]->v)*m, Mtr(1.1), &Color::Red);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void Triangle2d(Renderer &renderer, Vector4 sv[3], Color *c)
|
|
{
|
|
Vector4 wv[3];
|
|
for (int n = 0; n < 3; ++n)
|
|
wv[n] = renderer.GetCamera()->ScreenToWorld(renderer.GetViewport(), sv[n].x, sv[n].y);
|
|
Color cl[3];
|
|
for (int n = 0; n < 3; ++n)
|
|
cl[n] = *c;
|
|
RendererToolbox::Triangle3D(renderer, wv, cl, 0, 0, Material::Blend_Alpha, (Material::RenderWord)(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
}
|
|
void Cartouche(Renderer &render, Vector4 sp, float width, float height, Color *color)
|
|
{
|
|
float offset_y = 0.6f;
|
|
|
|
Vector4 v[3];
|
|
v[0].Set(sp.x - width * 0.5f, sp.y + (offset_y - 1) * height * 0.5f);
|
|
v[1].Set(sp.x + width * 0.5f, sp.y + (offset_y - 1) * height * 0.5f);
|
|
v[2].Set(sp.x + width * 0.5f, sp.y + (offset_y + 1) * height * 0.5f);
|
|
Triangle2d(render, v, color);
|
|
v[0].Set(sp.x + width * 0.5f, sp.y + (offset_y + 1) * height * 0.5f);
|
|
v[1].Set(sp.x - width * 0.5f, sp.y + (offset_y + 1) * height * 0.5f);
|
|
v[2].Set(sp.x - width * 0.5f, sp.y + (offset_y - 1) * height * 0.5f);
|
|
Triangle2d(render, v, color);
|
|
|
|
// Draw border.
|
|
for (int n = 0; n < 16; ++n)
|
|
{
|
|
v[2].Set(sp.x - width * 0.5f, sp.y);
|
|
float a = n * Deg(180.f / 16.f);
|
|
v[1].Set(sp.x - width * 0.5f - sin(a) * height * 0.25f, sp.y + (offset_y - cos(a)) * height * 0.5f);
|
|
a = (n + 1) * Deg(180.f / 16.f);
|
|
v[0].Set(sp.x - width * 0.5f - sin(a) * height * 0.25f, sp.y + (offset_y - cos(a)) * height * 0.5f);
|
|
Triangle2d(render, v, color);
|
|
}
|
|
for (int n = 0; n < 16; ++n)
|
|
{
|
|
v[0].Set(sp.x + width * 0.5f, sp.y);
|
|
float a = n * Deg(180.f / 16.f);
|
|
v[1].Set(sp.x + width * 0.5f + sin(a) * height * 0.25f, sp.y + (offset_y - cos(a)) * height * 0.5f);
|
|
a = (n + 1) * Deg(180.f / 16.f);
|
|
v[2].Set(sp.x + width * 0.5f + sin(a) * height * 0.25f, sp.y + (offset_y - cos(a)) * height * 0.5f);
|
|
Triangle2d(render, v, color);
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void SceneDebugger::DrawItemName(Renderer &renderer, MItem *pitem)
|
|
{
|
|
String label;
|
|
switch (pitem->GetItemType())
|
|
{
|
|
case Type_Object: label = "Object: "; break;
|
|
case Type_Camera: label = "Camera: "; break;
|
|
case Type_Light: label = "Light: "; break;
|
|
case Type_Trigger: label = "Trigger: "; break;
|
|
|
|
default: break;
|
|
}
|
|
label += pitem->name;
|
|
|
|
Vector4 sp;
|
|
if (!renderer.GetCamera()->WorldToScreen(renderer.GetViewport(), pitem->GetBaseItem()->GetMatrix().GetRow(3), sp))
|
|
return;
|
|
sp.y += 0.05f;
|
|
|
|
// Draw a background.
|
|
// fRect viewport = renderer.GetViewport();
|
|
// float width = profiler_font.ComputeLineWidth(label.c_str());
|
|
Color bg_color(0.5f, 0.5f, 0.5f, 0.7f);
|
|
// Cartouche(render, sp, k * width * 0.5f, k * 0.075f, &bg_color);
|
|
// render.Write(profiler_font, label, sp.x, sp.y, k, true, Renderer::AlignMiddle);
|
|
}
|
|
void SceneDebugger::DrawFigure(Renderer &render, Geometry *figure, const Matrix4 &matrix, Color &color)
|
|
{
|
|
if (!figure)
|
|
return;
|
|
|
|
uint line_count = 0;
|
|
for (uint n = 0; n < figure->pol.GetCount(); ++n)
|
|
line_count += figure->pol[n].vtx_count;
|
|
|
|
Array <Vector4> p_line(line_count * 2);
|
|
Array <Color> c_line(line_count * 2);
|
|
Vector4 *p_p = p_line;
|
|
Color *p_c = c_line;
|
|
|
|
if (p_p && p_c)
|
|
{
|
|
for (uint n = 0; n < figure->pol.GetCount(); ++n)
|
|
for (int v = 0; v < figure->pol[n].vtx_count; ++v)
|
|
{
|
|
int w = v + 1;
|
|
if (w == figure->pol[n].vtx_count)
|
|
w = 0;
|
|
|
|
*p_p++ = figure->vtx[figure->pol[n].binding[v]];
|
|
*p_p++ = figure->vtx[figure->pol[n].binding[w]];
|
|
*p_c++ = color;
|
|
*p_c++ = color;
|
|
}
|
|
|
|
render.SetWorldMatrix(matrix.AsOrthonormalBase() * Matrix4::ScaleMatrix(Vector4(scale, scale, scale)));
|
|
render.DrawLine(line_count, p_line, c_line, Material::Blend_Alpha, (Material::RenderWord)(Material::Render_NoZTest | Material::Render_NoZWrite));
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
static void DrawLineHatched(const Vector4 &a, const Vector4 &b, Vector4 *p_p, Color *p_c)
|
|
{
|
|
(*p_c++).Set(0.8f, 0.8f, 0.8f, 0.75f);
|
|
(*p_c++).Set(0.8f, 0.8f, 0.8f, 0.75f);
|
|
(*p_c++).Set(0.8f, 0.8f, 0.8f, 0.75f);
|
|
(*p_c++).Set(0.8f, 0.8f, 0.8f, 0.75f);
|
|
|
|
Vector4 dt = b - a;
|
|
*p_p++ = a; *p_p++ = a + dt * 0.2f;
|
|
*p_p++ = b; *p_p++ = b - dt * 0.2f;
|
|
}
|
|
static void DrawOBBCorners(Renderer &render, const OBB &obb, const Matrix4 &m)
|
|
{
|
|
Vector4 vtx[8];
|
|
vtx[0].Set(-0.5, 0.5, 0.5);
|
|
vtx[1].Set( 0.5, 0.5, 0.5);
|
|
vtx[2].Set( 0.5, -0.5, 0.5);
|
|
vtx[3].Set(-0.5, -0.5, 0.5);
|
|
vtx[4].Set(-0.5, 0.5, -0.5);
|
|
vtx[5].Set( 0.5, 0.5, -0.5);
|
|
vtx[6].Set( 0.5, -0.5, -0.5);
|
|
vtx[7].Set(-0.5, -0.5, -0.5);
|
|
|
|
render.SetWorldMatrix(m * Matrix4::TransformationMatrix(obb.bb_position, obb.bb_rotation, obb.bb_scale));
|
|
|
|
Array <Vector4> p_line(12 * 2 * 2);
|
|
Array <Color> c_line(12 * 2 * 2);
|
|
Vector4 *p_p = p_line;
|
|
Color *p_c = c_line;
|
|
|
|
if (p_p && p_c)
|
|
{
|
|
DrawLineHatched(vtx[0], vtx[1], p_p + 0, p_c + 0);
|
|
DrawLineHatched(vtx[1], vtx[2], p_p + 4, p_c + 4);
|
|
DrawLineHatched(vtx[2], vtx[3], p_p + 8, p_c + 8);
|
|
DrawLineHatched(vtx[3], vtx[0], p_p + 12, p_c + 12);
|
|
|
|
DrawLineHatched(vtx[4], vtx[5], p_p + 16, p_c + 16);
|
|
DrawLineHatched(vtx[5], vtx[6], p_p + 20, p_c + 20);
|
|
DrawLineHatched(vtx[6], vtx[7], p_p + 24, p_c + 24);
|
|
DrawLineHatched(vtx[7], vtx[4], p_p + 28, p_c + 28);
|
|
|
|
DrawLineHatched(vtx[0], vtx[4], p_p + 32, p_c + 32);
|
|
DrawLineHatched(vtx[1], vtx[5], p_p + 36, p_c + 36);
|
|
DrawLineHatched(vtx[2], vtx[6], p_p + 40, p_c + 40);
|
|
DrawLineHatched(vtx[3], vtx[7], p_p + 44, p_c + 44);
|
|
|
|
render.DrawLine(12 * 2, p_line, c_line, Material::Blend_Alpha, Material::Render_NoZTest);
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
void SceneDebugger::DrawScene(Renderer &render, const List <MItem *> *selection, const List <MItem *> *blacklist, uint display_flags)
|
|
{
|
|
Color middle_grey(0.72f, 0.72f, 0.72f),
|
|
selected_orange(1, 0.65f, 0.16f),
|
|
draw_color;
|
|
|
|
// Display light schematics.
|
|
ListForeachPtr(MItem *, i, scene->GetItemList())
|
|
{
|
|
if (blacklist && blacklist->Find(i))
|
|
continue;
|
|
|
|
switch (i->GetItemType())
|
|
{
|
|
case Type_Light:
|
|
if (MLight *l = (MLight *)i)
|
|
{
|
|
DrawItem(render, l, display_flags);
|
|
|
|
if (selection && selection->Find(l))
|
|
draw_color = selected_orange;
|
|
else draw_color = middle_grey;
|
|
|
|
switch (l->model)
|
|
{
|
|
case Light::Model_Point:
|
|
DrawFigure(render, pointlight.c_ptr(), l->GetMatrix(), draw_color);
|
|
break;
|
|
case Light::Model_Linear:
|
|
DrawFigure(render, linearlight.c_ptr(), l->GetMatrix(), draw_color);
|
|
break;
|
|
case Light::Model_Spot:
|
|
DrawFigure(render, spotlight.c_ptr(), l->GetMatrix(), draw_color);
|
|
break;
|
|
|
|
default: break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case Type_Object:
|
|
if (MObject *o = (MObject *)i)
|
|
{
|
|
DrawItemBoundingVolume(render, o, display_flags);
|
|
|
|
bool display_item = false;
|
|
if (!selection || selection->Find(o))
|
|
{
|
|
display_item = true;
|
|
draw_color = selected_orange;
|
|
}
|
|
else
|
|
draw_color = middle_grey;
|
|
|
|
if (display_item || o->geometry.IsEmpty())
|
|
DrawItem(render, o, display_flags, &draw_color);
|
|
|
|
// DrawFigure(render, dbg_object, obj->GetMatrix(), draw_color);
|
|
}
|
|
break;
|
|
|
|
case Type_Camera:
|
|
if (MCamera *c = (MCamera *)i)
|
|
{
|
|
DrawItem(render, c, display_flags);
|
|
|
|
if (!selection || selection->Find(c))
|
|
draw_color = selected_orange;
|
|
else draw_color = middle_grey;
|
|
|
|
DrawFigure(render, camera.c_ptr(), c->GetMatrix(), draw_color);
|
|
}
|
|
break;
|
|
|
|
case Type_Trigger:
|
|
if (MTrigger *t = (MTrigger *)i)
|
|
{
|
|
OBB obb(t->GetMatrix().GetRow(3), t->GetScale(), &t->GetRotationMatrix());
|
|
Color color(1, 0, 0);
|
|
if (t->isActive())
|
|
color.Set(0, 1, 0);
|
|
RendererToolbox::DrawOBB(render, obb, &color);
|
|
|
|
if (!selection || selection->Find(t))
|
|
draw_color = selected_orange;
|
|
else draw_color = middle_grey;
|
|
|
|
DrawFigure(render, trigger.c_ptr(), t->GetMatrix(), draw_color);
|
|
}
|
|
break;
|
|
|
|
case Type_Constraint:
|
|
if (MConstraint *c = (MConstraint *)i)
|
|
{
|
|
if (c->desc.item_a.IsNull() || c->desc.item_b.IsNull())
|
|
continue;
|
|
|
|
Vector4 wp_a = c->desc.pivot_a.GetRow(3) * c->desc.item_a->GetBaseItem()->GetMatrix(),
|
|
wp_b = c->desc.pivot_b.GetRow(3) * c->desc.item_b->GetBaseItem()->GetMatrix();
|
|
|
|
RendererToolbox::DrawCross(render, wp_a, Cm(20.f));
|
|
RendererToolbox::DrawCross(render, wp_b, Cm(20.f));
|
|
RendererToolbox::Line3D(render, wp_a, wp_b);
|
|
}
|
|
break;
|
|
|
|
case Type_Instance:
|
|
{
|
|
// the items draw debug inside this instance, only if this instance is selected
|
|
if (selection && selection->Find(i))
|
|
{
|
|
if (Instance *instance = (Instance *)i)
|
|
{
|
|
if (instance->instance_scene)
|
|
{
|
|
// call the draw debug for the object inside this scene instance
|
|
ListForeachPtr(MItem *, i_instance, instance->instance_scene->GetItemList())
|
|
{
|
|
if (i_instance->GetItemType() == Type_Object)
|
|
{
|
|
if (MObject *o = (MObject *)i_instance)
|
|
{
|
|
DrawItemBoundingVolume(render, o, display_flags);
|
|
|
|
bool display_item = false;
|
|
if (selection->Find(o))
|
|
{
|
|
display_item = true;
|
|
draw_color = selected_orange;
|
|
}
|
|
else
|
|
draw_color = middle_grey;
|
|
|
|
if (display_item || o->geometry.IsEmpty())
|
|
DrawItem(render, o, display_flags, &draw_color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
// Display bounding.
|
|
MinMax minmax;
|
|
ListForeachPtr(MItem *, i, *selection)
|
|
switch (i->GetItemType())
|
|
{
|
|
case Type_Object:
|
|
{
|
|
((MObject *)i)->ComputeLocalMinMax(minmax);
|
|
OBB obb(minmax);
|
|
DrawOBBCorners(render, obb, i->GetBaseItem()->GetMatrix());
|
|
}
|
|
break;
|
|
|
|
case Type_Instance:
|
|
{
|
|
Instance *instance = (Instance *)i;
|
|
if (instance->instance_scene)
|
|
{
|
|
instance->instance_scene->GetMinMax(minmax);
|
|
OBB obb(minmax);
|
|
DrawOBBCorners(render, obb, i->GetBaseItem()->GetMatrix());
|
|
}
|
|
}
|
|
break;
|
|
|
|
default: break;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool SceneDebugger::LoadSchematicFigures(const char *dbg_pointlight, const char *dbg_spotlight, const char *dbg_linearlight, const char *dbg_camera, const char *dbg_object, const char *dbg_trigger)
|
|
{
|
|
pointlight = new Geometry;
|
|
pointlight->name = dbg_pointlight;
|
|
NML::LoadFromFile(*pointlight, dbg_pointlight);
|
|
spotlight = new Geometry;
|
|
spotlight->name = dbg_spotlight;
|
|
NML::LoadFromFile(*spotlight, dbg_spotlight);
|
|
linearlight = new Geometry;
|
|
linearlight->name = dbg_linearlight;
|
|
NML::LoadFromFile(*linearlight, dbg_linearlight);
|
|
|
|
camera = new Geometry;
|
|
camera->name = dbg_camera;
|
|
NML::LoadFromFile(*camera, dbg_camera);
|
|
object = new Geometry;
|
|
object->name = dbg_object;
|
|
NML::LoadFromFile(*object, dbg_object);
|
|
trigger = new Geometry;
|
|
trigger->name = dbg_trigger;
|
|
NML::LoadFromFile(*trigger, dbg_trigger);
|
|
return true;
|
|
}
|
|
void SceneDebugger::SetScene(Scene *s)
|
|
{ scene = s; }
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SceneDebugger::SceneDebugger()
|
|
{
|
|
scene = NULL;
|
|
scale = 1.f;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
void Scene::DumpContentToLog() const
|
|
{
|
|
__LOG_V__ << "Dumping scene content\n\n";
|
|
|
|
__LOG_V__ << "Item list (" << GetActiveList().GetCount() << " entries):\n";
|
|
ArrayListForeachPtr(MItem *, i, GetActiveList())
|
|
{
|
|
MItem *pi = NULL;
|
|
if (i->GetBaseItem())
|
|
LocateItem(i->GetBaseItem()->GetParent(), &pi);
|
|
__LOG_V__ << " - '" << i->name << "' (" << i->GetUid() << ")";
|
|
|
|
if (pi)
|
|
__LOG_V__ << "(Linked to '" << pi->name << "' (" << pi->GetUid() << ")), (Active: " << (i->isActive() ? "yes" : "no") << ", Invisible: " << (i->GetBaseItem()->item_flags.IsSet(ItemFlagInvisible) ? "yes" : "no") << ")\n";
|
|
else __LOG_V__ << "\n";
|
|
}
|
|
__LOG_V__ << "\n";
|
|
}
|
|
//------------------------------------------------------------------------------
|