void Physx1::MakeBlocks()
{
PxTransform m_transform(PxVec3(0, 20, 0));
PxBoxGeometry box(2, 2, 2);
float density = 50;
m_dynamicActor = PxCreateDynamic(*m_Physics, m_transform, box, *m_PhysicsMaterial, density);
m_boxActors.push_back(m_dynamicActor);
int size = m_boxActors.size();
m_PhysicsScene->addActor(*m_boxActors[size - 1]);
m_boxCount++;
std::cout << "Boxes in Scene: " << m_boxCount << "\n";
}
reference dereference() const
{
const context &context = super_type::base().get_buffer().get_context();
command_queue queue(context, context.get_device());
detail::meta_kernel k("read");
size_t output_arg = k.add_arg<value_type *>(memory_object::global_memory, "output");
k << "*output = " << m_transform(super_type::base()[k.lit(0)]) << ";";
kernel kernel = k.compile(context);
buffer output_buffer(context, sizeof(value_type));
kernel.set_arg(output_arg, output_buffer);
queue.enqueue_task(kernel);
return detail::read_single_value<value_type>(output_buffer, queue);
}
AABB AnimatedTransform::getTranslationBounds() const {
if (m_tracks.size() == 0) {
Point p = m_transform(Point(0.0f));
return AABB(p, p);
}
AABB aabb;
for (size_t i=0; i<m_tracks.size(); ++i) {
const AbstractAnimationTrack *absTrack = m_tracks[i];
switch (absTrack->getType()) {
case AbstractAnimationTrack::ETranslationX:
case AbstractAnimationTrack::ETranslationY:
case AbstractAnimationTrack::ETranslationZ: {
int idx = absTrack->getType() - AbstractAnimationTrack::ETranslationX;
const FloatTrack *track =
static_cast<const FloatTrack *>(absTrack);
for (size_t j=0; j<track->getSize(); ++j) {
Float value = track->getValue(j);
aabb.max[idx] = std::max(aabb.max[idx], value);
aabb.min[idx] = std::min(aabb.min[idx], value);
}
}
break;
case AbstractAnimationTrack::ETranslationXYZ: {
const VectorTrack *track =
static_cast<const VectorTrack *>(absTrack);
for (size_t j=0; j<track->getSize(); ++j)
aabb.expandBy(Point(track->getValue(j)));
}
break;
default:
break;
}
}
for (int i=0; i<3; ++i) {
if (aabb.min[i] > aabb.max[i])
aabb.min[i] = aabb.max[i] = 0.0f;
}
return aabb;
}
void on_change(const vrpn_TRACKERCB t)
{
tf::Vector3 pos(t.pos[0], t.pos[1], t.pos[2]);
pos = m_transform(pos);
m_target.transform.translation.x = pos.x() * m_scaling.x();
m_target.transform.translation.y = pos.y() * m_scaling.y();
m_target.transform.translation.z = pos.z() * m_scaling.z();
tf::Quaternion quat(t.quat[0], t.quat[1], t.quat[2], t.quat[3]);
quat = m_transform * quat;
m_target.transform.rotation.x = quat.x() * sign(m_scaling.x());
m_target.transform.rotation.y = quat.y() * sign(m_scaling.y());
m_target.transform.rotation.z = quat.z() * sign(m_scaling.z());
m_target.transform.rotation.w = quat.w();
m_target.header.stamp = ros::Time::now();
m_br.sendTransform(m_target);
}
AABB AnimatedTransform::getSpatialBounds(const AABB &aabb) const {
AABB result;
if (m_tracks.size() == 0) {
for (int j=0; j<8; ++j)
result.expandBy(m_transform(aabb.getCorner(j)));
} else {
/* Compute approximate bounds */
int nSteps = 100;
AABB1 timeBounds = getTimeBounds();
Float step = timeBounds.getExtents().x / (nSteps-1);
for (int i=0; i<nSteps; ++i) {
const Transform &trafo = eval(timeBounds.min.x + step * i);
for (int j=0; j<8; ++j)
result.expandBy(trafo(aabb.getCorner(j)));
}
}
return result;
}
nv_math::vec4f VkeCamera::worldPosition(nv_math::vec4f &inPosition){
return m_transform(inPosition);
}
nv_math::vec4f Node::worldPosition(nv_math::vec4f &inPosition){
return m_transform(inPosition);
}
nv_math::vec4f Node::worldPosition(){
nv_math::vec4f outPosition(0.0, 0.0, 0.0, 1.0);
return m_transform(outPosition);
}
