void BMaxObject::UpdateGeometry()
{
SetGeometryDirty(false);
if (m_pAnimatedMesh && m_pAnimatedMesh->IsLoaded())
{
Vector3 vMin, vMax;
if (m_pAnimatedMesh->GetBoundingBox(&vMin, &vMax))
{
Matrix4 mat;
GetLocalTransform(&mat);
CShapeOBB obb(CShapeBox(vMin, vMax), mat);
CShapeBox minmaxBox;
minmaxBox.Extend(obb);
if (GetScaling()!= 1.0){
minmaxBox.SetMinMax(minmaxBox.GetMin() * GetScaling(), minmaxBox.GetMax() * GetScaling());
}
SetAABB(&minmaxBox.GetMin(), &minmaxBox.GetMax());
}
UnloadPhysics();
if (m_dwPhysicsMethod == 0)
m_dwPhysicsMethod = PHYSICS_LAZY_LOAD;
else if (IsPhysicsEnabled() && ((m_dwPhysicsMethod&PHYSICS_ALWAYS_LOAD)>0))
{
LoadPhysics();
}
}
}
void CoinAction::step(float time)
{
if(_target)
{
_target->setRotation3D(Vec3(90,angle,180));
angle+=time*140;
_target->setPosition3D (_target->getPosition3D()+Vec3(0,0,100*time));
if(_target->getPositionZ()>-40 && _target->getPositionZ()<10 )// enter the front
{
Sprite3D * sprite = dynamic_cast<Sprite3D * >(_target);
OBB obb(sprite->getAABB());
Vec3 vertices[8];
auto player_aabb= player->getPlayer()->getAABB();
auto dist =sprite->getPosition3D().distance(player->getPlayer()->getPosition3D());
if(dist<5 && !is_triggered)
{
is_triggered =~is_triggered;
sprite->setColor(Color3B(255,0,0));
Effect::CoinEffect(render_node);
auto a = (GameScene * )this->render_node;
a->earnGold();
CCLOG("get Money !!!");
return ;
}
}
if(_target->getPositionZ()>=10)
{
_target->removeFromParent();
_target=nullptr;
}
}
}
void Deferred_lighting_renderer::render_light_probe(const scene::Light_probe& light_probe, const Rendering_context& context)
{
const float4x4& world = light_probe.world_transformation();
OBB obb(world);
const auto& camera = context.camera();
if (Intersection_type::Outside == camera.frustum().intersect(obb))
{
return;
}
Rendering_device& device = rendering_tool_.device();
auto& change_per_light_data = change_per_light_.data();
change_per_light_data.world = world;
change_per_light_data.light_transformation = invert(world * camera.view());
change_per_light_data.position_vs = light_probe.world_position() * camera.view();
change_per_light_.update(device);
device.set_shader_resources(1, &light_probe.texture(), light_probe_texture_offset_);
techniques_.volume_light_probe_specular->use();
if (Intersection_type::Outside != Sphere(camera.world_position(), camera.greatest_distance_to_near_plane()).intersect(obb))
{
// camera is inside the light volume
device.set_rasterizer_state(lighting_rasterizer_states_[Cull_state::Front]);
device.set_depth_stencil_state(inside_lighting_volume_ds_state_light_, 1);
}
else
{
// camera is outside the light volume
device.set_rasterizer_state(lighting_rasterizer_states_[Cull_state::Back]);
device.set_depth_stencil_state(outside_lighting_volume_ds_state_prepare_, 1);
device.set_blend_state(z_only_blend_state_);
box_volume_.render(rendering_tool_);
device.set_rasterizer_state(lighting_rasterizer_states_[Cull_state::Front]);
device.set_depth_stencil_state(outside_lighting_volume_ds_state_light_, 2);
}
device.set_blend_state(lighting_blend_state_);
box_volume_.render(rendering_tool_);
}
matrix_type orientation(iterator_t point_begin,
iterator_t point_end,
point_t& center) const {
matrix<value_type, N, N> orientation;
value_type tightest_volume = boost::numeric::bounds<value_type>::highest();
for (int k = 0; k != _iterations; ++k) {
matrix<value_type, N, N> random;
point_t dir1 = generate_random_point();
point_t dir2 = generate_random_point();
point_t dir3 = generate_random_point();
// use ortho-normal system
dir1 /= dir1.length();
dir2 /= dir2.length();
dir3 /= dir3.length();
// normalize
dir3 = cross(dir1, dir2);
dir2 = cross(dir1, dir3);
random[0][0] = dir1[0];
random[1][0] = dir1[1];
random[2][0] = dir1[2];
random[0][1] = dir2[0];
random[1][1] = dir2[1];
random[2][1] = dir2[2];
random[0][2] = dir3[0];
random[1][2] = dir3[1];
random[2][2] = dir3[2];
// compute volume according to temporary orientation
point_t low, high;
limits(point_begin, point_end, center, random, low, high);
oriented_boundingbox<point_t> obb(random, center, low, high);
value_type volume = obb.volume();
// if tighter, apply
if (volume < tightest_volume) {
orientation = random;
tightest_volume = volume;
}
}
return orientation;
}
void analyze::applyFilter(RichParameterSet* pars)
{
starlab::LineSegments * bbox_lines = new starlab::LineSegments(1);
std::vector<starlab::LineSegments*> dir_lines(3, new starlab::LineSegments(2));
starlab::PolygonSoup * ps = new starlab::PolygonSoup;
std::vector< std::vector<double> > colors = starlab::randomColors(12);
mainWindow()->setStatusBarMessage("Finding connected pieces..");
QApplication::processEvents();
std::vector< SurfaceMesh::SurfaceMeshModel* > pieces = connectedPieces( mesh() );
std::vector<Vector3> all_points;
std::vector<MinOBB::OBB> obb( pieces.size() );
mainWindow()->setStatusBarMessage("Finding OBBs..");
QApplication::processEvents();
QElapsedTimer timer; timer.start();
if( pars->getBool("IsParallel") )
{
int N = pieces.size();
#pragma omp parallel for
for(int i = 0; i < N; i++)
{
Vector3VertexProperty points = pieces[i]->vertex_coordinates();
std::vector<Vector3> all_points;
for(auto v: pieces[i]->vertices()) all_points.push_back( points[v] );
obb[i] = MinOBB::OBB( all_points, true );
}
}
else
{
for(size_t pi = 0; pi < pieces.size(); pi++)
{
auto piece = pieces[pi];
Vector3VertexProperty points = piece->vertex_coordinates();
std::vector<Vector3> all_points;
for(auto v: piece->vertices()) all_points.push_back( points[v] );
bool isAddJitter = true;
obb[pi] = MinOBB::OBB( all_points, isAddJitter );
std::vector<Vector3> dir(3);
for(int i = 0; i < 3; i++){
dir[0][i] = obb[pi].bb.dir_1[i];
dir[1][i] = obb[pi].bb.dir_2[i];
dir[2][i] = obb[pi].bb.dir_3[i];
}
std::vector<Vector3> c = obb[pi].corners<Vector3>();
bbox_lines->addLines( (QVector<Vector3>() << c[0] << c[1] << c[5] << c[4] << c[0]).toStdVector(), Qt::black );
bbox_lines->addLines( (QVector<Vector3>() << c[0] << c[1] << c[3] << c[2] << c[0]).toStdVector(), Qt::black );
bbox_lines->addLines( (QVector<Vector3>() << c[6] << c[7] << c[3] << c[2] << c[6]).toStdVector(), Qt::black );
bbox_lines->addLines( (QVector<Vector3>() << c[6] << c[7] << c[5] << c[4] << c[6]).toStdVector(), Qt::black );
Vector3 mean(0,0,0);
for(auto p: c) mean += p;
mean /= c.size();
dir_lines[0]->addLine(mean, Vector3(mean + dir[0] * 0.5 * obb[pi].bb.length(0)), Qt::red);
dir_lines[1]->addLine(mean, Vector3(mean + dir[1] * 0.5 * obb[pi].bb.length(1)), Qt::green);
dir_lines[2]->addLine(mean, Vector3(mean + dir[2] * 0.5 * obb[pi].bb.length(2)), Qt::blue);
if( pars->getBool("VisualizeBoxes") ){
std::vector< std::vector<Vector3> > face = obb[pi].faces<Vector3>();
for(size_t i = 0; i < face.size(); i++){
ps->addPoly((QVector<starlab::QVector3>() << face[i][2] << face[i][1] << face[i][0]), QColor::fromRgbF(colors[i][0],colors[i][1],colors[i][2], 0.1));
}
}
}
}
if( pars->getBool("Visualize") )
{
drawArea()->addRenderObject(bbox_lines);
for(size_t i = 0; i < dir_lines.size(); i++) drawArea()->addRenderObject( dir_lines[i] );
drawArea()->addRenderObject(ps);
}
mainWindow()->setStatusBarMessage( QString("Done finding OBBs. (%1 ms)").arg(timer.elapsed()));
QApplication::processEvents();
Structure::Graph * graph = new Structure::Graph();
for(size_t bi = 0; bi < obb.size(); bi++)
{
MinOBB::OBB::OBBOX<Vector3> oi( obb[bi].bb );
std::vector<Vector3> dir(3);
for(int i = 0; i < 3; i++){
dir[0][i] = obb[bi].bb.dir_1[i];
dir[1][i] = obb[bi].bb.dir_2[i];
dir[2][i] = obb[bi].bb.dir_3[i];
}
Vector3 delta = dir[2] * oi.HalfSize[2];
Vector3 from = oi.Center + delta;
Vector3 to = oi.Center - delta;
NURBS::NURBSCurved curve = NURBS::NURBSCurved::createCurve(from, to);
Structure::Curve * n = new Structure::Curve(curve, QString("node%1").arg(bi));
graph->addNode( n );
}
mainWindow()->setStatusBarMessage("Now finding edges..");
QApplication::processEvents();
starlab::LineSegments * graphLines = new starlab::LineSegments(4);
for(size_t i = 0; i < obb.size(); i++){
MinOBB::OBB::OBBOX<Vector3> oi( obb[i].bb );
for(size_t j = i + 1; j < obb.size(); j++){
MinOBB::OBB::OBBOX<Vector3> oj( obb[j].bb );
bool isIsect = MinOBB::OBB::testObbObb<Vector3>( oi, oj );
if( isIsect )
{
graph->addEdge(QString("node%1").arg(i), QString("node%1").arg(j));
if( pars->getBool("VisualizeGraph") )
graphLines->addLine( oi.Center, oj.Center, Qt::magenta );
}
}
}
drawArea()->addRenderObject( graphLines );
graph->saveToFile("graph.xml");
}
//------------------------------------------------------------------------
bool Capsule::intersects( const Aabb& aabb ) const
{
// TODO: optimize this code for the AABB case.
OrientedBox obb( aabb );
return intersects( obb );
}
