static LPDIRECT3DDEVICE9 GetDevice()
{
GraphicsWindow *GW;
ViewExp *View;
LPDIRECT3DDEVICE9 Device;
View = GetCOREInterface()->GetActiveViewport();
if(View)
{
GW = View->getGW();
if(GW)
{
ID3D9GraphicsWindow *D3DGW = (ID3D9GraphicsWindow *)GW->GetInterface(D3D9_GRAPHICS_WINDOW_INTERFACE_ID);
if(D3DGW)
{
Device = D3DGW->GetDevice();
return(Device);
}
}
}
return NULL;
}
void CrossSectionMouseProc::DrawCrossing(HWND hWnd)
{
if (mShapeData == NULL) return;
BezierShape *shape = mShapeData->TempData(es)->GetShape(ip->GetTime());
if (shape == NULL) return;
int polys = mSelectedSplines.Count();
if (polys <= 0) return;
Spline3D *spline = shape->GetSpline(mSelectedSplines[polys-1]);
int knots = spline->KnotCount();
Point3 p(0.0f, 0.0f, 0.0f);
IPoint3 sp;
ViewExp *vpt = ip->GetViewport(hWnd);
GraphicsWindow *gw = vpt->getGW();
ip->ReleaseViewport(vpt);
gw->setTransform(mObjToWorldTM);
HDC hdc = GetDC(hWnd);
SetROP2(hdc, R2_XORPEN);
SetBkMode(hdc, TRANSPARENT);
SelectObject(hdc,CreatePen(PS_DOT, 0, ComputeViewportXORDrawColor()));
for (int i = 0, j = 0; i < 2 && i <= j; i++, j += (knots-1)) {
if (knots > i) p = spline->GetKnotPoint(j);
gw->wTransPoint(&p, &sp);
MoveToEx(hdc,sp.x,sp.y,NULL);
LineTo(hdc,mMouse.x,mMouse.y);
}
DeleteObject(SelectObject(hdc,GetStockObject(BLACK_PEN)));
ReleaseDC(hWnd, hdc);
}
void
TrackMouseCallBack::draw_marker(ViewExp& vpt, Point3 p, Point3 norm)
{
return; // sorry, this doesn't work yet - I'll post it later
// set GW tm to orientation specified by norm and draw a circle
Matrix3 tm;
Point3 zdir, ydir, xdir;
// compute the direction of the z axis to be.
// the positive z axis points AWAY from the target.
zdir = Normalize(norm);
// compute direction of the X axis before roll.
xdir = Normalize(CrossProd(zdir.x > 0 ? Point3(0, 0, 1) : Point3(0, 0, -1), zdir));
// compute direction of the Y axis before roll.
ydir = Normalize(CrossProd(zdir, xdir));
tm.SetRow(0, xdir);
tm.SetRow(1, ydir);
tm.SetRow(2, zdir);
vpt.getGW()->setTransform(tm);
vpt.getGW()->setColor(LINE_COLOR, MARKER_COLOR);
vpt.getGW()->marker(&p, CIRCLE_MRKR);
}
/**
* This method will be called from the max system when the user
* has choosen to export to the OpenSceneGraph format.
* This method is the entry point to the exporter plugin.
*/
int OSGExp::DoExport(const TCHAR *name, ExpInterface *ei,
Interface *i, BOOL suppressPrompts, DWORD MAXOptions){
// Only support "one at the time" exporting.
if(isExporting){
return FALSE;
}
isExporting = TRUE;
// Grab the interface pointer and save it for later use.
_ip = i;
// Set export path in options class
TCHAR p[300];
TCHAR f[100];
TCHAR e[10];
BMMSplitFilename(name, p, f, e);
_options->setExportPath(p);
_options->setExportFilename(f);
_options->setExportExtension(e);
// Get filename to config file.
TSTR cfgfilename = _ip->GetDir(APP_PLUGCFG_DIR);;
cfgfilename += _T("\\OSGEXP.CFG");
// Load options from config file
_options->load(cfgfilename);
// Should we only export selected nodes?
_onlyExportSelected = (MAXOptions & SCENE_EXPORT_SELECTED) ? TRUE : FALSE;
// Show option dialog to user and retrive any possible plugin choices.
if(!suppressPrompts)
if(!DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_EXPORTBOX),
GetActiveWindow(), OptionsDlgProc,
(LPARAM)_options)){
// If user closed or canceled export box then shutdown plugin.
isExporting = FALSE;
return TRUE;
}
// Write options to config file.
_options->write(cfgfilename);
// Create OSG root transform to hold the scene.
{
osg::ref_ptr<osg::MatrixTransform> rootTransform = new osg::MatrixTransform();
//osg::MatrixTransform* rootTransform = new osg::MatrixTransform();
rootTransform->setName(std::string(_ip->GetRootNode()->GetName()));
// Set static datavariance for better performance
rootTransform->setDataVariance(osg::Object::STATIC);
// Set NodeMask
if(_options->getUseDefaultNodeMaskValue())
rootTransform->setNodeMask(_options->getDefaultNodeMaskValue());
osg::Matrix rootMat = getNodeTransform(_ip->GetRootNode(), _ip->GetTime());
rootTransform->setMatrix(rootMat);
// Create root stateset for the lights.
osg::ref_ptr<osg::StateSet> rootStateSet = new osg::StateSet();
// Turn of lighting if set by the user.
if(_options->getTurnOffLighting())
rootStateSet->setMode(GL_LIGHTING,osg::StateAttribute::OVERRIDE|osg::StateAttribute::OFF);
else
rootStateSet->setMode(GL_LIGHTING,osg::StateAttribute::ON);
//osg::StateSet* rootStateSet = new osg::StateSet();
rootTransform->setStateSet(rootStateSet.get());
// We will make two progress bars. The first one will show
// the exporting of materials, wheras the second one will show
// the exporting of nodes. To get the total number of nodes in the
// scene graph we will accumulate the total node count while
// preprocessing the scenegraph for materials.
_nTotalNodeCount = 0;
_nCurNode = 0;
_nTotalMtlCount = _ip->GetSceneMtls()->Count();
_nCurMtl = 0;
// Starting up the material exporting progress bar.
_ip->ProgressStart(_T("Exporting materials..."), TRUE, fn, NULL);
// Export materials by preprocessing the scenegraph.
if(!preProcess(_ip->GetRootNode(), _ip->GetTime())){
// If user cancels we stop progress bar and return.
_ip->ProgressEnd();
isExporting = FALSE;
return TRUE;
}
// We're done exporting materials. Finish the progress bar.
_ip->ProgressEnd();
// Starting up the node exporting progress bar.
_ip->ProgressStart(_T("Exporting scene..."), TRUE, fn, NULL);
// Get number of children for the root node in the interface.
int numChildren = _ip->GetRootNode()->NumberOfChildren();
// Call our node enumerator.
// The nodeEnum function will recurse into itself and
// export each object found in the scene.
for (int idx=0; idx<numChildren; idx++) {
if (_ip->GetCancel() || !nodeEnum(rootTransform.get(), _ip->GetRootNode()->GetChildNode(idx), rootTransform.get())){
// If user cancels we stop progress bar and return
_ip->ProgressEnd();
isExporting = FALSE;
return TRUE;
}
}
// Finish exporting progress bar
_ip->ProgressEnd();
// If optimize scene graph
unsigned int optimizeMask = 0;
if(_options->getTriStripGeometry())
optimizeMask |= osgUtil::Optimizer::TRISTRIP_GEOMETRY;
if(_options->getMergeGeometry())
optimizeMask |= osgUtil::Optimizer::MERGE_GEOMETRY;
if(_options->getFlattenStaticTransform())
optimizeMask |= osgUtil::Optimizer::FLATTEN_STATIC_TRANSFORMS;
if(_options->getShareDuplicateStates())
optimizeMask |= osgUtil::Optimizer::SHARE_DUPLICATE_STATE;
if(_options->getSpatializeGroups())
optimizeMask |= osgUtil::Optimizer::SPATIALIZE_GROUPS;
if(optimizeMask){
_ip->ProgressStart(_T("Optimizing scenegraph..."), FALSE, fn, NULL);
_ip->ProgressUpdate(0.5f);
osgUtil::Optimizer optimizer;
optimizer.optimize(rootTransform.get(), optimizeMask);
_ip->ProgressEnd();
}
// Save file to disk.
if(_options->getSaveFile()){
_ip->ProgressStart(_T("Writing file..."), FALSE, fn, NULL);
_ip->ProgressUpdate(0.5f);
if(_options->getExportExtension().compare(".osg")==0 ||
_options->getExportExtension().compare(".OSG")==0 ||
_options->getExportExtension().compare(".ive")==0 ||
_options->getExportExtension().compare(".IVE")==0 ){
std::string filename(name);
// Exclude image data from ive file if this options has been choosen
if(!_options->getIncludeImageDataInIveFile()){
osgDB::ReaderWriter::Options* opt = new osgDB::ReaderWriter::Options("noTexturesInIVEFile");
osgDB::Registry::instance()->setOptions(opt);
}
#if defined(OPENSCENEGRAPH_MAJOR_VERSION) && OPENSCENEGRAPH_MAJOR_VERSION >= 2 && defined(OPENSCENEGRAPH_MINOR_VERSION) && OPENSCENEGRAPH_MINOR_VERSION >= 4
osgDB::ReaderWriter::WriteResult res =
osgDB::Registry::instance()->writeNode(*rootTransform, filename, NULL);
#else
osgDB::ReaderWriter::WriteResult res =
osgDB::Registry::instance()->writeNode(*rootTransform, filename);
#endif
if(res.error() && _options->getShowErrMsg()){
static TCHAR szBuffer[256];
wsprintf(szBuffer,TEXT("Error writing file %s:\n%s"),
TEXT(filename.c_str()),res.message());
MessageBox (GetActiveWindow(), szBuffer, TEXT("Warning"),
MB_OK | MB_ICONWARNING) ;
}
if(!_options->getIncludeImageDataInIveFile()){
// Turn readerwriter options off again.
osgDB::ReaderWriter::Options* opt = new osgDB::ReaderWriter::Options();
osgDB::Registry::instance()->setOptions(opt);
}
}
else{
if(_options->getShowErrMsg()){
std::string error("Can not find plugin to save file: ");
error.append(name);
MessageBox (GetActiveWindow(), error.c_str() , TEXT("Warning"), MB_OK | MB_ICONWARNING) ;
}
}
_ip->ProgressEnd();
}
// Show quick preview
if(_options->getQuickView()){
float fNear = 1.0f;
float fFar = 1000.0f;
// Get the active viewport and the win32 window within it.
// The position and size will be retreive from this.
ViewExp* viewExp = _ip->GetActiveViewport();
float fov = viewExp->GetFOV();
HWND hWnd = viewExp->getGW()->getHWnd();
RECT sRect;
BOOL ok = GetWindowRect(hWnd, &sRect);
int width = 100;
int height = 100;
int x =100;
int y =100;
if(ok){
x = sRect.left;
y = sRect.top;
width = sRect.right - sRect.left;
height = sRect.bottom - sRect.top;
}
// Create previewer window and set size.
Previewer previewer;
previewer.setWindowSize(x, y, width, height);
// The affine TM transforms from world coords to view coords
// so we need the inverse of this matrix
Matrix3 aTM, camTM, coordSysTM;
Point3 viewDir, viewPos, lookAtPos, upVector;
INode* camera;
float dist = 100;
Point3 upperLeft = viewExp->MapScreenToView(IPoint2(0, 0), fFar);
Point3 lowerRight = viewExp->MapScreenToView(IPoint2(width, height), fFar);
viewExp->GetAffineTM(aTM);
coordSysTM = Inverse(aTM);
viewDir = coordSysTM.VectorTransform(Point3(0.0f, 0.0f, -1.0f));
viewPos = coordSysTM.GetRow(3);
lookAtPos = viewPos + viewDir;
upVector.Set(0.0f, 0.0f, 1.0f);
switch(viewExp->GetViewType()){
case VIEW_ISO_USER:
case VIEW_PERSP_USER:
previewer.setProjectionMatrixAsFrustum(lowerRight.x, upperLeft.x, upperLeft.y, lowerRight.y, fFar, -fFar);
break;
case VIEW_CAMERA:
previewer.setProjectionMatrixAsFrustum(upperLeft.x, lowerRight.x, lowerRight.y, upperLeft.y, fFar, -fFar);
camera = viewExp->GetViewCamera();
camTM = camera->GetObjTMBeforeWSM(_ip->GetTime());
viewDir = camTM.VectorTransform(Point3(0.0f, 0.0f, -1.0f));
viewPos = camTM.GetRow(3);
lookAtPos = viewPos + viewDir;
break;
case VIEW_LEFT:
case VIEW_RIGHT:
case VIEW_TOP:
case VIEW_BOTTOM:
case VIEW_FRONT:
case VIEW_BACK:
previewer.setProjectionMatrixAsOrtho(upperLeft.x, lowerRight.x, lowerRight.y, upperLeft.y, -fFar, fFar);
//cam->setOrtho(upperLeft.x, lowerRight.x, lowerRight.y, upperLeft.y, -fFar, fFar);
// Go far away from the viewing point in the negative viewing direction.
viewPos = coordSysTM.PointTransform(Point3(0.0f, 0.0f, fFar));
lookAtPos = viewPos + viewDir;
// In top view the up vector on the camera is the positive y-axis.
if(viewExp->GetViewType() == VIEW_TOP)
upVector.Set(0.0f, 1.0f, 0.0f);
// In bottom view the up vector on the camera is the negative y-axis.
if(viewExp->GetViewType() == VIEW_BOTTOM)
upVector.Set(0.0f, -1.0f, 0.0f);
break;
}
// When we are done with the viewport we should release it.
_ip->ReleaseViewport(viewExp);
// Set scene data.
previewer.setSceneData(rootTransform.get());
// set the view - OpenGL look at
previewer.setViewMatrixAsLookAt(osg::Vec3( viewPos.x, viewPos.y, viewPos.z),
osg::Vec3(lookAtPos.x, lookAtPos.y, lookAtPos.z),
osg::Vec3(upVector.x, upVector.y, upVector.z) );
previewer.run();
isExporting = FALSE;
return TRUE;
}
}
isExporting = FALSE;
return TRUE;
}
int CreateLineMouseProc::proc(
HWND hwnd,
int msg,
int point,
int flags,
IPoint2 m )
{
ViewExp *vpt = ip->GetViewport(hwnd);
int res = TRUE;
static int poly, seg, vert;
static BezierShape *shape;
static Spline3D *spline;
static BOOL creating = FALSE;
static BOOL inserting = FALSE;
static Matrix3 mat;
static EditSplineMod *mod;
static int originalInsert;
if(creating) {
// Ignore the messages the spline code doesn't care about... TH 3/12/99
switch(msg) {
#ifdef DESIGN_VER
case MOUSE_DBLCLICK:
#endif
case MOUSE_POINT:
case MOUSE_MOVE:
case MOUSE_ABORT:
break;
default:
return TRUE;
}
vpt->getGW()->setTransform(mat);
int res = shape->splines[poly]->Create(vpt,msg,point,flags,m,&mat,ip);
// Must update the shape's selection set for this spline
shape->UpdateSels(TRUE);
switch(res) {
case CREATE_STOP:
es->EndCreateLine();
creating = FALSE;
backspaceRouter.UnRegister(&pBack);
break;
case CREATE_ABORT:
shape->DeleteSpline(poly);
es->EndCreateLine(FALSE);
creating = FALSE;
backspaceRouter.UnRegister(&pBack);
break;
}
mod->createShapeData->Invalidate(PART_GEOM);
mod->NotifyDependents(FOREVER, PART_GEOM, REFMSG_CHANGE);
ip->RedrawViews(ip->GetTime(), REDRAW_NORMAL);
}
else
if(inserting) {
// Ignore the messages the spline code doesn't care about... TH 3/12/99
switch(msg) {
#ifdef DESIGN_VER
case MOUSE_DBLCLICK:
#endif
case MOUSE_POINT:
{
for (int i = 0; i < shape->bindList.Count();i++)
{
if (poly == shape->bindList[i].segSplineIndex)
{
if ((seg!=-1)&&(originalInsert <= shape->bindList[i].seg))
{
if (originalInsert == shape->bindList[i].seg)
{
{
shape->bindList[i].seg++;
}
}
else
{
shape->bindList[i].seg++;
}
}
}
}
}
case MOUSE_MOVE:
case MOUSE_ABORT:
break;
default:
return TRUE;
}
int res = shape->splines[poly]->Create(vpt,msg,point,flags,m,&mat,ip);
// Must update the shape's selection set for this spline
BitArray& vsel = shape->vertSel[poly];
BitArray& ssel = shape->segSel[poly];
while(vsel.GetSize() < shape->splines[poly]->Verts()) {
vsel.SetSize(vsel.GetSize() + 3,1);
vsel.Shift(RIGHT_BITSHIFT,3,vert+3);
vsel.Clear(vert+2);
vsel.Clear(vert+3);
vsel.Clear(vert+4);
}
while(ssel.GetSize() < shape->splines[poly]->Segments()) {
ssel.SetSize(ssel.GetSize() + 1,1);
ssel.Shift(RIGHT_BITSHIFT,1,vert/3+1);
ssel.Clear(vert/3+1);
}
switch(res) {
case CREATE_STOP: {
// Must update the shape's selection set for this spline
BitArray& vsel = shape->vertSel[poly];
BitArray& ssel = shape->segSel[poly];
while(vsel.GetSize() > shape->splines[poly]->Verts()) {
vsel.Shift(LEFT_BITSHIFT,3,vert+1);
vsel.SetSize(vsel.GetSize() - 3,1);
}
while(ssel.GetSize() > shape->splines[poly]->Segments()) {
ssel.Shift(LEFT_BITSHIFT,1,(vert+1)/3);
ssel.SetSize(ssel.GetSize() - 1,1);
}
es->EndVertInsert();
inserting = FALSE;
backspaceRouter.UnRegister(&iBack);
for (int i = 0; i < shape->bindList.Count();i++)
{
if (poly == shape->bindList[i].segSplineIndex)
{
if ((seg!=-1)&&(originalInsert <= shape->bindList[i].seg))
{
if (originalInsert == shape->bindList[i].seg)
{
{
shape->bindList[i].seg--;
}
}
else
{
shape->bindList[i].seg--;
}
}
}
}
break;
}
case CREATE_ABORT:
shape->DeleteSpline(poly);
es->insertPoly = -1;
es->EndVertInsert();
inserting = FALSE;
backspaceRouter.UnRegister(&iBack);
break;
}
mod->insertShapeData->Invalidate(PART_GEOM);
mod->NotifyDependents(FOREVER, PART_GEOM, REFMSG_CHANGE);
ip->RedrawViews(ip->GetTime(), REDRAW_NORMAL);
}
else
{
switch(msg) {
case MOUSE_PROPCLICK:
ip->SetStdCommandMode(CID_OBJMOVE);
break;
case MOUSE_POINT:
mod = es;
if((SplineShape::GetUseEndPointAutoConnect()==BST_CHECKED) &&
InsertWhere(vpt, &m, &shape, &poly, &seg, &vert)) {
vert = es->StartVertInsert(vpt, shape, poly, seg, vert, &mod);
if(vert < 0) {
res = FALSE;
break;
}
originalInsert = seg;
mat = mod->insertTM;
shape->splines[poly]->StartInsert(vpt, msg, point, flags, m, &mat, vert/3+1 );
// Must update the shape's selection set for this spline
BitArray& vsel = shape->vertSel[poly];
BitArray& ssel = shape->segSel[poly];
while(vsel.GetSize() < shape->splines[poly]->Verts()) {
vsel.SetSize(vsel.GetSize() + 3,1);
vsel.Shift(RIGHT_BITSHIFT,3,vert+3);
vsel.Clear(vert+2);
vsel.Clear(vert+3);
vsel.Clear(vert+4);
}
while(ssel.GetSize() < shape->splines[poly]->Segments()) {
ssel.SetSize(ssel.GetSize() + 1,1);
ssel.Shift(RIGHT_BITSHIFT,1,vert/3+1);
ssel.Clear(vert/3+1);
}
inserting = TRUE;
iBack.SetPtrs(mod, shape->splines[poly]);
backspaceRouter.Register(&iBack);
}
else {
if(!mod->StartCreateLine(&shape))
return CREATE_ABORT;
poly = shape->splineCount;
spline = shape->NewSpline();
shape->UpdateSels(TRUE);
mat = mod->createTM;
vpt->getGW()->setTransform(mat);
if(spline->Create(vpt,msg,point,flags,m,&mat,ip) == CREATE_CONTINUE) {
creating = TRUE;
shape->UpdateSels(TRUE);
pBack.SetPtrs(mod, spline);
backspaceRouter.Register(&pBack);
}
else {
shape->DeleteSpline(poly);
res = FALSE;
}
}
SetCursor(LoadCursor(hInstance,MAKEINTRESOURCE(IDC_ES_CROSS_HAIR)));
break;
case MOUSE_MOVE:
case MOUSE_ABORT:
res = FALSE;
break;
case MOUSE_FREEMOVE:
if((SplineShape::GetUseEndPointAutoConnect()==BST_CHECKED) &&
InsertWhere(vpt, &m, &shape, &poly, &seg, &vert))
SetCursor(LoadCursor(hInstance,MAKEINTRESOURCE(IDC_CREATE_WELD)));
else
SetCursor(LoadCursor(hInstance,MAKEINTRESOURCE(IDC_ES_CROSS_HAIR)));
vpt->SnapPreview(m,m,NULL, SNAP_IN_3D);
break;
}
}
if ( vpt ) ip->ReleaseViewport(vpt);
return res;
}