bool Application::initGL(){
NVGcontext* context = NVG::instance()->context();
int res = nvgCreateFont(context, "sans", RESOURCE_PATH("Roboto-Regular.ttf").c_str());
if (res == -1) {
printf("Could not add font regular.\n");
return false;
}
res = nvgCreateFont(context, "sans-bold", RESOURCE_PATH("Roboto-Bold.ttf").c_str());
if (res == -1) {
printf("Could not add font bold.\n");
return false;
}
return true;
}
void DaemonManager::startSeafileDaemon()
{
const QString config_dir = seafApplet->configurator()->ccnetDir();
const QString seafile_dir = seafApplet->configurator()->seafileDir();
const QString worktree_dir = seafApplet->configurator()->worktreeDir();
seaf_daemon_ = new QProcess(this);
connect(seaf_daemon_, SIGNAL(started()), this, SLOT(onSeafDaemonStarted()));
connect(seaf_daemon_, SIGNAL(finished(int, QProcess::ExitStatus)),
this, SLOT(onSeafDaemonExited()));
QStringList args;
args << "-c" << config_dir << "-d" << seafile_dir << "-w" << worktree_dir;
seaf_daemon_->start(RESOURCE_PATH(kSeafileDaemonExecutable), args);
qDebug() << "starting seaf-daemon: " << args;
}
void DaemonManager::startCcnetDaemon()
{
sync_client_ = ccnet_client_new();
const QString config_dir = seafApplet->configurator()->ccnetDir();
const QByteArray path = config_dir.toUtf8();
if (ccnet_client_load_confdir(sync_client_, path.data()) < 0) {
seafApplet->errorAndExit(tr("failed to load ccnet config dir %1").arg(config_dir));
}
ccnet_daemon_ = new QProcess(this);
connect(ccnet_daemon_, SIGNAL(started()), this, SLOT(onCcnetDaemonStarted()));
connect(ccnet_daemon_, SIGNAL(finished(int, QProcess::ExitStatus)),
this, SLOT(onCcnetDaemonExited()));
QStringList args;
args << "-c" << config_dir;
ccnet_daemon_->start(RESOURCE_PATH(kCcnetDaemonExecutable), args);
qDebug() << "starting ccnet: " << args;
}
void Core::Init()
{
Window::CreateInst();
printf("by Eddie (illogictree.com)\n");
Renderer::CreateInst();
TextureManager::CreateInst();
SoundMngr::CreateInst();
Input::CreateInst();
ImguiManager::CreateInst();
VirtualMachine::CreateInst();
IniReader reader( RESOURCE_PATH("common/ini/main.ini") );
m_fps = reader.GetInt( "Window", "FPS" );
m_showAnalyticsGui = reader.GetInt( "Window", "ShowAnalytics" ) == 1;
Timer initTimer;
printf("Initializing...\n");
BaseEntityGroup::Init();
printf("initialized in %f secs!\n", initTimer.GetTimeMs() );
InitGuiGraphs();
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: 52-GEL-duck\n");
printf ("Copyright 2003-2010\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Show GEL Skeleton\n");
printf ("[2] - Hide GEL Skeleton\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(0.0, 0.0, 0.0);
world->setBackgroundColor(1.0, 1.0, 1.0);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
// define a default position of the camera (described in spherical coordinates)
cameraAngleH = 0;
cameraAngleV = 45;
cameraDistance = 2.5;
updateCameraPosition();
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// enable higher rendering quality because we are displaying transparent objects
camera->enableMultipassTransparency(true);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 2.0, 0.5, 1.0)); // position the light source
light->setDir(cVector3d(-2.0, 0.5, 1.0)); // define the direction of the light beam
light->setDirectionalLight(false);
light->m_ambient.set(0.5, 0.5, 0.5);
light->m_diffuse.set(0.7, 0.7, 0.7);
light->m_specular.set(0.9, 0.9, 0.9);
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.4, 0.4);
// here we replace all black pixels (0,0,0) of the logo bitmap
// with transparent black pixels (0, 0, 0, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0, 0, 0), // original RGB color
cColorb(0, 0, 0, 0) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info;
if (hapticDevice)
{
hapticDevice->open();
info = hapticDevice->getSpecifications();
}
// desired workspace radius of the cursor
cursorWorkspaceRadius = 0.8;
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
workspaceScaleFactor = cursorWorkspaceRadius / info.m_workspaceRadius;
// define a scale factor between the force perceived at the cursor and the
// forces actually sent to the haptic device
deviceForceScale = 0.005 * (info.m_maxForceStiffness / workspaceScaleFactor);
// define a force scale factor for the current haptic device.
const double FORCE_REFERENCE = 10.0;
deviceForceScale = info.m_maxForce / FORCE_REFERENCE;
// create a large sphere that represents the haptic device
deviceRadius = 0.12;
device = new cShapeSphere(deviceRadius);
world->addChild(device);
device->m_material.m_ambient.set(0.4, 0.4, 0.4, 0.7);
device->m_material.m_diffuse.set(0.7, 0.7, 0.7, 0.7);
device->m_material.m_specular.set(1.0, 1.0, 1.0, 0.7);
device->m_material.setShininess(100);
stiffness = 40;
//-----------------------------------------------------------------------
// COMPOSE THE VIRTUAL SCENE
//-----------------------------------------------------------------------
// create a world which supports deformable object
defWorld = new cGELWorld();
world->addChild(defWorld);
world->setPos(-1.5, 0.0, -0.1);
world->rotate(cVector3d(0,1,0), cDegToRad(30));
//-----------------------------------------------------------------------
// COMPOSE THE WATER
//-----------------------------------------------------------------------
ground = new cGELMesh(world);
ground->m_useMassParticleModel = true;
defWorld->m_gelMeshes.push_back(ground);
cGELMassParticle::default_mass = 0.010;
cGELMassParticle::default_kDampingPos = 0.4;
cGELMassParticle::default_gravity.set(0,0,0);
int u,v;
int RESOLUTION = 15;
double SIZE = 3.5;
for (v=0; v<RESOLUTION; v++)
{
for (u=0; u<RESOLUTION; u++)
{
double px, py, tu, tv;
// compute the position of the vertex
px = SIZE / (double)RESOLUTION * (double)u - (SIZE/2.0);
py = SIZE / (double)RESOLUTION * (double)v - (SIZE/2.0);
// create new vertex
unsigned int index = ground->newVertex(px, py, level);
cVertex* vertex = ground->getVertex(index);
// compute texture coordinate
tu = (double)u / (double)RESOLUTION;
tv = (double)v / (double)RESOLUTION;
vertex->setTexCoord(tu, tv);
vertex->setColor(cColorf(1.0, 0.0, 0.1));
}
}
ground->buildVertices();
for (v=0; v<RESOLUTION; v++)
{
for (u=0; u<RESOLUTION; u++)
{
if ((u == 0) || (v == 0) || (u == (RESOLUTION-1)) || (v == (RESOLUTION-1)))
{
// create new vertex
unsigned int index = ((v + 0) * RESOLUTION) + (u + 0);
ground->m_gelVertices[index].m_massParticle->m_fixed = true;
}
}
}
cGELLinearSpring::default_kSpringElongation = 10.0; // [N/m]
// Create a triangle based map using the above pixels
for (v=0; v<(RESOLUTION-1); v++)
{
for (u=0; u<(RESOLUTION-1); u++)
{
// get the indexing numbers of the next four vertices
unsigned int index00 = ((v + 0) * RESOLUTION) + (u + 0);
unsigned int index01 = ((v + 0) * RESOLUTION) + (u + 1);
unsigned int index10 = ((v + 1) * RESOLUTION) + (u + 0);
unsigned int index11 = ((v + 1) * RESOLUTION) + (u + 1);
// create two new triangles
ground->newTriangle(index00, index01, index10);
ground->newTriangle(index10, index01, index11);
cGELMassParticle* m0 = ground->m_gelVertices[index00].m_massParticle;
cGELMassParticle* m1 = ground->m_gelVertices[index01].m_massParticle;
cGELMassParticle* m2 = ground->m_gelVertices[index10].m_massParticle;
cGELLinearSpring* spring0 = new cGELLinearSpring(m0, m1);
cGELLinearSpring* spring1 = new cGELLinearSpring(m0, m2);
ground->m_linearSprings.push_back(spring0);
ground->m_linearSprings.push_back(spring1);
}
}
double transparencyLevel = 0.7;
ground->setUseMaterial(true);
ground->m_material.m_ambient.set(0.6, 0.6, 0.6, transparencyLevel);
ground->m_material.m_diffuse.set(0.8, 0.8, 0.8, transparencyLevel);
ground->m_material.m_specular.set(0.9, 0.9, 0.9, transparencyLevel);
ground->setTransparencyLevel(transparencyLevel);
ground->setUseTransparency(true);
cTexture2D* textureGround = new cTexture2D();
ground->setTexture(textureGround);
ground->setUseTexture(true, true);
fileload = textureGround->loadFromFile(RESOURCE_PATH("resources/images/aqua.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = textureGround->loadFromFile("../../../bin/resources/images/aqua.bmp" );
#endif
if (!fileload)
{
printf("Error - 3D Texture failed to load correctly.\n");
close();
return (-1);
}
}
//-----------------------------------------------------------------------
// COMPOSE SOME REFLEXION
//-----------------------------------------------------------------------
cGenericObject* reflexion = new cGenericObject();
world->addChild(reflexion);
cMatrix3d rot;
rot.set(1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, -1.0);
reflexion->setRot(rot);
reflexion->addChild(defWorld);
reflexion->setPos(0.0, 0.0, 2.0 * level);
cGenericObject* reflexionTool = new cGenericObject();
reflexion->addChild(reflexionTool);
reflexionTool->addChild(device);
reflexionTool->setPos(0.0, 0.0, -0.5 * level);
// Play with thse numbers carefully!
defWorld->m_integrationTime = 0.001;
// create a deformable mesh
defObject = new cGELMesh(world);
defWorld->m_gelMeshes.push_front(defObject);
//-----------------------------------------------------------------------
// BUILD THE DUCK!
//-----------------------------------------------------------------------
if (USE_SKELETON_MODEL)
{
fileload = createSkeletonMesh(defObject, RESOURCE_PATH("resources/models/ducky/duck-200.off"), RESOURCE_PATH("resources/models/ducky/duck-full.obj"));
if (!fileload)
{
#if defined(_MSVC)
fileload = createSkeletonMesh(defObject, "../../../bin/resources/models/ducky/duck-200.off", "../../../bin/resources/models/ducky/duck-full.obj");
#endif
if (!fileload)
{
printf("Error - 3D Model failed to load correctly.\n");
close();
return (-1);
}
}
}
else
{
fileload = createTetGenMesh(defObject, RESOURCE_PATH("resources/models/ducky/duck-1200.off"), RESOURCE_PATH("resources/models/ducky/duck-green.obj"));
if (!fileload)
{
#if defined(_MSVC)
fileload = createTetGenMesh(defObject, "../../../bin/resources/models/ducky/duck-1200.off", "../../../bin/resources/models/ducky/duck-green.obj");
#endif
if (!fileload)
{
printf("Error - 3D Model failed to load correctly.\n");
close();
return (-1);
}
}
}
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutMouseFunc(mouseClick);
glutMotionFunc(mouseMove);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CS 268 - Sonny Chan & Francois Conti - March 2009");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAddMenuEntry("show skeleton", OPTION_SHOWSKELETON);
glutAddMenuEntry("hide skeleton", OPTION_HIDESKELETON);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI3D\n");
printf ("Demo: 10-oring\n");
printf ("Copyright 2003-2012\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Texture (ON/OFF)\n");
printf ("[2] - Wireframe (ON/OFF)\n");
printf ("[x] - Exit application\n");
printf ("\n\n>\r");
// parse first arg to try and locate resources
string resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// WORLD - CAMERA - LIGHTING
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
world->m_backgroundColor.setBlack();
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (3.0, 0.0, 0.0), // camera position (eye)
cVector3d (0.0, 0.0, 0.0), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the (up) vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// enable shadow casting
camera->setUseShadowCasting(true);
// create a light source
light = new cSpotLight(world);
// attach light to camera
camera->addChild(light);
// enable light source
light->setEnabled(true);
// position the light source
light->setLocalPos( 0.0, 0.5, 0.0);
// define the direction of the light beam
light->setDir(-3.0,-0.5, 0.0);
// enable this light source to generate shadows
light->setShadowMapEnabled(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info = hapticDevice->getSpecifications();
// create a 3D tool and add it to the world
tool = new cToolCursor(world);
world->addChild(tool);
// connect the haptic device to the tool
tool->setHapticDevice(hapticDevice);
// initialize tool by connecting to haptic device
tool->start();
// map the physical workspace of the haptic device to a larger virtual workspace.
tool->setWorkspaceRadius(1.0);
// define a radius for the tool
tool->setRadius(0.03);
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
double workspaceScaleFactor = tool->getWorkspaceScaleFactor();
// define a maximum stiffness that can be handled by the current
// haptic device. The value is scaled to take into account the
// workspace scale factor
double stiffnessMax = info.m_maxLinearStiffness / workspaceScaleFactor;
//-----------------------------------------------------------------------
// CREATING OBJECTS
//-----------------------------------------------------------------------
// create a torus object (o-ring)
object = new cShapeTorus(0.24, 0.50);
// add object to world
world->addChild(object);
// set the position of the object at the center of the world
object->setLocalPos(0.0, 0.0, 0.0);
// rotate object of 90 degrees around its y-axis so that it
// stands vertically
object->rotateAboutGlobalAxisDeg( cVector3d(0, 1, 0), 90);
// set the material stiffness to 100% of the maximum permitted stiffness
// of the haptic device
object->m_material->setStiffness(1.00 * stiffnessMax);
// set some environmental texture and material properties
object->m_texture = new cTexture2d();
// load texture file
bool fileload = object->m_texture->loadFromFile(RESOURCE_PATH("resources/images/spheremap-6.jpg"));
if (!fileload)
{
//fileload = object->m_texture->loadFromFile("../../../bin/resources/images/spheremap-6.jpg");
fileload = object->m_texture->loadFromFile("resources/images/spheremap-6.jpg");
}
if (!fileload)
{
printf("Error - Texture image failed to load correctly.\n");
close();
return (-1);
}
// setup texture and material properties
object->setUseTexture(true);
object->m_texture->setSphericalMappingEnabled(true);
object->m_material->m_ambient.set(0.9, 0.9, 0.9);
object->m_material->m_diffuse.set(0.9, 0.9, 0.9);
object->m_material->m_specular.set(1.0, 1.0, 1.0);
// create a haptic effect for this object so that the operator can
// feel its surface
cEffectSurface* newEffect = new cEffectSurface(object);
object->addEffect(newEffect);
//-----------------------------------------------------------------------
// WIDGETS
//-----------------------------------------------------------------------
// create a font
cFont *font = NEW_CFONTCALIBRI20();
// create a label to display the haptic rate of the simulation
labelHapticRate = new cLabel(font);
camera->m_frontLayer->addChild(labelHapticRate);
level = new cLevel();
camera->m_frontLayer->addChild(level);
level->setLocalPos(100,100,0);
level->setRange(0.0, 25.0);
dial = new cDial();
camera->m_frontLayer->addChild(dial);
dial->setSingleIncrementDisplay(false);
dial->setLocalPos(600,100,0);
dial->setRange(0.0, 5.0);
dial->setSize(60);
dial->setValue0(0.0);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// simulation in now running!
simulationRunning = true;
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
if (USE_STEREO_DISPLAY)
{
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | GLUT_STEREO);
camera->setUseStereo(true);
}
else
{
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
camera->setUseStereo(false);
}
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->start(updateHaptics, CTHREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutTimerFunc(30, graphicsTimer, 0);
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI3D\n");
printf ("Demo: 22-chrome\n");
printf ("Copyright 2003-2012\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Texture ON\n");
printf ("[2] - Texture OFF\n");
printf ("[3] - Wireframe ON\n");
printf ("[4] - Wireframe OFF\n");
printf ("[5] - Normals ON\n");
printf ("[6] - Normals OFF\n");
printf ("[x] - Exit application\n");
printf ("\n\n>\r");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// WORLD - CAMERA - LIGHTING
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
world->m_backgroundColor.setBlack();
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (3.0, 0.0, 0.6), // camera position (eye)
cVector3d (0.0, 0.0, 0.0), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the (up) vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// Enable shadow casting
camera->setUseShadowCasting(true);
// create a light source
light = new cSpotLight(world);
// attach light to camera
camera->addChild(light);
// enable light source
light->setEnabled(true);
// position the light source
light->setLocalPos( 0.0, 0.5, 0.0);
// define the direction of the light beam
light->setDir(-3.0,-0.5, 0.0);
// enable this light source to generate shadows
light->setShadowMapEnabled(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info = hapticDevice->getSpecifications();
// if the haptic devices carries a gripper, enable it to behave like a user switch
hapticDevice->setEnableGripperUserSwitch(true);
// create a 3D tool and add it to the world
tool = new cToolCursor(world);
world->addChild(tool);
// connect the haptic device to the tool
tool->setHapticDevice(hapticDevice);
// initialize tool by connecting to haptic device
tool->start();
// map the physical workspace of the haptic device to a larger virtual workspace.
tool->setWorkspaceRadius(1.0);
// define the radius of the tool (sphere)
double toolRadius = 0.04;
// define a radius for the tool
tool->setRadius(toolRadius);
// hide the device sphere. only show proxy.
tool->setShowContactPoints(true, false);
// enable if objects in the scene are going to rotate of translate
// or possibly collide against the tool. If the environment
// is entirely static, you can set this parameter to "false"
tool->enableDynamicObjects(true);
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
double workspaceScaleFactor = tool->getWorkspaceScaleFactor();
// define a maximum stiffness that can be handled by the current
// haptic device. The value is scaled to take into account the
// workspace scale factor
double stiffnessMax = info.m_maxLinearStiffness / workspaceScaleFactor;
//-----------------------------------------------------------------------
// CREATING OBJECT
//-----------------------------------------------------------------------
// create a virtual mesh
object = new cMultiMesh();
// add object to world
world->addChild(object);
// set the position of the object at the center of the world
object->setLocalPos(0.0, 0.0, 0.0);
// rotate the object 90 degrees
object->rotateAboutGlobalAxisDeg(cVector3d(0,0,1), 90);
// load an object file
bool fileload;
fileload = object->loadFromFile(RESOURCE_PATH("resources/models/face/face.obj"));
if (!fileload)
{
#if defined(_MSVC)
fileload = object->loadFromFile("../../../bin/resources/models/face/face.obj");
#endif
}
if (!fileload)
{
printf("Error - 3D Model failed to load correctly.\n");
close();
return (-1);
}
// compute a boundary box
object->computeBoundaryBox(true);
// get dimensions of object
double size = cSub(object->getBoundaryMax(), object->getBoundaryMin()).length();
// resize object to screen
if (size > 0)
{
object->scale( 2.0 * tool->getWorkspaceRadius() / size);
}
// compute collision detection algorithm
object->createAABBCollisionDetector(toolRadius);
cMaterial mat;
mat.setRenderTriangles(true, true);
object->setMaterial(mat);
// define some environmental texture mapping
cTexture2d* texture = new cTexture2d();
// load texture file
fileload = texture->loadFromFile(RESOURCE_PATH("resources/images/chrome.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = texture->loadFromFile("../../../bin/resources/images/chrome.bmp");
#endif
}
if (!fileload)
{
printf("Error - Texture image failed to load correctly.\n");
close();
return (-1);
}
// enable spherical mapping
texture->setSphericalMappingEnabled(true);
// assign texture to object
object->setTexture(texture, true);
// enable texture mapping
object->setUseTexture(true, true);
// disable culling
object->setUseCulling(false, true);
// define a default stiffness for the object
object->setStiffness(stiffnessMax, true);
// define some haptic friction properties
object->setFriction(0.1, 0.2, true);
//-----------------------------------------------------------------------
// WIDGETS
//-----------------------------------------------------------------------
// create a font
cFont *font = NEW_CFONTCALIBRI20();
// create a label to display the haptic rate of the simulation
labelHapticRate = new cLabel(font);
labelHapticRate->m_fontColor.setWhite();
camera->m_frontLayer->addChild(labelHapticRate);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// simulation in now running!
simulationRunning = true;
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowW = 0.7 * screenH;
int windowH = 0.7 * screenH;
int windowPosX = (screenW - windowH) / 2;
int windowPosY = (screenH - windowW) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(windowW, windowH);
if (USE_STEREO_DISPLAY)
{
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | GLUT_STEREO);
camera->setUseStereo(true);
}
else
{
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
camera->setUseStereo(false);
}
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->start(updateHaptics, CTHREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutTimerFunc(30, graphicsTimer, 0);
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: 23-tooth\n");
printf ("Copyright 2003-2010\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Instructions:\n\n");
printf ("- Use haptic device and user switch to rotate \n");
printf (" rotate and translate tooth. \n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Wireframe (ON/OFF)\n");
printf ("[2] - Normals (ON/OFF)\n");
printf ("[+] - Increase Opacity\n");
printf ("[-] - Reduce Opacity\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
sp = new Serial("COM6");
if (sp->IsConnected())
printf("We're connected");
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(0.0, 0.0, 0.0);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (3.0, 0.0, 0.3), // camera position (eye)
cVector3d (0.0, 0.0, 0.0), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the "up" vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// enable high quality rendering when tooth becomes transparent
camera->enableMultipassTransparency(true);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 2.0, 0.5, 1.0)); // position the light source
light->setDir(cVector3d(-2.0, 0.5, 1.0)); // define the direction of the light beam
light->m_ambient.set(0.6, 0.6, 0.6);
light->m_diffuse.set(0.8, 0.8, 0.8);
light->m_specular.set(0.8, 0.8, 0.8);
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.4, 0.4);
// here we replace all black pixels (0,0,0) of the logo bitmap
// with transparent black pixels (0, 0, 0, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0, 0, 0), // original RGB color
cColorb(0, 0, 0, 0) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
cGenericHapticDevice* hapticDevice;
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
if (hapticDevice)
{
info = hapticDevice->getSpecifications();
}
// create a 3D tool and add it to the world
tool = new cGeneric3dofPointer(world);
//-----------------Jake--------------//
index_finger = new cGeneric3dofPointer(world);
thumb = new cGeneric3dofPointer(world);
world->addChild(tool);
world->addChild(index_finger);
world->addChild(thumb);
// connect the haptic device to the tool
tool->setHapticDevice(hapticDevice);
// initialize tool by connecting to haptic device
tool->start();
// map the physical workspace of the haptic device to a larger virtual workspace.
tool->setWorkspaceRadius(1.0);
index_finger->setWorkspaceRadius(1.0);
thumb->setWorkspaceRadius(1.0);
// define a radius for the tool (graphical display)
tool->setRadius(0.01);
index_finger->setRadius(0.01);
thumb->setRadius(0.01);
// hide the device sphere. only show proxy.
tool->m_deviceSphere->setShowEnabled(false);
index_finger->setShowEnabled(false);
thumb->setShowEnabled(false);
// set the physical radius of the proxy to be equal to the radius
// of the tip of the mesh drill (see drill in the virtual scene section)
proxyRadius = 0.03;
tool->m_proxyPointForceModel->setProxyRadius(proxyRadius);
index_finger->m_proxyPointForceModel->setProxyRadius(proxyRadius);
thumb->m_proxyPointForceModel->setProxyRadius(proxyRadius);
// informe the finger-proxy force renderer to only check one side of triangles
tool->m_proxyPointForceModel->m_collisionSettings.m_checkBothSidesOfTriangles = false;
index_finger->m_proxyPointForceModel->m_collisionSettings.m_checkBothSidesOfTriangles = false;
thumb->m_proxyPointForceModel->m_collisionSettings.m_checkBothSidesOfTriangles = false;
// the environmeny is static, you can set this parameter to "false"
tool->m_proxyPointForceModel->m_useDynamicProxy = false;
index_finger->m_proxyPointForceModel->m_useDynamicProxy = false;
thumb->m_proxyPointForceModel->m_useDynamicProxy = false;
tool->m_proxyPointForceModel->m_useForceShading = true;
index_finger->m_proxyPointForceModel->m_useForceShading = true;
thumb->m_proxyPointForceModel->m_useForceShading = true;
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
double workspaceScaleFactor = tool->getWorkspaceScaleFactor();
// define a maximum stiffness that can be handled by the current
// haptic device. The value is scaled to take into account the
// workspace scale factor
double stiffnessMax = info.m_maxForceStiffness / workspaceScaleFactor;
rootLabels = new cGenericObject();
camera->m_front_2Dscene.addChild(rootLabels);
// create a small label as title
cLabel* titleLabel = new cLabel();
rootLabels->addChild(titleLabel);
//-----Jake------//
// define its position, color and string message
titleLabel->setPos(300, 60, 0);
titleLabel->m_fontColor.set(1.0, 1.0, 1.0);
titleLabel->m_string = "Haptic Device Pos [mm]:";
string strID;
cStr(strID, 0);
string strDevice = "#" + strID + " - " +info.m_modelName;
cLabel* newLabel = new cLabel();
tool->m_proxyMesh->addChild(newLabel);
newLabel->m_string = strDevice;
newLabel->setPos(0.00, 0.05, 0.00);
newLabel->m_fontColor.set(1.0, 1.0, 1.0);
string strID1;
cStr(strID1, 1);
string strDevice1 = "#" + strID1 + " - index finger";
cLabel* newLabel1 = new cLabel();
index_finger->m_proxyMesh->addChild(newLabel1);
newLabel1->m_string = strDevice1;
newLabel1->setPos(0.00, 0.05, 0.00);
newLabel1->m_fontColor.set(1.0, 1.0, 1.0);
string strID2;
cStr(strID2, 2);
string strDevice2 = "#" + strID2 + " - thumb";
cLabel* newLabel2 = new cLabel();
thumb->m_proxyMesh->addChild(newLabel2);
newLabel2->m_string = strDevice2;
newLabel2->setPos(0.00, 0.05, 0.00);
newLabel2->m_fontColor.set(1.0, 1.0, 1.0);
// crate a small label to indicate the position of the device
cLabel* newPosLabel = new cLabel();
rootLabels->addChild(newPosLabel);
newPosLabel->setPos(300, 50, 0);
newPosLabel->m_fontColor.set(0.6, 0.6, 0.6);
labels[0] = newPosLabel;
cLabel* newPosLabel1 = new cLabel();
rootLabels->addChild(newPosLabel1);
newPosLabel1->setPos(300, 30, 0);
newPosLabel1->m_fontColor.set(0.6, 0.6, 0.6);
labels[1] = newPosLabel1;
cLabel* newPosLabel2 = new cLabel();
rootLabels->addChild(newPosLabel2);
newPosLabel2->setPos(300, 10, 0);
newPosLabel2->m_fontColor.set(0.6, 0.6, 0.6);
labels[2]= newPosLabel2;
//-----------------------------------------------------------------------
// COMPOSE THE VIRTUAL SCENE
//-----------------------------------------------------------------------
// create a virtual mesh
tooth = new cMesh(world);
// add object to world
world->addChild(tooth);
// set the position and orientation of the object at the center of the world
tooth->setPos(0.0, 0.0, 0.0);
tooth->rotate(cVector3d(0.0, 0.0, 1.0), cDegToRad(-10));
tooth->rotate(cVector3d(0.0, 1.0, 0.0), cDegToRad(10));
// load an object file
fileload = tooth->loadFromFile(RESOURCE_PATH("resources/models/tooth/tooth.3ds"));
if (!fileload)
{
#if defined(_MSVC)
fileload = tooth->loadFromFile("../../../bin/resources/models/tooth/tooth.3ds");
#endif
}
if (!fileload)
{
printf("Error - 3D Model failed to load correctly.\n");
close();
return (-1);
}
// make the outside of the tooth rendered in wireframe
((cMesh*)(tooth->getChild(1)))->setWireMode(true);
// make the outside of the tooth rendered in semi-transparent
((cMesh*)(tooth->getChild(1)))->setUseTransparency(false);
((cMesh*)(tooth->getChild(1)))->setTransparencyLevel(transparencyLevel);
// compute a boundary box
tooth->computeBoundaryBox(true);
// resize tooth to screen
tooth->scale(0.003);
// compute collision detection algorithm
tooth->createAABBCollisionDetector(1.01 * proxyRadius, true, false);
// define a default stiffness for the object x
tooth->setStiffness(0.8 * stiffnessMax, true);
// create a new mesh.
drill = new cMesh(world);
// load a drill like mesh and attach it to the tool
fileload = drill->loadFromFile(RESOURCE_PATH("resources/models/drill/drill.3ds"));
if (!fileload)
{
#if defined(_MSVC)
fileload = drill->loadFromFile("../../../bin/resources/models/drill/drill.3ds");
#endif
}
if (!fileload)
{
printf("Error - 3D Model failed to load correctly.\n");
close();
return (-1);
}
// resize tool mesh model
drill->scale(0.004);
// remove the collision detector. we do not want to compute any
// force feedback rendering on the object itself.
drill->deleteCollisionDetector(true);
// define a material property for the mesh
cMaterial mat;
mat.m_ambient.set(0.5, 0.5, 0.5);
mat.m_diffuse.set(0.8, 0.8, 0.8);
mat.m_specular.set(1.0, 1.0, 1.0);
drill->setMaterial(mat, true);
drill->computeAllNormals(true);
// attach drill to tool
tool->m_proxyMesh->addChild(drill);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI 3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: 25-cubic\n");
printf ("Copyright 2003-2009\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(1.0, 1.0, 1.0);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (3.0, 0.0, 0.0), // camera position (eye)
cVector3d (0.0, 0.0, 0.0), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the "up" vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 2.0, 0.5, 1.0)); // position the light source
light->setDir(cVector3d(-2.0, 0.5, 1.0)); // define the direction of the light beam
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d-w.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d-w.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.25, 0.25);
// here we replace all wite pixels (1,1,1) of the logo bitmap
// with transparent black pixels (1, 1, 1, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0xff, 0xff, 0xff), // original RGB color
cColorb(0xff, 0xff, 0xff, 0x00) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
cGenericHapticDevice* hapticDevice;
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info;
if (hapticDevice)
{
info = hapticDevice->getSpecifications();
}
// create a 3D tool and add it to the world
tool = new cGeneric3dofPointer(world);
world->addChild(tool);
// connect the haptic device to the tool
tool->setHapticDevice(hapticDevice);
// initialize tool by connecting to haptic device
tool->start();
// map the physical workspace of the haptic device to a larger virtual workspace.
tool->setWorkspaceRadius(1.0);
// define a radius for the tool (graphical display)
tool->setRadius(0.05);
// hide the device sphere. only show proxy.
tool->m_deviceSphere->setShowEnabled(false);
// set the physical readius of the proxy.
proxyRadius = 0.05;
tool->m_proxyPointForceModel->setProxyRadius(proxyRadius);
tool->m_proxyPointForceModel->m_collisionSettings.m_checkBothSidesOfTriangles = false;
// enable if objects in the scene are going to rotate of translate
// or possibly collide against the tool. If the environment
// is entirely static, you can set this parameter to "false"
tool->m_proxyPointForceModel->m_useDynamicProxy = true;
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
double workspaceScaleFactor = tool->getWorkspaceScaleFactor();
// define a maximum stiffness that can be handled by the current
// haptic device. The value is scaled to take into account the
// workspace scale factor
double stiffnessMax = info.m_maxForceStiffness / workspaceScaleFactor;
//-----------------------------------------------------------------------
// COMPOSE THE VIRTUAL SCENE
//-----------------------------------------------------------------------
// create a virtual mesh
object = new cMesh(world);
// add object to world
world->addChild(object);
// set the position of the object at the center of the world
object->setPos(0.0, 0.0, 0.0);
/////////////////////////////////////////////////////////////////////////
// create a cube
/////////////////////////////////////////////////////////////////////////
const double HALFSIZE = 0.08;
// face -x
vertices[0][0] = object->newVertex(-HALFSIZE, HALFSIZE, -HALFSIZE);
vertices[0][1] = object->newVertex(-HALFSIZE, -HALFSIZE, -HALFSIZE);
vertices[0][2] = object->newVertex(-HALFSIZE, -HALFSIZE, HALFSIZE);
vertices[0][3] = object->newVertex(-HALFSIZE, HALFSIZE, HALFSIZE);
// face +x
vertices[1][0] = object->newVertex( HALFSIZE, -HALFSIZE, -HALFSIZE);
vertices[1][1] = object->newVertex( HALFSIZE, HALFSIZE, -HALFSIZE);
vertices[1][2] = object->newVertex( HALFSIZE, HALFSIZE, HALFSIZE);
vertices[1][3] = object->newVertex( HALFSIZE, -HALFSIZE, HALFSIZE);
// face -y
vertices[2][0] = object->newVertex(-HALFSIZE, -HALFSIZE, -HALFSIZE);
vertices[2][1] = object->newVertex( HALFSIZE, -HALFSIZE, -HALFSIZE);
vertices[2][2] = object->newVertex( HALFSIZE, -HALFSIZE, HALFSIZE);
vertices[2][3] = object->newVertex(-HALFSIZE, -HALFSIZE, HALFSIZE);
// face +y
vertices[3][0] = object->newVertex( HALFSIZE, HALFSIZE, -HALFSIZE);
vertices[3][1] = object->newVertex(-HALFSIZE, HALFSIZE, -HALFSIZE);
vertices[3][2] = object->newVertex(-HALFSIZE, HALFSIZE, HALFSIZE);
vertices[3][3] = object->newVertex( HALFSIZE, HALFSIZE, HALFSIZE);
// face -z
vertices[4][0] = object->newVertex(-HALFSIZE, -HALFSIZE, -HALFSIZE);
vertices[4][1] = object->newVertex(-HALFSIZE, HALFSIZE, -HALFSIZE);
vertices[4][2] = object->newVertex( HALFSIZE, HALFSIZE, -HALFSIZE);
vertices[4][3] = object->newVertex( HALFSIZE, -HALFSIZE, -HALFSIZE);
// face +z
vertices[5][0] = object->newVertex( HALFSIZE, -HALFSIZE, HALFSIZE);
vertices[5][1] = object->newVertex( HALFSIZE, HALFSIZE, HALFSIZE);
vertices[5][2] = object->newVertex(-HALFSIZE, HALFSIZE, HALFSIZE);
vertices[5][3] = object->newVertex(-HALFSIZE, -HALFSIZE, HALFSIZE);
// create triangles
for (int i=0; i<6; i++)
{
object->newTriangle(vertices[i][0], vertices[i][1], vertices[i][2]);
object->newTriangle(vertices[i][0], vertices[i][2], vertices[i][3]);
}
// create a texture
texture = new cTexture2D();
object->setTexture(texture);
object->setUseTexture(true);
// set material properties to light gray
object->m_material.m_ambient.set(0.5f, 0.5f, 0.5f, 1.0f);
object->m_material.m_diffuse.set(0.7f, 0.7f, 0.7f, 1.0f);
object->m_material.m_specular.set(1.0f, 1.0f, 1.0f, 1.0f);
object->m_material.m_emission.set(0.0f, 0.0f, 0.0f, 1.0f);
// compute normals
object->computeAllNormals();
// display triangle normals
object->setShowNormals(true);
// set length and color of normals
object->setNormalsProperties(0.1, cColorf(1.0, 0.0, 0.0), true);
// compute a boundary box
object->computeBoundaryBox(true);
// get dimensions of object
double size = cSub(object->getBoundaryMax(), object->getBoundaryMin()).length();
// resize object to screen
object->scale( 2.0 * tool->getWorkspaceRadius() / size);
// compute collision detection algorithm
object->createAABBCollisionDetector(1.01 * proxyRadius, true, false);
// define a default stiffness for the object
object->setStiffness(stiffnessMax, true);
// define friction properties
object->setFriction(0.2, 0.5, true);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI 3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: 01-devices\n");
printf ("Copyright 2003-2010\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Render attraction force\n");
printf ("[2] - Render viscous environment\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(0.0, 0.0, 0.0);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (0.5, 0.0, 0.0), // camera position (eye)
cVector3d (0.0, 0.0, 0.0), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the "up" vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 2.0, 0.5, 1.0)); // position the light source
light->setDir(cVector3d(-2.0, 0.5, 1.0)); // define the direction of the light beam
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.4, 0.4);
// here we replace all black pixels (0,0,0) of the logo bitmap
// with transparent black pixels (0, 0, 0, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0, 0, 0), // original RGB color
cColorb(0, 0, 0, 0) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// read the number of haptic devices currently connected to the computer
numHapticDevices = handler->getNumDevices();
// limit the number of devices to MAX_DEVICES
numHapticDevices = cMin(numHapticDevices, MAX_DEVICES);
// create a node on which we will attach small labels that display the
// position of each haptic device
rootLabels = new cGenericObject();
camera->m_front_2Dscene.addChild(rootLabels);
// create a small label as title
cLabel* titleLabel = new cLabel();
rootLabels->addChild(titleLabel);
// define its position, color and string message
titleLabel->setPos(0, 30, 0);
titleLabel->m_fontColor.set(1.0, 1.0, 1.0);
titleLabel->m_string = "Haptic Device Pos [mm]:";
// for each available haptic device, create a 3D cursor
// and a small line to show velocity
int i = 0;
while (i < numHapticDevices)
{
// get a handle to the next haptic device
cGenericHapticDevice* newHapticDevice;
handler->getDevice(newHapticDevice, i);
// open connection to haptic device
newHapticDevice->open();
// initialize haptic device
newHapticDevice->initialize();
// store the handle in the haptic device table
hapticDevices[i] = newHapticDevice;
// retrieve information about the current haptic device
cHapticDeviceInfo info = newHapticDevice->getSpecifications();
// create a cursor by setting its radius
cShapeSphere* newCursor = new cShapeSphere(0.01);
// add cursor to the world
world->addChild(newCursor);
// add cursor to the cursor table
cursors[i] = newCursor;
// create a small line to illustrate velocity
cShapeLine* newLine = new cShapeLine(cVector3d(0,0,0), cVector3d(0,0,0));
velocityVectors[i] = newLine;
// add line to the world
world->addChild(newLine);
// create a string that concatenates the device number and model name.
string strID;
cStr(strID, i);
string strDevice = "#" + strID + " - " +info.m_modelName;
// attach a small label next to the cursor to indicate device information
cLabel* newLabel = new cLabel();
newCursor->addChild(newLabel);
newLabel->m_string = strDevice;
newLabel->setPos(0.00, 0.02, 0.00);
newLabel->m_fontColor.set(1.0, 1.0, 1.0);
// if the device provided orientation sensing (stylus), a reference
// frame is displayed
if (info.m_sensedRotation == true)
{
// display a reference frame
newCursor->setShowFrame(true);
// set the size of the reference frame
newCursor->setFrameSize(0.05, 0.05);
}
// crate a small label to indicate the position of the device
cLabel* newPosLabel = new cLabel();
rootLabels->addChild(newPosLabel);
newPosLabel->setPos(0, -20 * i, 0);
newPosLabel->m_fontColor.set(0.6, 0.6, 0.6);
labels[i] = newPosLabel;
// increment counter
i++;
}
// here we define the material properties of the cursor when the
// user button of the device end-effector is engaged (ON) or released (OFF)
// a light orange material color
matCursorButtonOFF.m_ambient.set(0.5, 0.2, 0.0);
matCursorButtonOFF.m_diffuse.set(1.0, 0.5, 0.0);
matCursorButtonOFF.m_specular.set(1.0, 1.0, 1.0);
// a blue material color
matCursorButtonON.m_ambient.set(0.1, 0.1, 0.4);
matCursorButtonON.m_diffuse.set(0.3, 0.3, 0.8);
matCursorButtonON.m_specular.set(1.0, 1.0, 1.0);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI 3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: 11-effects\n");
printf ("Copyright 2003-2009\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(0.0, 0.0, 0.0);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (3.0, 0.0, 0.0), // camera position (eye)
cVector3d (0.0, 0.0, 0.0), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the "up" vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// enable higher quality rendering for transparent objects
camera->enableMultipassTransparency(true);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 2.0, 0.5, 1.0)); // position the light source
light->setDir(cVector3d(-2.0, 0.5, 1.0)); // define the direction of the light beam
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.4, 0.4);
// here we replace all black pixels (0,0,0) of the logo bitmap
// with transparent black pixels (0, 0, 0, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0, 0, 0), // original RGB color
cColorb(0, 0, 0, 0) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
cGenericHapticDevice* hapticDevice;
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info;
if (hapticDevice)
{
info = hapticDevice->getSpecifications();
}
// create a 3D tool and add it to the world
tool = new cGeneric3dofPointer(world);
world->addChild(tool);
// connect the haptic device to the tool
tool->setHapticDevice(hapticDevice);
// initialize tool by connecting to haptic device
tool->start();
// map the physical workspace of the haptic device to a larger virtual workspace.
tool->setWorkspaceRadius(1.0);
// define a radius for the tool
tool->setRadius(0.03);
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
double workspaceScaleFactor = tool->getWorkspaceScaleFactor();
// define a maximum stiffness that can be handled by the current
// haptic device. The value is scaled to take into account the
// workspace scale factor
double stiffnessMax = info.m_maxForceStiffness / workspaceScaleFactor;
double forceMax = info.m_maxForce;
// define the maximum damping factor that can be handled by the
// current haptic device. The The value is scaled to take into account the
// workspace scale factor
double dampingMax = info.m_maxLinearDamping / workspaceScaleFactor;
//-----------------------------------------------------------------------
// COMPOSE THE VIRTUAL SCENE
//-----------------------------------------------------------------------
// temp variable
cGenericEffect* newEffect;
/////////////////////////////////////////////////////////////////////////
// OBJECT 0: "MAGNET"
/////////////////////////////////////////////////////////////////////////
// create a sphere and define its radius
object0 = new cShapeSphere(0.3);
// add object to world
world->addChild(object0);
// set the position of the object at the center of the world
object0->setPos(0.0, -0.5, 0.0);
// set graphic properties
object0->m_texture = new cTexture2D();
fileload = object0->m_texture->loadFromFile(RESOURCE_PATH("resources/images/chrome.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = object0->m_texture->loadFromFile("../../../bin/resources/images/chrome.bmp");
#endif
}
if (!fileload)
{
printf("Error - Texture image failed to load correctly.\n");
close();
return (-1);
}
object0->m_texture->setSphericalMappingEnabled(true);
object0->m_material.m_ambient.set(1.0, 1.0, 1.0);
object0->m_material.m_diffuse.set(1.0, 1.0, 1.0);
object0->m_material.m_specular.set(1.0, 1.0, 1.0);
object0->m_material.setShininess(100);
object0->setUseTexture(true);
// set haptic properties
object0->m_material.setStiffness(0.4 * stiffnessMax);
object0->m_material.setMagnetMaxForce(0.4 * forceMax);
object0->m_material.setMagnetMaxDistance(0.12);
object0->m_material.setViscosity(0.2 * dampingMax);
// create a haptic surface effect
newEffect = new cEffectSurface(object0);
object0->addEffect(newEffect);
// create a haptic magnetic effect
newEffect = new cEffectMagnet(object0);
object0->addEffect(newEffect);
/////////////////////////////////////////////////////////////////////////
// OBJECT 1: "FLUID"
////////////////////////////////////////////////////////////////////////
// create a sphere and define its radius
object1 = new cShapeSphere(0.3);
// add object to world
world->addChild(object1);
// set the position of the object at the center of the world
object1->setPos(0.0, 0.5, 0.0);
// set graphic properties
object1->m_texture = new cTexture2D();
fileload = object1->m_texture->loadFromFile(RESOURCE_PATH("resources/images/water.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = object1->m_texture->loadFromFile("../../../bin/resources/images/water.bmp");
#endif
}
if (!fileload)
{
printf("Error - Texture image failed to load correctly.\n");
close();
return (-1);
}
object1->m_material.m_ambient.set(0.1, 0.1, 0.6, 0.5);
object1->m_material.m_diffuse.set(0.3, 0.3, 0.9, 0.5);
object1->m_material.m_specular.set(1.0, 1.0, 1.0, 0.5);
object1->setTransparencyLevel(0.5);
object1->setUseTexture(true);
// set haptic properties
object1->m_material.setViscosity(dampingMax);
// create a haptic viscous effect
newEffect = new cEffectViscosity(object1);
object1->addEffect(newEffect);
/////////////////////////////////////////////////////////////////////////
// OBJECT 2: "STICK-SLIP"
/////////////////////////////////////////////////////////////////////////
// create a sphere and define its radius
object2 = new cShapeSphere(0.3);
// add object to world
world->addChild(object2);
// set the position of the object at the center of the world
object2->setPos(0.0, 0.0, 0.5);
// set graphic properties
object2->m_texture = new cTexture2D();
fileload = object2->m_texture->loadFromFile(RESOURCE_PATH("resources/images/stone.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = object2->m_texture->loadFromFile("../../../bin/resources/images/stone.bmp");
#endif
}
if (!fileload)
{
printf("Error - Texture image failed to load correctly.\n");
close();
return (-1);
}
object2->m_material.m_ambient.set(0.1, 0.1, 0.6, 0.5);
object2->m_material.m_diffuse.set(0.3, 0.3, 0.9, 0.5);
object2->m_material.m_specular.set(1.0, 1.0, 1.0, 0.5);
object2->setTransparencyLevel(0.5);
object2->setUseTexture(true);
// set haptic properties
object2->m_material.setStickSlipForceMax(0.5 * forceMax);
object2->m_material.setStickSlipStiffness(0.7 * stiffnessMax);
// create a haptic stick-slip effect
newEffect = new cEffectStickSlip(object2);
object2->addEffect(newEffect);
/////////////////////////////////////////////////////////////////////////
// OBJECT 3: "VIBRATIONS"
////////////////////////////////////////////////////////////////////////
// create a sphere and define its radius
object3 = new cShapeSphere(0.3);
// add object to world
world->addChild(object3);
// set the position of the object at the center of the world
object3->setPos(0.0, 0.0, -0.5);
// set graphic properties
object3->m_texture = new cTexture2D();
fileload = object3->m_texture->loadFromFile(RESOURCE_PATH("resources/images/plastic.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = object3->m_texture->loadFromFile("../../../bin/resources/images/plastic.bmp");
#endif
}
if (!fileload)
{
printf("Error - Texture image failed to load correctly.\n");
close();
return (-1);
}
object3->m_texture->setSphericalMappingEnabled(true);
object3->m_material.m_ambient.set(0.6, 0.1, 0.1, 0.5);
object3->m_material.m_diffuse.set(0.9, 0.3, 0.3, 0.5);
object3->m_material.m_specular.set(1.0, 1.0, 1.0, 0.5);
object3->setTransparencyLevel(0.8);
object3->setUseTexture(true);
// set haptic properties
object3->m_material.setVibrationFrequency(50);
object3->m_material.setVibrationAmplitude(0.1 * forceMax);
object3->m_material.setStiffness(0.1 * stiffnessMax);
// create a haptic viscous effect
newEffect = new cEffectVibration(object3);
object3->addEffect(newEffect);
newEffect = new cEffectSurface(object3);
object3->addEffect(newEffect);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI 3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: ODE mesh\n");
printf ("Copyright 2003-2009\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Instructions:\n\n");
printf ("- Use haptic device and user switch to manipulate gear parts \n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Enable gravity\n");
printf ("[2] - Disable gravity\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(0.0, 0.0, 0.0);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (1.2, 0.0, 0.8), // camera position (eye)
cVector3d (0.0, 0.0,-0.5), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the "up" vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 2.0, 0.5, 1.0)); // position the light source
light->setDir(cVector3d(-2.0, 0.5, 1.0)); // define the direction of the light beam
light->m_ambient.set(0.6, 0.6, 0.6);
light->m_diffuse.set(0.8, 0.8, 0.8);
light->m_specular.set(0.8, 0.8, 0.8);
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.25, 0.25);
// here we replace all black pixels (0,0,0) of the logo bitmap
// with transparent black pixels (0, 0, 0, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0, 0, 0), // original RGB color
cColorb(0, 0, 0, 0) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
cGenericHapticDevice* hapticDevice;
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info;
if (hapticDevice)
{
info = hapticDevice->getSpecifications();
}
// create a 3D tool and add it to the world
tool = new cGeneric3dofPointer(world);
world->addChild(tool);
// connect the haptic device to the tool
tool->setHapticDevice(hapticDevice);
// initialize tool by connecting to haptic device
tool->start();
// map the physical workspace of the haptic device to a larger virtual workspace.
tool->setWorkspaceRadius(1.4);
// define a radius for the tool (graphical display)
tool->setRadius(0.015);
// hide the device sphere. only show proxy.
tool->m_deviceSphere->setShowEnabled(false);
// set the physical readius of the proxy.
proxyRadius = 0.0;
tool->m_proxyPointForceModel->setProxyRadius(proxyRadius);
tool->m_proxyPointForceModel->m_collisionSettings.m_checkBothSidesOfTriangles = false;
// enable if objects in the scene are going to rotate of translate
// or possibly collide against the tool. If the environment
// is entirely static, you can set this parameter to "false"
tool->m_proxyPointForceModel->m_useDynamicProxy = true;
// ajust the color of the tool
tool->m_materialProxy = tool->m_materialProxyButtonPressed;
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
double workspaceScaleFactor = tool->getWorkspaceScaleFactor();
// define a maximum stiffness that can be handled by the current
// haptic device. The value is scaled to take into account the
// workspace scale factor
stiffnessMax = info.m_maxForceStiffness / workspaceScaleFactor;
// create a small white line that will be enabled every time the operator
// grasps an object. The line indicated the connection between the
// position of the tool and the grasp position on the object
graspLine = new cShapeLine(cVector3d(0,0,0), cVector3d(0,0,0));
world->addChild(graspLine);
graspLine->m_ColorPointA.set(1.0, 1.0, 1.0);
graspLine->m_ColorPointB.set(1.0, 1.0, 1.0);
graspLine->setShowEnabled(false);
//-----------------------------------------------------------------------
// COMPOSE THE VIRTUAL SCENE
//-----------------------------------------------------------------------
// create an ODE world to simulate dynamic bodies
ODEWorld = new cODEWorld(world);
// add ODE world as a node inside world
world->addChild(ODEWorld);
// set some gravity
ODEWorld->setGravity(cVector3d(0.0, 0.0, -0.5));
// create a new ODE object that is automatically added to the ODE world
ODEGear1 = new cODEGenericBody(ODEWorld);
ODEGear2 = new cODEGenericBody(ODEWorld);
ODEAxis1 = new cODEGenericBody(ODEWorld);
ODEAxis2 = new cODEGenericBody(ODEWorld);
// create a virtual mesh that will be used for the geometry
// representation of the dynamic body
cMesh* gear1 = new cMesh(world);
cMesh* gear2 = new cMesh(world);
cMesh* axis1 = new cMesh(world);
cMesh* axis2 = new cMesh(world);
// load object 1 - a gear
fileload = gear1->loadFromFile(RESOURCE_PATH("resources/models/gear/gear.3ds"));
if (!fileload)
{
#if defined(_MSVC)
fileload = gear1->loadFromFile("../../../bin/resources/models/gear/gear.3ds");
#endif
}
gear1->scale(0.0015);
gear1->createAABBCollisionDetector(proxyRadius, true, false);
// load object 2 - a gear
fileload = gear2->loadFromFile(RESOURCE_PATH("resources/models/gear/gear.3ds"));
if (!fileload)
{
#if defined(_MSVC)
fileload = gear2->loadFromFile("../../../bin/resources/models/gear/gear.3ds");
#endif
}
gear2->scale(0.0015);
gear2->createAABBCollisionDetector(proxyRadius, true, false);
// load static object 1 - a shaft
fileload = axis1->loadFromFile(RESOURCE_PATH("resources/models/gear/axis.3ds"));
if (!fileload)
{
#if defined(_MSVC)
fileload = axis1->loadFromFile("../../../bin/resources/models/gear/axis.3ds");
#endif
}
axis1->scale(0.0015);
axis1->createAABBCollisionDetector(proxyRadius, true, false);
// load static object 2 - a shaft
fileload = axis2->loadFromFile(RESOURCE_PATH("resources/models/gear/axis.3ds"));
if (!fileload)
{
#if defined(_MSVC)
fileload = axis2->loadFromFile("../../../bin/resources/models/gear/axis.3ds");
#endif
}
axis2->scale(0.0015);
axis2->createAABBCollisionDetector(proxyRadius, true, false);
// define some material properties for both types of objects
cMaterial mat0, mat1, mat2;
mat0.m_ambient.set(0.7, 0.1, 0.2);
mat0.m_diffuse.set(0.8, 0.15, 0.2);
mat0.m_specular.set(1.0, 0.2, 0.2);
mat0.setStiffness(0.5 * stiffnessMax);
mat0.setDynamicFriction(0.4);
mat0.setStaticFriction(0.9);
gear1->setMaterial(mat0, true);
gear2->setMaterial(mat0, true);
mat1.m_ambient.set(0.2, 0.2, 0.2);
mat1.m_diffuse.set(0.8, 0.8, 0.8);
mat1.m_specular.set(1.0, 1.0, 1.0);
mat1.setStiffness(0.5 * stiffnessMax);
mat1.setDynamicFriction(0.4);
mat1.setStaticFriction(0.9);
axis1->setMaterial(mat1, true);
axis2->setMaterial(mat1, true);
// define image models
ODEGear1->setImageModel(gear1);
ODEGear2->setImageModel(gear2);
ODEAxis1->setImageModel(axis1);
ODEAxis2->setImageModel(axis2);
// create a dynamic model of the ODE object. Here we decide to use a box just like
// the object mesh we just defined
ODEGear1->createDynamicMesh();
ODEGear2->createDynamicMesh();
ODEAxis1->createDynamicCapsule(0.050, 0.47, true); // true = make object static
ODEAxis2->createDynamicCapsule(0.050, 0.47, true); // true = make object static
// define some mass properties for each gear
ODEGear1->setMass(0.6);
ODEGear2->setMass(0.6);
// define temp variables
cVector3d pos;
cMatrix3d rot;
// default distance between both gears when demo starts
double DISTANCE = 0.260;
// position and oriente gear 1
pos = cVector3d(0.0,-DISTANCE, -0.5);
rot.identity();
rot.rotate(cVector3d(1,0,0), cDegToRad(90));
ODEGear1->setPosition(pos);
ODEGear1->setRotation(rot);
// position and oriente gear 1
pos = cVector3d(0.0, DISTANCE, -0.5);
rot.rotate(cVector3d(0,0,1), cDegToRad(14));
ODEGear2->setPosition(pos);
ODEGear2->setRotation(rot);
// position shaft 1
pos = cVector3d(0.0,-DISTANCE, -0.7);
ODEAxis1->setPosition(pos);
// position shaft 2
pos = cVector3d(0.0, DISTANCE, -0.7);
ODEAxis2->setPosition(pos);
// we now create 6 static walls to bound the workspace of our simulation
ODEGPlane0 = new cODEGenericBody(ODEWorld);
ODEGPlane1 = new cODEGenericBody(ODEWorld);
ODEGPlane2 = new cODEGenericBody(ODEWorld);
ODEGPlane3 = new cODEGenericBody(ODEWorld);
ODEGPlane4 = new cODEGenericBody(ODEWorld);
ODEGPlane5 = new cODEGenericBody(ODEWorld);
double size = 1.0;
ODEGPlane0->createStaticPlane(cVector3d(0.0, 0.0, 2.0 *size), cVector3d(0.0, 0.0 ,-1.0));
ODEGPlane1->createStaticPlane(cVector3d(0.0, 0.0, -size), cVector3d(0.0, 0.0 , 1.0));
ODEGPlane2->createStaticPlane(cVector3d(0.0, size, 0.0), cVector3d(0.0,-1.0, 0.0));
ODEGPlane3->createStaticPlane(cVector3d(0.0, -size, 0.0), cVector3d(0.0, 1.0, 0.0));
ODEGPlane4->createStaticPlane(cVector3d( size, 0.0, 0.0), cVector3d(-1.0,0.0, 0.0));
ODEGPlane5->createStaticPlane(cVector3d(-0.8 * size, 0.0, 0.0), cVector3d( 1.0,0.0, 0.0));
//////////////////////////////////////////////////////////////////////////
// Create some reflexion
//////////////////////////////////////////////////////////////////////////
// we create an intermediate node to which we will attach
// a copy of the object located inside the world
cGenericObject* reflexion = new cGenericObject();
// set this object as a ghost node so that no haptic interactions or
// collision detecting take place within the child nodes added to the
// reflexion node.
reflexion->setAsGhost(true);
// add reflexion node to world
world->addChild(reflexion);
// turn off culling on each object (objects now get rendered on both sides)
gear1->setUseCulling(false, true);
gear2->setUseCulling(false, true);
axis1->setUseCulling(false, true);
axis2->setUseCulling(false, true);
// create a symmetry rotation matrix (z-plane)
cMatrix3d rotRefexion;
rotRefexion.set(1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, -1.0);
reflexion->setRot(rotRefexion);
reflexion->setPos(0.0, 0.0, -2.005);
// add objects to the world
reflexion->addChild(ODEWorld);
reflexion->addChild(tool);
//////////////////////////////////////////////////////////////////////////
// Create a Ground
//////////////////////////////////////////////////////////////////////////
// create mesh to model ground surface
cMesh* ground = new cMesh(world);
world->addChild(ground);
// create 4 vertices (one at each corner)
double groundSize = 2.0;
int vertices0 = ground->newVertex(-groundSize, -groundSize, 0.0);
int vertices1 = ground->newVertex( groundSize, -groundSize, 0.0);
int vertices2 = ground->newVertex( groundSize, groundSize, 0.0);
int vertices3 = ground->newVertex(-groundSize, groundSize, 0.0);
// compose surface with 2 triangles
ground->newTriangle(vertices0, vertices1, vertices2);
ground->newTriangle(vertices0, vertices2, vertices3);
// compute surface normals
ground->computeAllNormals();
// position ground at the right level
ground->setPos(0.0, 0.0, -1.0);
// define some material properties and apply to mesh
cMaterial matGround;
matGround.setStiffness(stiffnessMax);
matGround.setDynamicFriction(0.7);
matGround.setStaticFriction(1.0);
matGround.m_ambient.set(0.0, 0.0, 0.0);
matGround.m_diffuse.set(0.0, 0.0, 0.0);
matGround.m_specular.set(0.0, 0.0, 0.0);
ground->setMaterial(matGround);
// enable and set transparency level of ground
ground->setTransparencyLevel(0.75);
ground->setUseTransparency(true);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI 3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int loadHeightMap()
{
// create a texture file
cTexture2D* newTexture = new cTexture2D();
world->addTexture(newTexture);
// texture 2D
bool fileload = newTexture->loadFromFile(RESOURCE_PATH("resources/images/map.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = newTexture->loadFromFile("../../../bin/resources/images/map.bmp");
#endif
}
if (!fileload)
{
printf("Error - Texture image failed to load correctly.\n");
close();
return (-1);
}
// get the size of the texture image (U and V)
int texSizeU = newTexture->m_image.getWidth();
int texSizeV = newTexture->m_image.getHeight();
// check size of image
if ((texSizeU < 1) || (texSizeV < 1)) { return (false); }
// we look for the largest side
int largestSide;
if (texSizeU > texSizeV)
{
largestSide = texSizeU;
}
else
{
largestSide = texSizeV;
}
// The largest side of the map has a length of 1.0
// we now compute the respective size for 1 pixel of the image in world space.
double size = 1.0 / (double)largestSide;
// we will create an triangle based object. For centering puposes we
// compute an offset for axis X and Y corresponding to the half size
// of the image map.
double offsetU = 0.5 * (double)texSizeU * size;
double offsetV = 0.5 * (double)texSizeV * size;
// For each pixel of the image, create a vertex
int u,v;
for (v=0; v<texSizeV; v++)
{
for (u=0; u<texSizeU; u++)
{
double px, py, tu, tv;
// compute the height of the vertex
cColorb color = newTexture->m_image.getPixelColor(u,v);
double height = 0.1 * ((double)color.getR() + (double)color.getG() + (double)color.getB()) / (3.0 * 255.0);
// compute the position of the vertex
px = size * (double)u - offsetU;
py = size * (double)v - offsetV;
// create new vertex
unsigned int index = object->newVertex(px, py, height);
cVertex* vertex = object->getVertex(index);
// compute texture coordinate
tu = (double)u / texSizeU;
tv = (double)v / texSizeV;
vertex->setTexCoord(tu, tv);
}
}
// Create a triangle based map using the above pixels
for (v=0; v<(texSizeV-1); v++)
{
for (u=0; u<(texSizeU-1); u++)
{
// get the indexing numbers of the next four vertices
unsigned int index00 = ((v + 0) * texSizeU) + (u + 0);
unsigned int index01 = ((v + 0) * texSizeU) + (u + 1);
unsigned int index10 = ((v + 1) * texSizeU) + (u + 0);
unsigned int index11 = ((v + 1) * texSizeU) + (u + 1);
// create two new triangles
object->newTriangle(index00, index01, index10);
object->newTriangle(index10, index01, index11);
}
}
// apply texture to object
object->setTexture(newTexture);
object->setUseTexture(true);
// compute normals
object->computeAllNormals(true);
// compute size of object
object->computeBoundaryBox(true);
cVector3d min = object->getBoundaryMin();
cVector3d max = object->getBoundaryMax();
// This is the "size" of the object
cVector3d span = cSub(max, min);
size = cMax(span.x, cMax(span.y, span.z));
// We'll center all vertices, then multiply by this amount,
// to scale to the desired size.
double scaleFactor = MESH_SCALE_SIZE / size;
object->scale(scaleFactor);
// compute size of object again
object->computeBoundaryBox(true);
// Build a collision-detector for this object, so
// the proxy will work nicely when haptics are enabled.
object->createAABBCollisionDetector(1.01 * proxyRadius, true, false);
// set size of frame
object->setFrameSize(0.2, true);
// set size of normals
object->setNormalsProperties(0.01, cColorf(1.0, 0.0, 0.0, 1.0), true);
// render graphically both sides of triangles
object->setUseCulling(false);
// update global position
object->computeGlobalPositions();
// success
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: 20-map\n");
printf ("Copyright 2003-2010\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Instructions:\n\n");
printf ("- Use left mouse button to rotate camera view. \n");
printf ("- Use right mouse button to control camera zoom. \n");
printf ("- Use haptic device and user switch to rotate \n");
printf (" camera or deform terrain. \n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Texture (ON/OFF)\n");
printf ("[2] - Wireframe (ON/OFF)\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(0.1, 0.1, 0.1);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// define a default position of the camera (described in spherical coordinates)
cameraAngleH = 0;
cameraAngleV = 45;
cameraDistance = 1.8 * MESH_SCALE_SIZE;
updateCameraPosition();
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 0.0, 0.3, 0.3)); // position the light source
light->setDir(cVector3d(-1.0,-0.1, -0.1)); // define the direction of the light beam
light->m_ambient.set(0.5, 0.5, 0.5);
light->m_diffuse.set(0.8, 0.8, 0.8);
light->m_specular.set(1.0, 1.0, 1.0);
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.4, 0.4);
// here we replace all black pixels (0,0,0) of the logo bitmap
// with transparent black pixels (0, 0, 0, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0, 0, 0), // original RGB color
cColorb(0, 0, 0, 0) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
cGenericHapticDevice* hapticDevice;
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info;
if (hapticDevice)
{
info = hapticDevice->getSpecifications();
}
// create a 3D tool and add it to the world
tool = new cGeneric3dofPointer(world);
// attach tool to camera
camera->addChild(tool);
// position tool workspace in front of camera (x-axis of camera reference pointing towards the viewer)
tool->setPos(-cameraDistance, 0.0, 0.0);
// connect the haptic device to the tool
tool->setHapticDevice(hapticDevice);
// initialize tool by connecting to haptic device
tool->start();
// map the physical workspace of the haptic device to a larger virtual workspace.
tool->setWorkspaceRadius(1.0);
// define a radius for the tool (graphical display)
tool->setRadius(0.03);
// hide the device sphere. only show proxy.
tool->m_deviceSphere->setShowEnabled(false);
// set the physical readius of the proxy.
proxyRadius = 0.0;
tool->m_proxyPointForceModel->setProxyRadius(proxyRadius);
tool->m_proxyPointForceModel->m_collisionSettings.m_checkBothSidesOfTriangles = false;
//-----------------------------------------------------------------------
// COMPOSE THE VIRTUAL SCENE
//-----------------------------------------------------------------------
// create a new mesh to display a height map
object = new cMesh(world);
world->addChild(object);
// load default map
loadHeightMap();
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
double workspaceScaleFactor = tool->getWorkspaceScaleFactor();
// define a maximum stiffness that can be handled by the current
// haptic device. The value is scaled to take into account the
// workspace scale factor
double stiffnessMax = info.m_maxForceStiffness / workspaceScaleFactor;
object->setStiffness(0.5 * stiffnessMax, true);
// create a small vertical white magnetic line that will be activated when the
// user deforms the mesh.
magneticLine = new cShapeLine(cVector3d(0,0,0), cVector3d(0,0,0));
world->addChild(magneticLine);
magneticLine->m_ColorPointA.set(0.6, 0.6, 0.6);
magneticLine->m_ColorPointB.set(0.6, 0.6, 0.6);
magneticLine->setShowEnabled(false);
// set haptic properties
magneticLine->m_material.setStiffness(0.05 * stiffnessMax);
magneticLine->m_material.setMagnetMaxForce(0.2 * info.m_maxForce);
magneticLine->m_material.setMagnetMaxDistance(0.25);
magneticLine->m_material.setViscosity(0.05 * info.m_maxLinearDamping);
// create a haptic magnetic effect
cEffectMagnet* newEffect = new cEffectMagnet(magneticLine);
magneticLine->addEffect(newEffect);
// disable haptic feedback for now
magneticLine->setHapticEnabled(false);
// create two sphere that will be added at both ends of the line
sphereA = new cShapeSphere(0.02);
sphereB = new cShapeSphere(0.02);
world->addChild(sphereA);
world->addChild(sphereB);
sphereA->setShowEnabled(false);
sphereB->setShowEnabled(false);
// define some material properties for spheres
cMaterial matSphere;
matSphere.m_ambient.set(0.5, 0.2, 0.2);
matSphere.m_diffuse.set(0.8, 0.4, 0.4);
matSphere.m_specular.set(1.0, 1.0, 1.0);
sphereA->setMaterial(matSphere);
sphereB->setMaterial(matSphere);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutMouseFunc(mouseClick);
glutMotionFunc(mouseMove);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI 3D");
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: 50-GEL-membrane\n");
printf ("Copyright 2003-2009\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Show GEL Skeleton\n");
printf ("[2] - Hide GEL Skeleton\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(0.0, 0.0, 0.0);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (1.8, 0.0, 1.1), // camera position (eye)
cVector3d (0.0, 0.0, 0.0), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the "up" vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// enable higher rendering quality because we are displaying transparent objects
camera->enableMultipassTransparency(true);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 2.0, 0.5, 1.0)); // position the light source
light->setDir(cVector3d(-2.0, 0.5, 1.0)); // define the direction of the light beam
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.4, 0.4);
// here we replace all black pixels (0,0,0) of the logo bitmap
// with transparent black pixels (0, 0, 0, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0, 0, 0), // original RGB color
cColorb(0, 0, 0, 0) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info;
if (hapticDevice)
{
hapticDevice->open();
info = hapticDevice->getSpecifications();
}
// desired workspace radius of the cursor
cursorWorkspaceRadius = 0.5;
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
workspaceScaleFactor = cursorWorkspaceRadius / info.m_workspaceRadius;
// define a scale factor between the force perceived at the cursor and the
// forces actually sent to the haptic device
deviceForceScale = 0.1 * info.m_maxForce;
// create a large sphere that represents the haptic device
deviceRadius = 0.1;
device = new cShapeSphere(deviceRadius);
world->addChild(device);
device->m_material.m_ambient.set(0.4, 0.4, 0.4, 0.7);
device->m_material.m_diffuse.set(0.7, 0.7, 0.7, 0.7);
device->m_material.m_specular.set(1.0, 1.0, 1.0, 0.7);
device->m_material.setShininess(100);
stiffness = 40;
//-----------------------------------------------------------------------
// COMPOSE THE VIRTUAL SCENE
//-----------------------------------------------------------------------
// create a world which supports deformable object
defWorld = new cGELWorld();
world->addChild(defWorld);
world->setPos(-1.5, 0.0, -0.1);
world->rotate(cVector3d(0,1,0), cDegToRad(30));
// Play with thse numbers carefully!
cGELSkeletonNode::default_kDampingPos = 0.1;
cGELSkeletonNode::default_kDampingRot = 0.1;
defWorld->m_integrationTime = 0.001;
// create a deformable mesh
defObject = new cGELMesh(world);
defWorld->m_gelMeshes.push_front(defObject);
fileload = defObject->loadFromFile(RESOURCE_PATH("resources/models/box/box.3ds"));
if (!fileload)
{
#if defined(_MSVC)
fileload = defObject->loadFromFile("../../../bin/resources/models/box/box.3ds");
#endif
}
if (!fileload)
{
printf("Error - 3D Model failed to load correctly.\n");
close();
return (-1);
}
// set some material color on the object
cMaterial mat;
mat.m_ambient.set(0.2, 0.2, 0.2);
mat.m_diffuse.set(0.6, 0.6, 0.6);
mat.m_ambient.set(1.0, 1.0, 1.0);
mat.setShininess(100);
defObject->setMaterial(mat, true);
// let's create a some environment mapping
cTexture2D* texture = new cTexture2D();
fileload = texture->loadFromFile(RESOURCE_PATH("resources/images/shadow.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = texture->loadFromFile("../../../bin/resources/images/shadow.bmp");
#endif
}
if (!fileload)
{
printf("Error - Texture image failed to load correctly.\n");
close();
return (-1);
}
texture->setEnvironmentMode(GL_DECAL);
texture->setSphericalMappingEnabled(true);
defObject->setTexture(texture, true);
defObject->setTransparencyLevel(0.7, true);
defObject->setUseTexture(true, true);
// build dynamic vertices
defObject->buildVertices();
defObject->m_useSkeletonModel = true;
// setup default values for nodes
cGELSkeletonNode::default_radius = 0.05;
cGELSkeletonNode::default_kDampingPos = 0.4;
cGELSkeletonNode::default_kDampingRot = 0.1;
cGELSkeletonNode::default_mass = 0.01; // [kg]
cGELSkeletonNode::default_showFrame = true;
cGELSkeletonNode::default_color.set(1.0, 0.6, 0.6);
cGELSkeletonNode::default_useGravity = true;
cGELSkeletonNode::default_gravity.set(0.00, 0.00, -1.00);
radius = cGELSkeletonNode::default_radius;
// create an array of nodes
for (int y=0; y<10; y++)
{
for (int x=0; x<10; x++)
{
cGELSkeletonNode* newNode = new cGELSkeletonNode();
nodes[x][y] = newNode;
defObject->m_nodes.push_front(newNode);
newNode->m_pos.set( (-0.45 + 0.1*(double)x), (-0.43 + 0.1*(double)y), 0.0);
}
}
// fix 4 nodes 9corners)
nodes[0][0]->m_fixed = true;
nodes[0][9]->m_fixed = true;
nodes[9][0]->m_fixed = true;
nodes[9][9]->m_fixed = true;
// setup default values for links
cGELSkeletonLink::default_kSpringElongation = 100.0; // [N/m]
cGELSkeletonLink::default_kSpringFlexion = 0.5; // [Nm/RAD]
cGELSkeletonLink::default_kSpringTorsion = 0.1; // [Nm/RAD]
cGELSkeletonLink::default_color.set(0.2, 0.2, 1.0);
// create links between nodes
for (int y=0; y<9; y++)
{
for (int x=0; x<9; x++)
{
cGELSkeletonLink* newLinkX0 = new cGELSkeletonLink(nodes[x+0][y+0], nodes[x+1][y+0]);
cGELSkeletonLink* newLinkX1 = new cGELSkeletonLink(nodes[x+0][y+1], nodes[x+1][y+1]);
cGELSkeletonLink* newLinkY0 = new cGELSkeletonLink(nodes[x+0][y+0], nodes[x+0][y+1]);
cGELSkeletonLink* newLinkY1 = new cGELSkeletonLink(nodes[x+1][y+0], nodes[x+1][y+1]);
defObject->m_links.push_front(newLinkX0);
defObject->m_links.push_front(newLinkX1);
defObject->m_links.push_front(newLinkY0);
defObject->m_links.push_front(newLinkY1);
}
}
// connect skin (mesh) to skeleton (GEM)
defObject->connectVerticesToSkeleton(false);
// show/hide underlying dynamic skeleton model
defObject->m_showSkeletonModel = false;
// define the integration time constant of the dynamics model
defWorld->m_integrationTime = 0.005;
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI 3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAddMenuEntry("show skeleton", OPTION_SHOWSKELETON);
glutAddMenuEntry("hide skeleton", OPTION_HIDESKELETON);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
void VirtualMachine::RunMain()
{
IniReader ini(RESOURCE_PATH("common/ini/main.ini"));
int debugMode = 1;
int runGmLibs = 0;
#ifdef FNK_FINAL
debugMode = 0;
runGmLibs = 1;
#endif
int fps = ini.GetInt("Window", "FPS");
int gcWorkPerIncrement = ini.GetInt("VirtualMachine", "GC_WorkPerIncrement");
int gcDestructsPerIncrement = ini.GetInt("VirtualMachine", "GC_DestructPerIncrement");
int memUsageSoft = ini.GetInt("VirtualMachine", "MemUsageSoft");
int memUsageHard = ini.GetInt("VirtualMachine", "MemUsageHard");
m_vm->GetGC()->SetWorkPerIncrement(gcWorkPerIncrement);
m_vm->GetGC()->SetDestructPerIncrement(gcDestructsPerIncrement);
m_vm->SetDesiredByteMemoryUsageSoft(memUsageSoft);
m_vm->SetDesiredByteMemoryUsageHard(memUsageHard);
m_vm->SetDebugMode(debugMode == 1);
m_bUseGmByteCode = runGmLibs == 1;
m_dt = 1.0f/fps;
// print current setting
char buffer[128];
sprintf_s(buffer, "Running at %d hz, VM Debug Mode: %d, VM Run Byte-Code: %d", fps, debugMode, runGmLibs );
m_console.Log(buffer);
sprintf_s(buffer, "GC Works Per Increment: %d, GC Destructs Per Increment: %d", gcWorkPerIncrement, gcDestructsPerIncrement );
m_console.Log(buffer);
sprintf_s(buffer, "Mem Usage Soft: %d bytes, Mem Usage Hard: %d bytes", memUsageSoft, memUsageHard );
m_console.Log(buffer);
// attach debugger
if ( m_vm->GetDebugMode() ) m_debugger.Open(m_vm);
RegisterLibs(m_vm);
// set dt
m_vm->GetGlobals()->Set( m_vm, "g_dt", gmVariable(m_dt) );
m_vm->GetGlobals()->Set( m_vm, "g_rendering", gmVariable(0) );
m_vm->GetGlobals()->Set( m_vm, "g_resourcePathPrefix", gmVariable(m_vm->AllocStringObject(RESOURCE_PATH(""))) );
m_threadId = gmCompileStr(m_vm, kEntryFile);
printf("'%s' Main thread: %d\n", kEntryFile, m_threadId );
// get draw manager
gmVariable drawManagerKey = gmVariable(m_vm->AllocStringObject("g_drawManager"));
gmTableObject* drawManager = m_vm->GetGlobals()->Get(drawManagerKey).GetTableObjectSafe();
m_drawManager.Nullify();
if ( drawManager )
{
m_drawManager = gmVariable(gmVariable(drawManager));
// grab draw functions
gmVariable drawKey = gmVariable(m_vm->AllocStringObject("Draw"));
m_drawFunc = drawManager->Get(drawKey).GetFunctionObjectSafe();
gmVariable clearKey = gmVariable(m_vm->AllocStringObject("Clear"));
m_clearFunc = drawManager->Get(clearKey).GetFunctionObjectSafe();
}
}
namespace funk
{
const char * kEntryFile = RESOURCE_PATH("common/gm/Core.gm");
VirtualMachine::VirtualMachine()
{
m_vm = new gmMachine();
m_vm->SetAutoMemoryUsage(false);
m_dt = 0.0f;
m_updateMs = 0.0f;
m_bUseGmByteCode = false;
m_numThreads = 0;
m_threadId = 0;
InitGuiSettings();
InitGuiThreadAllocations();
}
VirtualMachine::~VirtualMachine()
{
m_console.Log("Destructing Virtual Machine");
if ( m_vm->GetDebugMode() ) m_debugger.Close();
delete m_vm;
m_console.Log("Virtual Machine destructed!");
}
void VirtualMachine::Update()
{
#ifndef FUNK_FINAL
if( Input::Get()->DidKeyJustGoDown("F5") ) ResetVM();
#endif
HandleErrors();
// run main game only if not debugging
if ( !(m_vm->GetDebugMode() && m_debugger.IsDebugging()) )
{
Timer gmTimer;
gmuint32 delta = (gmuint32)(m_dt*1000.0f);
m_numThreads = m_vm->Execute( delta );
m_updateMs = gmTimer.GetTimeMs();
}
// update debugger
if ( m_vm->GetDebugMode() )
{
m_debugger.Update();
}
}
void VirtualMachine::ResetVM()
{
m_console.ClearText();
m_console.Log("Restarting Virtual Machine..." );
if ( m_vm->GetDebugMode() ) m_debugger.Close();
ImguiManager::Get()->ClearAllWindows();
m_vm->ResetAndFreeMemory();
m_vm->Init();
if ( m_vm->GetDebugMode() ) m_debugger.Open(m_vm);
RunMain();
m_console.Log("Restarting Virtual Machine complete!");
}
void VirtualMachine::Render()
{
if ( !m_drawManager.IsNull() )
{
// draw only if not debugging
if ( !m_vm->GetDebugMode() || !m_debugger.IsDebugging() )
{
m_vm->GetGlobals()->Set( m_vm, "g_rendering", gmVariable(1) );
m_vm->ExecuteFunction(m_drawFunc, 0, true, &m_drawManager);
m_vm->GetGlobals()->Set( m_vm, "g_rendering", gmVariable(0) );
}
else
{
m_vm->ExecuteFunction(m_clearFunc, 0, true, &m_drawManager);
}
}
}
void VirtualMachine::RunMain()
{
IniReader ini(RESOURCE_PATH("common/ini/main.ini"));
int debugMode = 1;
int runGmLibs = 0;
#ifdef FNK_FINAL
debugMode = 0;
runGmLibs = 1;
#endif
int fps = ini.GetInt("Window", "FPS");
int gcWorkPerIncrement = ini.GetInt("VirtualMachine", "GC_WorkPerIncrement");
int gcDestructsPerIncrement = ini.GetInt("VirtualMachine", "GC_DestructPerIncrement");
int memUsageSoft = ini.GetInt("VirtualMachine", "MemUsageSoft");
int memUsageHard = ini.GetInt("VirtualMachine", "MemUsageHard");
m_vm->GetGC()->SetWorkPerIncrement(gcWorkPerIncrement);
m_vm->GetGC()->SetDestructPerIncrement(gcDestructsPerIncrement);
m_vm->SetDesiredByteMemoryUsageSoft(memUsageSoft);
m_vm->SetDesiredByteMemoryUsageHard(memUsageHard);
m_vm->SetDebugMode(debugMode == 1);
m_bUseGmByteCode = runGmLibs == 1;
m_dt = 1.0f/fps;
// print current setting
char buffer[128];
sprintf_s(buffer, "Running at %d hz, VM Debug Mode: %d, VM Run Byte-Code: %d", fps, debugMode, runGmLibs );
m_console.Log(buffer);
sprintf_s(buffer, "GC Works Per Increment: %d, GC Destructs Per Increment: %d", gcWorkPerIncrement, gcDestructsPerIncrement );
m_console.Log(buffer);
sprintf_s(buffer, "Mem Usage Soft: %d bytes, Mem Usage Hard: %d bytes", memUsageSoft, memUsageHard );
m_console.Log(buffer);
// attach debugger
if ( m_vm->GetDebugMode() ) m_debugger.Open(m_vm);
RegisterLibs(m_vm);
// set dt
m_vm->GetGlobals()->Set( m_vm, "g_dt", gmVariable(m_dt) );
m_vm->GetGlobals()->Set( m_vm, "g_rendering", gmVariable(0) );
m_vm->GetGlobals()->Set( m_vm, "g_resourcePathPrefix", gmVariable(m_vm->AllocStringObject(RESOURCE_PATH(""))) );
m_threadId = gmCompileStr(m_vm, kEntryFile);
printf("'%s' Main thread: %d\n", kEntryFile, m_threadId );
// get draw manager
gmVariable drawManagerKey = gmVariable(m_vm->AllocStringObject("g_drawManager"));
gmTableObject* drawManager = m_vm->GetGlobals()->Get(drawManagerKey).GetTableObjectSafe();
m_drawManager.Nullify();
if ( drawManager )
{
m_drawManager = gmVariable(gmVariable(drawManager));
// grab draw functions
gmVariable drawKey = gmVariable(m_vm->AllocStringObject("Draw"));
m_drawFunc = drawManager->Get(drawKey).GetFunctionObjectSafe();
gmVariable clearKey = gmVariable(m_vm->AllocStringObject("Clear"));
m_clearFunc = drawManager->Get(clearKey).GetFunctionObjectSafe();
}
}
void VirtualMachine::HandleErrors()
{
bool firstErr = true;
gmLog & compileLog = m_vm->GetLog();
const char *msg = compileLog.GetEntry(firstErr);
if ( msg )
{
const char * textHeader = "#############################\n[GameMonkey Run-time Error]:";
m_console.Log(textHeader);
}
while(msg)
{
m_console.Log(msg, false);
msg = compileLog.GetEntry(firstErr);
}
compileLog.Reset();
}
void VirtualMachine::GuiStats()
{
Imgui::Header("GameMonkey");
Imgui::FillBarFloat("Update", m_updateMs, 0.0f, 16.0 );
Imgui::FillBarInt("Mem Usage (Bytes)", m_vm->GetCurrentMemoryUsage(), 0, m_vm->GetDesiredByteMemoryUsageHard() );
Imgui::FillBarInt("Num Threads", m_numThreads, 0, 500 );
Imgui::CheckBox("Show Settings", m_showSettingsGui );
Imgui::CheckBox("Show Allocations", m_showThreadAllocationsGui );
}
void VirtualMachine::Gui()
{
if ( m_vm->GetDebugMode() ) m_debugger.Gui();
if ( m_showSettingsGui ) GuiSettings();
if ( m_showThreadAllocationsGui ) GuiThreadAllocations();
m_console.Gui();
}
void VirtualMachine::InitGuiSettings()
{
m_showSettingsGui = false;
const float minVal = 0.0f;
const float maxVal = 16.0f;
const int width = 200;
const int height = 100;
const int numVals = 128;
m_lineGraphUpdate = new LineGraph( minVal, maxVal, v2i(width, height), numVals );
m_lineGraphMemory = new LineGraph( minVal, maxVal, v2i(width, height), numVals );
}
void VirtualMachine::GuiSettings()
{
m_lineGraphUpdate->PushVal( m_updateMs );
m_lineGraphUpdate->SetMaxVal(m_dt*1000.0f);
m_lineGraphMemory->SetMaxVal( (float)m_vm->GetDesiredByteMemoryUsageHard() );
m_lineGraphMemory->PushVal( (float)m_vm->GetCurrentMemoryUsage() );
int workPerIncrement = m_vm->GetGC()->GetWorkPerIncrement();
int destructPerIncrement = m_vm->GetGC()->GetDestructPerIncrement();
int memUsageSoft = m_vm->GetDesiredByteMemoryUsageSoft();
int memUsageHard = m_vm->GetDesiredByteMemoryUsageHard();
const v2i pos = v2i(300, Window::Get()->Sizei().y - 20 );
Imgui::Begin("GameMonkey Settings", pos);
Imgui::Print("Update");
Imgui::LineGraph( m_lineGraphUpdate );
Imgui::Print("Memory");
Imgui::LineGraph( m_lineGraphMemory );
Imgui::FillBarInt("Mem Usage (Bytes)", m_vm->GetCurrentMemoryUsage(), 0, m_vm->GetDesiredByteMemoryUsageHard() );
Imgui::Header("Garbage Collector");
Imgui::SliderInt( "Work Per Increment", workPerIncrement, 1, 600 );
Imgui::SliderInt( "Destructs Per Increment", destructPerIncrement, 1, 600 );
Imgui::SliderInt( "Mem Usage Soft", memUsageSoft, 200000, memUsageHard );
Imgui::SliderInt( "Mem Usage Hard", memUsageHard, memUsageSoft+500, memUsageSoft+200000 );
Imgui::Separator();
Imgui::FillBarInt("GC Warnings", m_vm->GetStatsGCNumWarnings(), 0, 200 );
Imgui::FillBarInt("GC Full Collects", m_vm->GetStatsGCNumFullCollects(), 0, 200 );
Imgui::FillBarInt("GC Inc Collects", m_vm->GetStatsGCNumIncCollects(), 0, 200 );
Imgui::End();
m_vm->SetDesiredByteMemoryUsageSoft(memUsageSoft);
m_vm->SetDesiredByteMemoryUsageHard(memUsageHard);
m_vm->GetGC()->SetWorkPerIncrement(workPerIncrement);
m_vm->GetGC()->SetDestructPerIncrement(destructPerIncrement);
}
void VirtualMachine::InitGuiThreadAllocations()
{
m_showThreadAllocationsGui = false;
m_freezeThreadAllocationsGui = false;
}
void VirtualMachine::GuiThreadAllocations()
{
const v2i pos = v2i(300, Window::Get()->Sizei().y - 20 );
Imgui::Begin("Thread Allocations (Live)", pos);
m_freezeThreadAllocationsGui = Imgui::CheckBox("Freeze", m_freezeThreadAllocationsGui);
if (!m_freezeThreadAllocationsGui)
{
std::map<const gmFunctionObject*, ThreadAllocationItem>::iterator i = m_threadAllocationsHistory.begin();
while (i != m_threadAllocationsHistory.end())
{
i->second.eraseCountdown -= 1;
if (i->second.eraseCountdown <= 0)
{
i = m_threadAllocationsHistory.erase(i);
}
else
{
++i;
}
}
}
if (!m_freezeThreadAllocationsGui)
{
std::map<const gmFunctionObject*, int>::const_iterator a = m_vm->GetAllocCountIteratorBegin();
std::map<const gmFunctionObject*, int>::const_iterator b = m_vm->GetAllocCountIteratorEnd();
for (; a != b; ++a)
{
ThreadAllocationItem& item = m_threadAllocationsHistory[a->first];
item.allocations = a->second;
item.eraseCountdown = 300;
}
}
{
std::map<const gmFunctionObject*, ThreadAllocationItem>::const_iterator a = m_threadAllocationsHistory.begin();
std::map<const gmFunctionObject*, ThreadAllocationItem>::const_iterator b = m_threadAllocationsHistory.end();
for (; a != b; ++a)
{
const gmFunctionObject* func = a->first;
const gmuint32 sourceid = func->GetSourceId();
const char* sourcecode = NULL;
const char* filename = NULL;
m_vm->GetSourceCode(sourceid, sourcecode, filename);
int allocations = a->second.allocations;
if (allocations <= 0)
continue;
char buffer[128] = { '.' };
const char* fname = func->GetDebugName();
const char* status = a->second.eraseCountdown == 300 ? "new" : "old";
sprintf(buffer, "%s:%s [%s]", filename, fname, status);
int len = strlen(buffer);
memset( &buffer[len], '.', sizeof(buffer)-len-1);
itoa(allocations, buffer+50, 10);
Imgui::Print(buffer);
}
}
Imgui::End();
}
}
int main(int argc, char* argv[])
{
//-----------------------------------------------------------------------
// INITIALIZATION
//-----------------------------------------------------------------------
printf ("\n");
printf ("-----------------------------------\n");
printf ("CHAI 3D\n");
printf ("Demo: 12-polygons\n");
printf ("Copyright 2003-2009\n");
printf ("-----------------------------------\n");
printf ("\n\n");
printf ("Keyboard Options:\n\n");
printf ("[1] - Wireframe (ON/OFF)\n");
printf ("[x] - Exit application\n");
printf ("\n\n");
// parse first arg to try and locate resources
resourceRoot = string(argv[0]).substr(0,string(argv[0]).find_last_of("/\\")+1);
//-----------------------------------------------------------------------
// 3D - SCENEGRAPH
//-----------------------------------------------------------------------
// create a new world.
world = new cWorld();
// set the background color of the environment
// the color is defined by its (R,G,B) components.
world->setBackgroundColor(0.15, 0.15, 0.15);
// create a camera and insert it into the virtual world
camera = new cCamera(world);
world->addChild(camera);
// position and oriente the camera
camera->set( cVector3d (3.0, 0.0, 0.0), // camera position (eye)
cVector3d (0.0, 0.0, 0.0), // lookat position (target)
cVector3d (0.0, 0.0, 1.0)); // direction of the "up" vector
// set the near and far clipping planes of the camera
// anything in front/behind these clipping planes will not be rendered
camera->setClippingPlanes(0.01, 10.0);
// create a light source and attach it to the camera
light = new cLight(world);
camera->addChild(light); // attach light to camera
light->setEnabled(true); // enable light source
light->setPos(cVector3d( 2.0, 0.5, 1.0)); // position the light source
light->setDir(cVector3d(-2.0, 0.5, 1.0)); // define the direction of the light beam
//-----------------------------------------------------------------------
// 2D - WIDGETS
//-----------------------------------------------------------------------
// create a 2D bitmap logo
logo = new cBitmap();
// add logo to the front plane
camera->m_front_2Dscene.addChild(logo);
// load a "chai3d" bitmap image file
bool fileload;
fileload = logo->m_image.loadFromFile(RESOURCE_PATH("resources/images/chai3d.bmp"));
if (!fileload)
{
#if defined(_MSVC)
fileload = logo->m_image.loadFromFile("../../../bin/resources/images/chai3d.bmp");
#endif
}
// position the logo at the bottom left of the screen (pixel coordinates)
logo->setPos(10, 10, 0);
// scale the logo along its horizontal and vertical axis
logo->setZoomHV(0.4, 0.4);
// here we replace all wite pixels (1,1,1) of the logo bitmap
// with transparent black pixels (1, 1, 1, 0). This allows us to make
// the background of the logo look transparent.
logo->m_image.replace(
cColorb(0x00, 0x00, 0x00), // original RGB color
cColorb(0x00, 0x00, 0x00, 0x00) // new RGBA color
);
// enable transparency
logo->enableTransparency(true);
//-----------------------------------------------------------------------
// HAPTIC DEVICES / TOOLS
//-----------------------------------------------------------------------
// create a haptic device handler
handler = new cHapticDeviceHandler();
// get access to the first available haptic device
cGenericHapticDevice* hapticDevice;
handler->getDevice(hapticDevice, 0);
// retrieve information about the current haptic device
cHapticDeviceInfo info;
if (hapticDevice)
{
info = hapticDevice->getSpecifications();
}
// create a 3D tool and add it to the world
tool = new cGeneric3dofPointer(world);
world->addChild(tool);
// connect the haptic device to the tool
tool->setHapticDevice(hapticDevice);
// initialize tool by connecting to haptic device
tool->start();
// map the physical workspace of the haptic device to a larger virtual workspace.
tool->setWorkspaceRadius(1.0);
// define a radius for the tool (graphical display)
tool->setRadius(0.1);
// hide the device sphere. only show proxy.
tool->m_deviceSphere->setShowEnabled(false);
// set the physical readius of the proxy.
proxyRadius = 0.1;
tool->m_proxyPointForceModel->setProxyRadius(proxyRadius);
// enable if objects in the scene are going to rotate of translate
// or possibly collide against the tool. If the environment
// is entirely static, you can set this parameter to "false"
tool->m_proxyPointForceModel->m_useDynamicProxy = true;
// read the scale factor between the physical workspace of the haptic
// device and the virtual workspace defined for the tool
double workspaceScaleFactor = tool->getWorkspaceScaleFactor();
// define a maximum stiffness that can be handled by the current
// haptic device. The value is scaled to take into account the
// workspace scale factor
double stiffnessMax = info.m_maxForceStiffness / workspaceScaleFactor;
//-----------------------------------------------------------------------
// COMPOSE THE VIRTUAL SCENE
//-----------------------------------------------------------------------
// create a virtual mesh
object = new cMesh(world);
// add object to world
world->addChild(object);
// set the position of the object at the center of the world
object->setPos(0.0, 0.0, 0.0);
// Since we want to see our polygons from both sides, we disable culling.
object->setUseCulling(false, true);
// here we create a small cloud of triangles
double ang = 0;
double angStep = 5;
while (ang < 360)
{
double radius = 0.2;
double radiusStep = 0.1;
double tang = ang;
while (radius < 1.0)
{
// we create three vectors p0, p1, p2 that describe the position of the vertices
cVector3d p0 = cVector3d(0.0, radius * cCosDeg(tang), radius * cSinDeg(tang));
cVector3d p1 = cVector3d(0.0, (radius + radiusStep) * cCosDeg(tang+angStep), (radius + radiusStep) * cSinDeg(tang+angStep));
cVector3d p2 = cVector3d(0.0, (radius + radiusStep) * cCosDeg(tang-angStep), (radius + radiusStep) * cSinDeg(tang-angStep));
// we generate a triangles by passing the position of the new vertices
unsigned int index = object->newTriangle(p0, p1, p2);
// for each triangle we define a color
cColorf color;
color.set(ang / 360, 1.0 - ang/360, radius);
// we get a pointer to the latest created triangle
cTriangle* triangle = object->getTriangle(index);
// we get pointers to its respective vertices.
cVertex* vertex0 = triangle->getVertex0();
cVertex* vertex1 = triangle->getVertex1();
cVertex* vertex2 = triangle->getVertex2();
// for each vertex we attribute the new color. In this example
// the color is the same for all vertices, but it is of course
// possible to define a specific color for each vertex
vertex0->setColor(color);
vertex1->setColor(color);
vertex2->setColor(color);
// we increment the different counters
radiusStep = 1.1 * radiusStep;
radius = radius + 1.2 * radiusStep;
tang = tang + 0.5 * angStep;
}
ang = ang + 3 * angStep;
}
// we indicate that we ware rendering the triangle by using the specific
// colors for each of them (see abov)
object->setUseVertexColors(true);
// compute a boundary box
object->computeBoundaryBox(true);
// compute collision detection algorithm
object->createAABBCollisionDetector(1.01 * proxyRadius, true, false);
// define a default stiffness for the object
object->setStiffness(stiffnessMax, true);
// define some haptic friction properties
object->setFriction(0.1, 0.2, true);
//-----------------------------------------------------------------------
// OPEN GL - WINDOW DISPLAY
//-----------------------------------------------------------------------
// initialize GLUT
glutInit(&argc, argv);
// retrieve the resolution of the computer display and estimate the position
// of the GLUT window so that it is located at the center of the screen
int screenW = glutGet(GLUT_SCREEN_WIDTH);
int screenH = glutGet(GLUT_SCREEN_HEIGHT);
int windowPosX = (screenW - WINDOW_SIZE_W) / 2;
int windowPosY = (screenH - WINDOW_SIZE_H) / 2;
// initialize the OpenGL GLUT window
glutInitWindowPosition(windowPosX, windowPosY);
glutInitWindowSize(WINDOW_SIZE_W, WINDOW_SIZE_H);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow(argv[0]);
glutDisplayFunc(updateGraphics);
glutKeyboardFunc(keySelect);
glutReshapeFunc(resizeWindow);
glutSetWindowTitle("CHAI 3D");
// create a mouse menu (right button)
glutCreateMenu(menuSelect);
glutAddMenuEntry("full screen", OPTION_FULLSCREEN);
glutAddMenuEntry("window display", OPTION_WINDOWDISPLAY);
glutAttachMenu(GLUT_RIGHT_BUTTON);
//-----------------------------------------------------------------------
// START SIMULATION
//-----------------------------------------------------------------------
// simulation in now running
simulationRunning = true;
// create a thread which starts the main haptics rendering loop
cThread* hapticsThread = new cThread();
hapticsThread->set(updateHaptics, CHAI_THREAD_PRIORITY_HAPTICS);
// start the main graphics rendering loop
glutMainLoop();
// close everything
close();
// exit
return (0);
}
