dAnimIKController* CreateHuman(DemoEntity* const model, const dMatrix& origin)
{
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData(GetWorld());
DemoEntity* const character = (DemoEntity*)model->CreateClone();
character->SetNameID("dommyRoot");
character->ResetMatrix(*scene, character->GetCurrentMatrix() * origin);
scene->Append(character);
dAnimIKController* const controller = CreateSkeletonRig(character);
// dAnimCharacterUserData* const userData = new dAnimCharacterUserData(controller);
// character->SetUserData(userData);
// populate base pose
PopulateBasePose(controller->GetBasePose(), character);
//dAnimTakeData* const walkCycle = LoadAnimation(controller, "whiteman_walk.ngd");
dAnimTakeData* const walkCycle = LoadAnimation(controller, "whiteman_idle.ngd");
dAnimIKBlendNodeTake* const walk = new dAnimIKBlendNodeTake(controller, walkCycle);
//dAnimIKBlendNodePose* const walk = new dAnimIKBlendNodePose(controller);
//dAnimIKBlendNodePose* const pose = new dAnimIKBlendNodePose(controller);
dAnimIKBlendNodeRoot* const animTree = new dAnimIKBlendNodeRoot(controller, walk);
//dAnimIKBlendNodeRoot* const animTree = new dAnimIKBlendNodeRoot(controller, pose);
controller->SetAnimationTree(animTree);
return controller;
}
void PreUpdate(dFloat timestep)
{
NewtonWorld* const workd = GetWorld();
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(workd);
bool mouseClick = scene->GetMouseKeyState(0);
if (!m_mouseDown && mouseClick) {
if (!m_body) {
// pick a body form teh scene
int mouseX;
int mouseY;
DemoCamera* const camera = scene->GetCamera();
scene->GetMousePosition(mouseX, mouseY);
dFloat x = dFloat(mouseX);
dFloat y = dFloat(mouseY);
dVector p0(camera->ScreenToWorld(dVector(x, y, 0.0f, 0.0f)));
dVector p1(camera->ScreenToWorld(dVector(x, y, 1.0f, 0.0f)));
RayCastCompoundsAllSubShapes(p0, p1);
}
} else if (m_mouseDown && !mouseClick) {
// release the body
m_body = NULL;
}
m_mouseDown = mouseClick;
}
static void OnReconstructMainMeshCallBack (NewtonBody* const body, NewtonFracturedCompoundMeshPart* const mainMesh, const NewtonCollision* const fracturedCompoundCollision)
{
DemoEntity* const entity = (DemoEntity*)NewtonBodyGetUserData(body);
DemoMesh* const visualMesh = (DemoMesh*)entity->GetMesh();
dAssert (visualMesh->IsType(DemoMesh::GetRttiType()));
dAssert (NewtonCollisionGetType(fracturedCompoundCollision) == SERIALIZE_ID_FRACTURED_COMPOUND);
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(NewtonBodyGetWorld(body));
dAssert (scene);
visualMesh->RemoveAll();
for (void* segment = NewtonFracturedCompoundMeshPartGetFirstSegment(mainMesh); segment; segment = NewtonFracturedCompoundMeshPartGetNextSegment (segment)) {
DemoSubMesh* const subMesh = visualMesh->AddSubMesh();
int material = NewtonFracturedCompoundMeshPartGetMaterial (segment);
int indexCount = NewtonFracturedCompoundMeshPartGetIndexCount (segment);
subMesh->m_textureHandle = AddTextureRef ((GLuint)material);
subMesh->m_shader = scene->GetShaderCache().m_diffuseEffect;
subMesh->AllocIndexData (indexCount);
subMesh->m_indexCount = NewtonFracturedCompoundMeshPartGetIndexStream (fracturedCompoundCollision, mainMesh, segment, (int*)subMesh->m_indexes);
}
visualMesh->OptimizeForRender();
}
VALUE MSNewton::Servo::set_power(VALUE self, VALUE v_joint, VALUE v_power) {
JointData* joint_data = Util::value_to_joint2(v_joint, JT_SERVO);
ServoData* cj_data = (ServoData*)joint_data->cj_data;
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(joint_data->world);
cj_data->power = Util::clamp_min(Util::value_to_dFloat(v_power), 0.0f) * world_data->scale5;
return Util::to_value(cj_data->power * world_data->inverse_scale5);
}
void SpawnRandomProp(const dMatrix& location) const
{
NewtonWorld* const world = GetWorld();
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData(world);
//scene->SetCurrent();
static PrimitiveType proSelection[] = {_SPHERE_PRIMITIVE, _BOX_PRIMITIVE, _CAPSULE_PRIMITIVE, _CYLINDER_PRIMITIVE, _CONE_PRIMITIVE,
_CHAMFER_CYLINDER_PRIMITIVE, _RANDOM_CONVEX_HULL_PRIMITIVE, _REGULAR_CONVEX_HULL_PRIMITIVE};
PrimitiveType type = PrimitiveType (dRand() % (sizeof (proSelection) / sizeof (proSelection[0])));
dVector size (0.35f, 0.25f, 0.25f, 0.0f);
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), size, type, 0);
DemoMesh* const geometry = new DemoMesh("prop", collision, "smilli.tga", "smilli.tga", "smilli.tga");
dMatrix matrix (location);
matrix.m_posit.m_y += 0.5f;
NewtonBody* const prop = CreateSimpleSolid (scene, geometry, 30.0f, matrix, collision, 0);
NewtonDestroyCollision(collision);
geometry->Release();
dFloat initialSpeed = 20.0f;
dVector veloc (matrix.m_front.Scale (initialSpeed));
NewtonBodySetVelocity(prop, &veloc[0]);
NewtonBodySetLinearDamping(prop, 0);
}
void* dNewtonBody::GetInterpolatedRotation()
{
const dNewtonWorld* const world = (dNewtonWorld*) NewtonWorldGetUserData(NewtonBodyGetWorld(m_body));
ScopeLock scopelock(&m_lock);
m_interpolatedRotation = m_rotation0.Slerp(m_rotation1, world->m_interpotationParam);
return &m_interpolatedRotation.m_q0;
}
VALUE MSNewton::Bodies::get_force_in_between(VALUE self, VALUE v_body1, VALUE v_body2) {
const NewtonBody* body1 = Util::value_to_body(v_body1);
const NewtonBody* body2 = Util::value_to_body(v_body2);
Util::validate_two_bodies(body1, body2);
dVector net_force(0.0f, 0.0f, 0.0f);
for (NewtonJoint* joint = NewtonBodyGetFirstContactJoint(body1); joint; joint = NewtonBodyGetNextContactJoint(body1, joint)) {
if (NewtonJointGetBody0(joint) == body2 || NewtonJointGetBody1(joint) == body2) {
for (void* contact = NewtonContactJointGetFirstContact(joint); contact; contact = NewtonContactJointGetNextContact(joint, contact)) {
NewtonMaterial* material = NewtonContactGetMaterial(contact);
dVector force;
NewtonMaterialGetContactForce(material, body1, &force[0]);
net_force += force;
}
}
}
const NewtonWorld* world = NewtonBodyGetWorld(body1);
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(world);
//BodyData* body1_data = (BodyData*)NewtonBodyGetUserData(body1);
//BodyData* body2_data = (BodyData*)NewtonBodyGetUserData(body2);
/*if (world_data->gravity_enabled && (body1_data->gravity_enabled || body2_data->gravity_enabled)) {
for (int i = 0; i < 3; ++i)
net_force[i] *= world_data->inverse_scale;
}*/
return Util::vector_to_value(net_force, world_data->inverse_scale4);
}
static void OnEmitFracturedChunk (NewtonBody* const chunkBody, NewtonFracturedCompoundMeshPart* const fractureChunkMesh, const NewtonCollision* const fracturedCompoundCollision)
{
NewtonWorld* const world = NewtonBodyGetWorld(chunkBody);
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(world);
// set the force an torque call back
NewtonBodySetForceAndTorqueCallback (chunkBody, PhysicsApplyGravityForce);
// set the transform callback
NewtonBodySetTransformCallback (chunkBody, DemoEntity::TransformCallback);
// create the visual entity and mesh, and set the use data
dMatrix matrix;
NewtonBodyGetMatrix (chunkBody, &matrix[0][0]);
DemoEntity* const visualChunkEntity = new DemoEntity(matrix, NULL);
scene->Append(visualChunkEntity);
NewtonBodySetUserData (chunkBody, visualChunkEntity);
// create the mesh geometry and attach it to the entity
DemoMesh* const visualChunkMesh = new DemoMesh ("fracturedChuckMesh");
visualChunkEntity->SetMesh (visualChunkMesh, dGetIdentityMatrix());
visualChunkMesh->Release();
// add the vertex data
AddMeshVertexwData (visualChunkMesh, fractureChunkMesh, fracturedCompoundCollision);
// add the mesh indices
OnReconstructMainMeshCallBack (chunkBody, fractureChunkMesh, fracturedCompoundCollision);
}
void CreatCasterBody(dFloat location_x, dFloat location_z, PrimitiveType shapeType, int materialID)
{
NewtonWorld* const world = ((CustomControllerManager<dClosestDistanceRecord>*)GetManager())->GetWorld();
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(world);
//dMatrix matrix (GetIdentityMatrix());
dMatrix matrix (dRollMatrix(3.141592f/2.0f));
matrix.m_posit.m_x = location_x;
matrix.m_posit.m_y = 2.0f;
matrix.m_posit.m_z = location_z;
// create the shape and visual mesh as a common data to be re used
dVector size(0.5f, 0.5f, 0.75f, 0.0f);
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), size, shapeType, materialID);
// DemoMesh____* const geometry = new DemoMesh____("cylinder_1", collision, "wood_0.tga", "wood_0.tga", "wood_1.tga");
DemoMesh* const geometry = new DemoMesh("convexShape", collision, "smilli.tga", "smilli.tga", "smilli.tga");
m_body = CreateSimpleSolid (scene, geometry, 1.0f, matrix, collision, materialID);
// disable gravity and apply a force that only spin the body
//NewtonBodySetForceAndTorqueCallback(m_myBody, PhysicsSpinBody);
//NewtonBodySetAutoSleep (m_myBody, 0);
geometry->Release();
NewtonDestroyCollision (collision);
}
virtual const void InitRigiBody(const NewtonBody* const body, const char* const bodyName) const
{
dMatrix matrix;
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(NewtonBodyGetWorld(body));
NewtonCollision* const collision = NewtonBodyGetCollision(body);
DemoMesh* const mesh = new DemoMesh("ragdoll", collision, "smilli.tga", "smilli.tga", "smilli.tga");
NewtonBodyGetMatrix(body, &matrix[0][0]);
DemoEntity* const entity = new DemoEntity(matrix, NULL);
entity->SetNameID (bodyName);
entity->SetMesh(mesh, dGetIdentityMatrix());
scene->Append(entity);
mesh->Release();
// save the pointer to the graphic object with the body.
NewtonBodySetUserData(body, entity);
// assign the wood id
NewtonBodySetMaterialGroupID(body, m_material);
//set continuous collision mode
//NewtonBodySetContinuousCollisionMode (rigidBody, continueCollisionMode);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback(body, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback(body, DemoEntity::TransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback(body, PhysicsApplyGravityForce);
}
void* dNewtonBody::GetInterpolatedPosition()
{
const dNewtonWorld* const world = (dNewtonWorld*)NewtonWorldGetUserData(NewtonBodyGetWorld(m_body));
ScopeLock scopelock(&m_lock);
m_interpolatedPosit = m_posit0 + (m_posit1 - m_posit0).Scale(world->m_interpotationParam);
return &m_interpolatedPosit.m_x;
}
VALUE MSNewton::Slider::set_max(VALUE self, VALUE v_joint, VALUE v_max) {
JointData* joint_data = Util::value_to_joint2(v_joint, JT_SLIDER);
SliderData* cj_data = (SliderData*)joint_data->cj_data;
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(joint_data->world);
cj_data->max = Util::value_to_dFloat(v_max) * world_data->scale;
return Util::to_value(cj_data->max * world_data->inverse_scale);
}
void PostUpdate(dFloat timestep, int threadIndex)
{
int count = 1;
void* nodes[32];
dMatrix parentMatrix[32];
nodes[0] = NewtonInverseDynamicsGetRoot(m_kinematicSolver);
parentMatrix[0] = dGetIdentityMatrix();
NewtonWorld* const world = GetManager()->GetWorld();
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(world);
while (count) {
dMatrix matrix;
count --;
void* const rootNode = nodes[count];
NewtonBody* const body = NewtonInverseDynamicsGetBody(m_kinematicSolver, rootNode);
NewtonBodyGetMatrix (body, &matrix[0][0]);
dMatrix localMatrix (matrix * parentMatrix[count]);
DemoEntity* const ent = (DemoEntity*)NewtonBodyGetUserData(body);
dQuaternion rot(localMatrix);
ent->SetMatrix(*scene, rot, localMatrix.m_posit);
matrix = matrix.Inverse();
for (void* node = NewtonInverseDynamicsGetFirstChildNode(m_kinematicSolver, rootNode); node; node = NewtonInverseDynamicsGetNextChildNode(m_kinematicSolver, node)) {
nodes[count] = node;
parentMatrix[count] = matrix;
count ++;
}
}
}
VALUE MSNewton::Slider::set_friction(VALUE self, VALUE v_joint, VALUE v_friction) {
JointData* joint_data = Util::value_to_joint2(v_joint, JT_SLIDER);
SliderData* cj_data = (SliderData*)joint_data->cj_data;
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(joint_data->world);
cj_data->friction = Util::clamp_min<dFloat>(Util::value_to_dFloat(v_friction), 0.0f) * world_data->scale4;
return Util::to_value(cj_data->friction * world_data->inverse_scale4);
}
VALUE MSNewton::CurvySlider::set_angular_friction(VALUE self, VALUE v_joint, VALUE v_friction) {
JointData* joint_data = Util::value_to_joint2(v_joint, JT_CURVY_SLIDER);
CurvySliderData* cj_data = (CurvySliderData*)joint_data->cj_data;
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(joint_data->world);
cj_data->angular_friction = Util::clamp_min(Util::value_to_dFloat(v_friction), 0.0f) * world_data->scale5;
return Util::to_value(cj_data->angular_friction * world_data->inverse_scale5);
}
void OnUpdateTransform (const dAnimationRigJoint* const bone, const dMatrix& localMatrix) const
{
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData(GetWorld());
NewtonBody* const newtonBody = bone->GetNewtonBody();
DemoEntity* const meshEntity = (DemoEntity*)NewtonBodyGetUserData(newtonBody);
dQuaternion rot(localMatrix);
meshEntity->SetMatrix(*scene, rot, localMatrix.m_posit);
}
int dNewton::OnBodiesAABBOverlap (const NewtonMaterial* const material, const NewtonBody* const body0, const NewtonBody* const body1, int threadIndex)
{
dAssert (NewtonBodyGetWorld (body0) == NewtonBodyGetWorld (body1));
dNewton* const world = (dNewton*) NewtonWorldGetUserData(NewtonBodyGetWorld (body0));
dNewtonBody* const dBody0 = (dNewtonBody*) NewtonBodyGetUserData (body0);
dNewtonBody* const dBody1 = (dNewtonBody*) NewtonBodyGetUserData (body1);
return world->OnBodiesAABBOverlap(dBody0, dBody1, threadIndex);
}
VALUE MSNewton::CurvySlider::get_cur_point(VALUE self, VALUE v_joint) {
JointData* joint_data = Util::value_to_joint2(v_joint, JT_CURVY_SLIDER);
CurvySliderData* cj_data = (CurvySliderData*)joint_data->cj_data;
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(joint_data->world);
if (cj_data->cur_data_set)
return Util::point_to_value(cj_data->cur_point, world_data->inverse_scale);
else
return Qnil;
}
BasicCarControllerManager (NewtonWorld* const world)
:CustomVehicleControllerManager (world)
,m_externalView(true)
,m_player (NULL)
{
// hook a callback for 2d help display
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData(world);
scene->Set2DDisplayRenderFunction (RenderVehicleHud, this);
}
virtual void OnUpdateTransform(const dAnimationJoint* const bone, const dMatrix& localMatrix) const
{
// calculate the local transform for this player body
NewtonBody* const body = bone->GetBody();
DemoEntity* const ent = (DemoEntity*)NewtonBodyGetUserData(body);
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(NewtonBodyGetWorld(body));
dQuaternion rot(localMatrix);
ent->SetMatrix(*scene, rot, localMatrix.m_posit);
}
virtual void OnUpdateTransform (const dCustomActiveCharacterController::dSkeletonBone* const bone, const dMatrix& localMatrix) const
{
DemoEntity* const ent = (DemoEntity*) NewtonBodyGetUserData(bone->m_body);
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData(NewtonBodyGetWorld(bone->m_body));
dQuaternion rot (localMatrix);
ent->SetMatrix (*scene, rot, localMatrix.m_posit);
dCustomActiveCharacterControllerManager::OnUpdateTransform (bone, localMatrix);
}
void _CDECL World::newtonLeaveWorld( const NewtonBody* body, int threadIndex )
{
OgreNewt::World* me = (OgreNewt::World*)NewtonWorldGetUserData( NewtonBodyGetWorld( body ) );
if (me->m_leaveCallback)
{
OgreNewt::Body* b = (OgreNewt::Body*)NewtonBodyGetUserData( body );
me->m_leaveCallback( b, threadIndex );
}
}
VALUE MSNewton::CurvySlider::add_point(VALUE self, VALUE v_joint, VALUE v_position) {
JointData* joint_data = Util::value_to_joint2(v_joint, JT_CURVY_SLIDER);
CurvySliderData* cj_data = (CurvySliderData*)joint_data->cj_data;
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(joint_data->world);
dVector point = Util::value_to_point(v_position, world_data->scale);
dMatrix pin_matrix;
MSNewton::Joint::c_get_pin_matrix(joint_data, pin_matrix);
cj_data->points.push_back(pin_matrix.UntransformVector(point));
cj_data->curve_len = c_calc_curve_length(cj_data->points, cj_data->loop);
return Util::to_value(cj_data->points.size() - 1);
}
void dNewton::OnContactProcess (const NewtonJoint* const contactJoint, dFloat timestep, int threadIndex)
{
NewtonBody* const body = NewtonJointGetBody0 (contactJoint);
dNewton* const world = (dNewton*) NewtonWorldGetUserData(NewtonBodyGetWorld (body));
// for (void* contact = NewtonContactJointGetFirstContact (contactJoint); contact; contact = NewtonContactJointGetNextContact (contactJoint, contact)) {
// NewtonMaterial* const material = NewtonContactGetMaterial (contact);
// NewtonMaterialSetContactFrictionCoef (material, 1.0f, 1.0f, 0);
// NewtonMaterialSetContactFrictionCoef (material, 1.0f, 1.0f, 1);
// }
dNewtonContactMaterial contactMaterial ((void*)contactJoint);
world->OnContactProcess (&contactMaterial, timestep, threadIndex);
}
AnimatedPlayerControllerManager(NewtonWorld* const world)
:dCustomPlayerControllerManager(world)
, m_player(NULL)
{
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(GetWorld());
scene->SetUpdateCameraFunction(UpdateCameraCallback, this);
scene->Set2DDisplayRenderFunction(RenderPlayerHelp, NULL, this);
// load the animation sequences.
GetAnimationSequence("whiteman_idle.ngd");
GetAnimationSequence("whiteman_walk.ngd");
}
VALUE MSNewton::CurvySlider::get_points(VALUE self, VALUE v_joint) {
JointData* joint_data = Util::value_to_joint2(v_joint, JT_CURVY_SLIDER);
CurvySliderData* cj_data = (CurvySliderData*)joint_data->cj_data;
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(joint_data->world);
dMatrix pin_matrix;
MSNewton::Joint::c_get_pin_matrix(joint_data, pin_matrix);
VALUE v_points = rb_ary_new();
for(std::vector<dVector>::iterator it = cj_data->points.begin(); it != cj_data->points.end(); ++it) {
dVector point = pin_matrix.TransformVector(*it);
rb_ary_push(v_points, Util::point_to_value(point, world_data->inverse_scale));
}
return v_points;
}
void DemoSoundListener::PostUpdate (const NewtonWorld* const world, dFloat timestep)
{
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData(world);
DemoCamera* const camera = scene->GetCamera();
dMatrix matrix0 (camera->GetCurrentMatrix ());
dMatrix matrix1 (camera->GetNextMatrix ());
dVector veloc ((matrix1.m_posit - matrix0.m_posit).Scale (1.0f / timestep));
//printf ("%f %f %f %f\n", veloc.m_x, veloc.m_y, veloc.m_z, timestepInSecunds);
UpdateListener (matrix1.m_posit, veloc, matrix0.m_front, matrix0.m_up);
dSoundManager::Update();
}
void dNewtonDynamicBody::InitForceAccumulators()
{
dFloat mass;
dFloat Ixx;
dFloat Iyy;
dFloat Izz;
NewtonBodyGetMass(m_body, &mass, &Ixx, &Iyy, &Izz);
const dNewtonWorld* const world = (dNewtonWorld*)NewtonWorldGetUserData(NewtonBodyGetWorld(m_body));
m_externalForce = world->GetGravity().Scale(mass);
m_externalTorque = dVector(0.0f);
}
VALUE MSNewton::CurvySlider::get_point_position(VALUE self, VALUE v_joint, VALUE v_point_index) {
JointData* joint_data = Util::value_to_joint2(v_joint, JT_CURVY_SLIDER);
CurvySliderData* cj_data = (CurvySliderData*)joint_data->cj_data;
WorldData* world_data = (WorldData*)NewtonWorldGetUserData(joint_data->world);
unsigned int point_index = Util::value_to_uint(v_point_index);
if (point_index < cj_data->points.size()) {
dMatrix pin_matrix;
MSNewton::Joint::c_get_pin_matrix(joint_data, pin_matrix);
dVector point = pin_matrix.TransformVector(cj_data->points[point_index]);
return Util::point_to_value(point, world_data->inverse_scale);
}
else
return Qnil;
}
virtual void PreUpdate (dFloat timestep)
{
(void)timestep;
NewtonWorld* const world = GetWorld();
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData(world);
NewtonDemos* const mainWindow = scene->GetRootWindow();
DemoCamera* const camera = scene->GetCamera();
m_helpKey.UpdatePushButton (mainWindow, 'H');
if (m_selectShape.UpdateTriggerButton (mainWindow, ' ')) {
m_stupidLevel->ChangeCastingShape();
}
bool buttonState = mainWindow->GetMouseKeyState(1);
if (buttonState) {
int mouseX;
int mouseY;
buttonState = false;
mainWindow->GetMousePosition (mouseX, mouseY);
float x = dFloat (mouseX);
float y = dFloat (mouseY);
dVector p0 (camera->ScreenToWorld(dVector (x, y, 0.0f, 0.0f)));
dVector p1 (camera->ScreenToWorld(dVector (x, y, 1.0f, 0.0f)));
//p0 = dVector (-11.531384, 6.897866, -2.453451, 1.0f);
//p1 = dVector (1720.189697, -1245.047241, 58.625248, 1.0f);
// do the convex cast here
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = p0;
dFloat param = 1.2f;
NewtonCollision* const shape = m_stupidLevel->GetCurrentShape();
//int count = NewtonWorldConvexCast (world, &matrix[0][0], &p1[0], shape, ConvexCastCallBack::Filter, &filter, ConvexCastCallBack::Prefilter, &filter.m_contacts[0], 4, 0);
NewtonWorldConvexCast (world, &matrix[0][0], &p1[0], shape, ¶m, NULL, Prefilter, NULL, 0, 0);
//dTrace(("%f, %f, %f\n", p0[0], p0[1], p0[2]));
//dTrace(("%f, %f, %f\n", p1[0], p1[1], p1[2]));
if (param < 1.0f) {
matrix.m_posit += (p1 - matrix.m_posit).Scale (param);
m_stupidLevel->SetCastEntityMatrix (scene, matrix);
}
m_stupidLevel->SetCastingLine (p0, p1);
}
}
