static bool SaveBIN(const char* filename, const IndexedSurface& surface)
{
const udword NbVerts = surface.GetNbVerts();
const udword NbFaces = surface.GetNbFaces();
const Point* Verts = surface.GetVerts();
const IndexedTriangle* F = surface.GetFaces();
CustomArray CA;
CA.Store(udword(1)); // # meshes
CA.Store(udword(1)); // Collidable
CA.Store(udword(1)); // Renderable
CA.Store(NbVerts);
CA.Store(NbFaces);
for(udword i=0;i<NbVerts;i++)
{
CA.Store(Verts[i].x);
CA.Store(Verts[i].y);
CA.Store(Verts[i].z);
}
for(udword i=0;i<NbFaces;i++)
{
CA.Store(F[i].mRef[0]);
CA.Store(F[i].mRef[1]);
CA.Store(F[i].mRef[2]);
}
CA.ExportToDisk(filename);
return true;
}
void CameraManager::GenerateRays(PintRaycastData* rays, udword nb_rays, float max_dist)
{
GLint viewPort[4];
GLdouble modelMatrix[16];
GLdouble projMatrix[16];
glGetIntegerv(GL_VIEWPORT, viewPort);
glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
const float fScreenWidth = float(gScreenWidth)/float(nb_rays);
const float fScreenHeight = float(gScreenHeight)/float(nb_rays);
const Point Origin = GetCameraPos();
udword Offset=0;
for(udword j=0;j<nb_rays;j++)
{
const udword yi = udword(fScreenHeight*float(j));
for(udword i=0;i<nb_rays;i++)
{
const udword xi = udword(fScreenWidth*float(i));
rays[Offset].mOrigin = Origin;
rays[Offset].mDir = ComputeWorldRay(viewPort, modelMatrix, projMatrix, xi, yi);
rays[Offset].mMaxDist = max_dist;
Offset++;
}
}
}
static void CreateBitmapWindow(Container& owner, TitleBitmapWindow*& bitmap, /*IceGroupBox*& group,*/ TitleWindow* parent, sdword x, sdword y, udword width, udword height, const char* label)
{
const udword OffsetY = 4; // ### not sure why this is needed
// Create bitmap window
WindowDesc WD;
WD.mParent = parent;
WD.mX = x + GROUP_BOX_BORDER_SIZE;
WD.mY = y + GROUP_BOX_BORDER_SIZE + OffsetY;
WD.mWidth = width;
WD.mHeight = height;
WD.mLabel = "BitmapWindow";
WD.mType = WINDOW_POPUP;
WD.mStyle = WSTYLE_NORMAL;
// ### the better style works but not all pixels get displayed
// WD.mStyle = WSTYLE_CLIENT_EDGES|WSTYLE_STATIC_EDGES;
bitmap = ICE_NEW(TitleBitmapWindow)(WD);
bitmap->SetVisible(true);
bitmap->mMainW = parent;
owner.Add(udword(bitmap));
/* if(0)
{
GroupBoxDesc GBD;
GBD.mParent = parent;
GBD.mX = x;
GBD.mY = y;
GBD.mWidth = width + GROUP_BOX_BORDER_SIZE*2;
GBD.mHeight = height + GROUP_BOX_BORDER_SIZE*2 + OffsetY;
GBD.mLabel = label;
group = ICE_NEW(IceGroupBox)(GBD);
owner.Add(udword(group));
}
else*/
{
EditBoxDesc EBD;
EBD.mParent = parent;
EBD.mX = x;
EBD.mY = y;
EBD.mWidth = width + GROUP_BOX_BORDER_SIZE*2;
EBD.mHeight = height + GROUP_BOX_BORDER_SIZE*2 + OffsetY;
EBD.mLabel = label;
EBD.mFilter = EDITBOX_TEXT;
EBD.mType = EDITBOX_READ_ONLY;
IceEditBox* EB = ICE_NEW(IceEditBox)(EBD);
EB->SetVisible(true);
owner.Add(udword(EB));
}
}
TitleWindow* CreateTitleWindow(Container& owner, IceWidget* parent, sdword x, sdword y, sdword width, sdword height)
{
// Texture size
const udword TextureWidth = TITLE_WIDTH;
const udword TextureHeight = TITLE_HEIGHT;
// Create main window
TitleWindow* TTWindow = null;
if(1)
{
WindowDesc WD;
WD.mParent = parent;
WD.mX = x;
WD.mY = y;
WD.mWidth = width;
WD.mHeight = height;
WD.mLabel = "Raytracing window";
WD.mType = WINDOW_NORMAL;
// WD.mType = WINDOW_POPUP;
// WD.mStyle = WSTYLE_CLIENT_EDGES;
WD.mStyle = WSTYLE_NORMAL;
TTWindow = ICE_NEW(TitleWindow)(WD);
TTWindow->SetVisible(true);
owner.Add(udword(TTWindow));
}
CreateBitmapWindow(owner, TTWindow->mRGBWindow, /*TTWindow->mRGBGroup,*/ TTWindow, BORDER_SIZE, BORDER_SIZE, TextureWidth, TextureHeight, "");
return TTWindow;
}
static void gBullet_GetOptionsFromGUI()
{
if(gEditBox_SolverIter)
{
sdword tmp;
bool status = gEditBox_SolverIter->GetTextAsInt(tmp);
ASSERT(status);
ASSERT(tmp>=0);
gSolverIterationCount = udword(tmp);
}
if(gEditBox_LinearDamping)
{
float tmp;
bool status = gEditBox_LinearDamping->GetTextAsFloat(tmp);
ASSERT(status);
ASSERT(tmp>=0.0f);
gLinearDamping = tmp;
}
if(gEditBox_AngularDamping)
{
float tmp;
bool status = gEditBox_AngularDamping->GetTextAsFloat(tmp);
ASSERT(status);
ASSERT(tmp>=0.0f);
gAngularDamping = tmp;
}
if(gEditBox_Erp)
{
float tmp;
bool status = gEditBox_Erp->GetTextAsFloat(tmp);
ASSERT(status);
gErp = tmp;
}
if(gEditBox_Erp2)
{
float tmp;
bool status = gEditBox_Erp2->GetTextAsFloat(tmp);
ASSERT(status);
gErp2 = tmp;
}
if(gEditBox_CollisionMargin)
{
float tmp;
bool status = gEditBox_CollisionMargin->GetTextAsFloat(tmp);
ASSERT(status);
ASSERT(tmp>=0.0f);
gCollisionMargin = tmp;
}
}
void Common_GetFromEditBox(udword& value, const IceEditBox* edit_box)
{
if(edit_box)
{
sdword Value;
bool status = edit_box->GetTextAsInt(Value);
ASSERT(status);
ASSERT(Value>=0);
value = udword(Value);
}
}
static PintShapeRenderer* RegisterShapeRenderer(PintShapeRenderer* renderer)
{
ASSERT(renderer);
if(!gShapeRenderers)
gShapeRenderers = ICE_NEW(Container);
ASSERT(gShapeRenderers);
gShapeRenderers->Add(udword(renderer));
return renderer;
}
void* Havok::CreatePhantom(const AABB& box)
{
Point Min, Max;
box.GetMin(Min);
box.GetMax(Max);
hkAabb info;
info.m_min = ToHkVector4(Min);
info.m_max = ToHkVector4(Max);
hkpAabbPhantom* phantom = new hkpAabbPhantom(info);
mPhysicsWorld->lock();
mPhysicsWorld->addPhantom(phantom);
mPhysicsWorld->unlock();
mPhantoms.Add(udword(phantom));
return phantom;
}
void Havok::TestNewFeature()
{
const float Altitude = 100.0f;
const SwingingRopeVariant& variant = g_variants[2];
// const SwingingRopeVariant& variant = g_variants[7];
// const SwingingRopeVariant& variant = g_variants[1];
// const SwingingRopeVariant& variant = g_variants[3];
// Horizontal distance between the attachment points of the strings.
const hkReal offset = 50.0f;
//
// Create the world
//
{
/* hkpWorldCinfo info;
info.setBroadPhaseWorldSize( 100000.0f );
info.m_gravity.set(0.0f, 0.0f, -variant.m_gravity);
info.m_solverTau = variant.m_tau;
mPhysicsWorld = new hkpWorld( info );*/
mPhysicsWorld->lock();
// mPhysicsWorld->m_wantDeactivation = false;
}
const float Radius = 1.0f;
{
hkpRigidBodyCinfo info;
info.m_shape = new hkpSphereShape(Radius);
// info.m_shape = new hkpBoxShape( hkVector4(0.5, 0.5f, 0.5f), 0.01f );
// hkpInertiaTensorComputer::setShapeVolumeMassProperties(info.m_shape, 10.0f, info);
hkpInertiaTensorComputer::setShapeVolumeMassProperties(info.m_shape, 1.0f, info);
info.m_mass = 1.0f;
// info.m_linearVelocity(2) = -10.0f;
//
// Construct string of independent bilateral constraints
//
if(0)
{
hkpConstraintData* data;
{
hkpBallAndSocketConstraintData* bsData = new hkpBallAndSocketConstraintData();
// bsData->setInBodySpace(hkVector4::getZero(), hkVector4( -1.5f, 0.0f, -0.3f));
bsData->setInBodySpace(hkVector4::getZero(), hkVector4( -1.5f, -0.3f, 0.0f));
data = bsData;
}
hkpRigidBody* prevBody = HK_NULL;
for (int b = 0; b < variant.m_numBodies; b++)
{
info.m_position.set(1.5f * hkReal(b) - offset / 2.0f, Altitude + 0.3f * hkReal(b), 0.0f);
info.m_motionType = b ? hkpMotion::MOTION_DYNAMIC : hkpMotion::MOTION_FIXED;
hkpRigidBody* body = new hkpRigidBody(info);
mPhysicsWorld->addEntity(body);
// HK_SET_OBJECT_COLOR( hkUlong(body->getCollidable()), 0xffff0000 );
mRigidBodies.Add(udword(body));
if (prevBody)
{
// add constraint
hkpConstraintInstance* instance = new hkpConstraintInstance(prevBody, body, data);
mPhysicsWorld->addConstraint( instance );
instance->removeReference();
}
prevBody = body;
// we remove reference, but we know one is still kept by mPhysicsWorld
body->removeReference();
}
data->removeReference();
}
//
// Construct constraint chain
//
{
hkArray<hkpEntity*> entities;
for (int b = 0; b < variant.m_numBodies; b++)
{
// info.m_position.set(1.5f * hkReal(b) + offset / 2.0f, Altitude + 0.3f * hkReal(b), 2.0f);
info.m_position.set(float(b)*(Radius+0.5f)*2.0f, 0.0f, 0.0f);
info.m_motionType = b ? hkpMotion::MOTION_DYNAMIC : hkpMotion::MOTION_FIXED;
hkpRigidBody* body = new hkpRigidBody(info);
mPhysicsWorld->addEntity(body);
// HK_SET_OBJECT_COLOR( hkUlong(body->getCollidable()), 0xff00ff00 );
mRigidBodies.Add(udword(body));
entities.pushBack(body);
// we know, a reference is kept by the world
body->removeReference();
}
{
hkpConstraintChainInstance* chainInstance = HK_NULL;
if (variant.m_type == BALL_AND_SOCKET)
{
hkpBallSocketChainData* chainData = new hkpBallSocketChainData();
chainInstance = new hkpConstraintChainInstance( chainData );
chainInstance->addEntity( entities[0] );
for (int e = 1; e < entities.getSize(); e++)
{
// chainData->addConstraintInfoInBodySpace( hkVector4::getZero(), hkVector4( -1.5f, 0.0f, -0.3f) );
// chainData->addConstraintInfoInBodySpace( hkVector4::getZero(), hkVector4( -1.5f, -0.3f, 0.0f) );
chainData->addConstraintInfoInBodySpace( hkVector4( Radius+0.5f, 0.0f, 0.0f), hkVector4( -Radius-0.5f, 0.0f, 0.0f) );
chainInstance->addEntity( entities[e] );
}
chainData->m_tau = variant.m_tau;
chainData->removeReference();
}
else if(variant.m_type == STIFF_SPRING)
{
hkpStiffSpringChainData* chainData = new hkpStiffSpringChainData();
chainInstance = new hkpConstraintChainInstance( chainData );
chainInstance->addEntity( entities[0] );
for (int e = 1; e < entities.getSize(); e++)
{
// chainData->addConstraintInfoInBodySpace( hkVector4::getZero(), hkVector4( -1.0f, 0.0f, -0.2f), 0.55f );
chainData->addConstraintInfoInBodySpace( hkVector4::getZero(), hkVector4( -1.0f, -0.2f, 0.0f), 0.55f );
chainInstance->addEntity( entities[e] );
}
chainData->m_tau = variant.m_tau;
chainData->removeReference();
}
mPhysicsWorld->addConstraint( chainInstance );
chainInstance->removeReference();
}
}
info.m_shape->removeReference();
}
mPhysicsWorld->unlock();
}
sdword Common_CreateDebugVizUI( IceWidget* parent, sdword x, sdword y, CBCallback check_box_callback, udword id, udword nb_params,
const bool* debug_viz_params, const char** debug_viz_names, IceCheckBox** check_boxes, Container* gui)
{
ASSERT(gui);
ASSERT(check_boxes);
ASSERT(debug_viz_names);
ASSERT(debug_viz_params);
const sdword YStepCB = 16;
const sdword YSaved = y;
CheckBoxDesc CBD;
CBD.mParent = parent;
CBD.mX = x+10;
CBD.mWidth = 170;
CBD.mHeight = 20;
CBD.mCallback = check_box_callback;
for(udword i=0;i<nb_params;i++)
{
CBD.mID = id++;
CBD.mY = y+20;
CBD.mLabel = debug_viz_names[i];
CBD.mChecked = debug_viz_params[i];
check_boxes[i] = ICE_NEW(IceCheckBox)(CBD);
gui->Add(udword(check_boxes[i]));
check_boxes[i]->SetVisible(true);
if(i==0)
check_boxes[i]->SetEnabled(true);
else
check_boxes[i]->SetEnabled(debug_viz_params[0]);
y += YStepCB;
}
if(0)
{
GroupBoxDesc GBD;
GBD.mParent = parent;
GBD.mX = x;
GBD.mY = YSaved;
GBD.mWidth = 200;
GBD.mHeight = nb_params*20;
GBD.mLabel = "Debug visualization";
IceGroupBox* GB = ICE_NEW(IceGroupBox)(GBD);
gui->Add(udword(GB));
GB->SetVisible(true);
}
else
{
EditBoxDesc EBD;
EBD.mParent = parent;
EBD.mX = x;
EBD.mY = YSaved;
EBD.mWidth = 200;
EBD.mHeight = 20*2 + nb_params*YStepCB;
EBD.mLabel = "======= Debug visualization ========";
// EBD.mLabel = ""
EBD.mFilter = EDITBOX_TEXT;
EBD.mType = EDITBOX_READ_ONLY;
IceEditBox* EB = ICE_NEW(IceEditBox)(EBD);
EB->SetVisible(true);
gui->Add(udword(EB));
/*
LabelDesc LD;
LD.mParent = EB;
// LD.mX = x+14;
LD.mX = 14;
// LD.mY = YSaved-5;
LD.mY = -5;
LD.mWidth = 95;
LD.mHeight = 14;
LD.mLabel = "Debug visualization";
IceLabel* Label = ICE_NEW(IceLabel)(LD);
Label->SetVisible(true);
gui->Add(udword(Label));*/
}
return y;
}
