Init
This commit is contained in:
ninja
868
exchange/exchangesource/DrawingViewer/drawing_main.cpp
Normal file
868
exchange/exchangesource/DrawingViewer/drawing_main.cpp
Normal file
@@ -0,0 +1,868 @@
|
||||
/***********************************************************************************************************************
|
||||
*
|
||||
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
|
||||
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
|
||||
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
|
||||
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
|
||||
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
|
||||
* scope and manner of such use.
|
||||
*
|
||||
***********************************************************************************************************************/
|
||||
/**
|
||||
\file drawing_main.cpp
|
||||
|
||||
This file demonstrates how to programmatically visualize a drawing PRC file
|
||||
from a basic OpenGL program using HOOPS Exchange.
|
||||
|
||||
***********************************************************************************************************************/
|
||||
|
||||
#define INITIALIZE_A3D_API
|
||||
#include <A3DSDKIncludes.h>
|
||||
|
||||
#include "../common.hpp"
|
||||
|
||||
#include "callback_opengl.h"
|
||||
#include "drawing_main.h"
|
||||
#include "trackball.h"
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <time.h>
|
||||
#include <vector>
|
||||
|
||||
//######################################################################################################################
|
||||
A3DStatus CollectDrawing(A3DAsmModelFile* pModelFile, std::vector<A3DDrawingModel*> &apDrawingModels);
|
||||
|
||||
//######################################################################################################################
|
||||
A3DStatus A3DDrawDrawing(A3DDrawingModel* pDrawingModel, A3DDrawCallbacksData* psCallbacks,
|
||||
std::vector<GLuint> &aGLSheetDisplayList, std::vector<A3DVector2dData>* paGLSheetSize,
|
||||
bool bDrawMarkup);
|
||||
|
||||
//######################################################################################################################
|
||||
static bool stbTrackBallAnimate = GL_FALSE;
|
||||
|
||||
//######################################################################################################################
|
||||
static GLsizei stiXScreen = 0;
|
||||
static GLsizei stiYScreen = 0;
|
||||
static GLdouble stdXPan = 0.0;
|
||||
static GLdouble stdYPan = 0.0;
|
||||
static GLdouble stdZoom = 1.0;
|
||||
static GLint staiViewport[4];
|
||||
|
||||
//######################################################################################################################
|
||||
static bool stbLButtonDown = false;
|
||||
static bool stbRButtonDown = false;
|
||||
|
||||
//######################################################################################################################
|
||||
static GLuint stuiModelFileDisplayList = 0;
|
||||
static GLuint stuiMarkupsDisplayList = 0;
|
||||
static GLuint stuiTriedronDisplayList = 0;
|
||||
|
||||
//######################################################################################################################
|
||||
static std::vector<GLuint> st_aGLSheetDisplayList;
|
||||
static std::vector<A3DVector2dData> st_aGLSheetSize;
|
||||
|
||||
//######################################################################################################################
|
||||
static std::vector<GLuint> st_aGLSheetMarkupDisplayList;
|
||||
static GLuint st_CurrentSheetIndex = 0;
|
||||
|
||||
//######################################################################################################################
|
||||
static GLfloat stafLightDiffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
|
||||
static GLfloat stafLightAmbient[] = { 0.1f, 0.1f, 0.1f, 1.0f };
|
||||
static GLfloat stafLightPosition[] = { 0.0f, 0.0f, 1.0f, 0.0f };
|
||||
|
||||
//######################################################################################################################
|
||||
static GLfloat stafMaterialDiffuse[] = { 0.6f, 0.6f, 0.6f, 1.0f };
|
||||
static GLfloat stafMaterialSpecular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
|
||||
static GLfloat stafMaterialShininess[] = { 100.0f };
|
||||
|
||||
//######################################################################################################################
|
||||
static GLfloat stafTextColor[] = { 1.0f, 1.0f, 0.0f, 1.0f };
|
||||
|
||||
//######################################################################################################################
|
||||
static unsigned int stuiClearColor = 0xB2B2B2;
|
||||
|
||||
//######################################################################################################################
|
||||
static GLint staiWinSize[2];
|
||||
static GLint staiWinPosition[2];
|
||||
static bool stbFullScreen = false;
|
||||
|
||||
//######################################################################################################################
|
||||
static clock_t stiStart, stiEnd;
|
||||
static float stfElapsed;
|
||||
static unsigned int stiNbFrames = 0;
|
||||
static float stfFps = 0.0f;
|
||||
|
||||
//######################################################################################################################
|
||||
static A3DUTF8Char stpcWinTitle[_MAX_PATH];
|
||||
|
||||
//######################################################################################################################
|
||||
static bool stbDisplayHelp = false;
|
||||
static bool stbDisplayInfos = false;
|
||||
static bool stbDisplayMarkups = true;
|
||||
|
||||
//######################################################################################################################
|
||||
#define TRIEDRON_SIZE 40.0
|
||||
|
||||
//######################################################################################################################
|
||||
#define A3DGL_MIN(a,b) (((a)<(b)) ? (a) : (b))
|
||||
#define A3DGL_MAX(a,b) (((a)>(b)) ? (a) : (b))
|
||||
|
||||
//######################################################################################################################
|
||||
class A3DPRCViewerGLInfo
|
||||
{
|
||||
public:
|
||||
A3DBoundingBoxData sBoundingBox;
|
||||
double dBoundingBoxRadius;
|
||||
A3DVector3dData sBoundingBoxCenter;
|
||||
A3DVector2dData sDelta;
|
||||
|
||||
public:
|
||||
//##################################################################################################################
|
||||
A3DPRCViewerGLInfo() { Init(); }
|
||||
|
||||
//##################################################################################################################
|
||||
void Init()
|
||||
{
|
||||
A3D_INITIALIZE_DATA(A3DBoundingBoxData, sBoundingBox);
|
||||
A3D_INITIALIZE_DATA(A3DVector3dData, sBoundingBoxCenter);
|
||||
dBoundingBoxRadius = 0.0;
|
||||
}
|
||||
|
||||
//##################################################################################################################
|
||||
void operator=(const A3DPRCViewerGLInfo& sOther)
|
||||
{
|
||||
sBoundingBox.m_sMin.m_dX = sOther.sBoundingBox.m_sMin.m_dX;
|
||||
sBoundingBox.m_sMin.m_dY = sOther.sBoundingBox.m_sMin.m_dY;
|
||||
sBoundingBox.m_sMin.m_dZ = sOther.sBoundingBox.m_sMin.m_dZ;
|
||||
sBoundingBox.m_sMax.m_dX = sOther.sBoundingBox.m_sMax.m_dX;
|
||||
sBoundingBox.m_sMax.m_dY = sOther.sBoundingBox.m_sMax.m_dY;
|
||||
sBoundingBox.m_sMax.m_dZ = sOther.sBoundingBox.m_sMax.m_dZ;
|
||||
dBoundingBoxRadius = sOther.dBoundingBoxRadius;
|
||||
sBoundingBoxCenter.m_dX = sOther.sBoundingBoxCenter.m_dX;
|
||||
sBoundingBoxCenter.m_dY = sOther.sBoundingBoxCenter.m_dY;
|
||||
sBoundingBoxCenter.m_dZ = sOther.sBoundingBoxCenter.m_dZ;
|
||||
}
|
||||
|
||||
//##################################################################################################################
|
||||
void Calculate()
|
||||
{
|
||||
A3DVector3dData sMin;
|
||||
A3DVector3dData sMax;
|
||||
sMin.m_dX = sBoundingBox.m_sMin.m_dX;
|
||||
sMin.m_dY = sBoundingBox.m_sMin.m_dY;
|
||||
sMin.m_dZ = sBoundingBox.m_sMin.m_dZ;
|
||||
sMax.m_dX = sBoundingBox.m_sMax.m_dX;
|
||||
sMax.m_dY = sBoundingBox.m_sMax.m_dY;
|
||||
sMax.m_dZ = sBoundingBox.m_sMax.m_dZ;
|
||||
|
||||
A3DDouble dBX = sMax.m_dX - sMin.m_dX;
|
||||
A3DDouble dBY = sMax.m_dY - sMin.m_dY;
|
||||
A3DDouble dBZ = sMax.m_dZ - sMin.m_dZ;
|
||||
dBoundingBoxRadius = (float)sqrt(dBX*dBX + dBY*dBY + dBZ*dBZ) / 2.0f;
|
||||
sBoundingBoxCenter.m_dX = (sMin.m_dX + sMax.m_dX) / 2.0;
|
||||
sBoundingBoxCenter.m_dY = (sMin.m_dY + sMax.m_dY) / 2.0;
|
||||
sBoundingBoxCenter.m_dZ = (sMin.m_dZ + sMax.m_dZ) / 2.0;
|
||||
}
|
||||
|
||||
//##################################################################################################################
|
||||
A3DPRCViewerGLInfo operator+(const A3DPRCViewerGLInfo& sOther)
|
||||
{
|
||||
A3DPRCViewerGLInfo sSum;
|
||||
ExtentUnion(&sBoundingBox, &sOther.sBoundingBox, &sSum.sBoundingBox);
|
||||
sSum.Calculate();
|
||||
return sSum;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
//##################################################################################################################
|
||||
void ExtentUnion(const A3DBoundingBoxData* e1, const A3DBoundingBoxData* e2, A3DBoundingBoxData* r)
|
||||
{
|
||||
r->m_sMin.m_dX = A3DGL_MIN(e1->m_sMin.m_dX, e2->m_sMin.m_dX);
|
||||
r->m_sMax.m_dX = A3DGL_MAX(e1->m_sMax.m_dX, e2->m_sMax.m_dX);
|
||||
r->m_sMin.m_dY = A3DGL_MIN(e1->m_sMin.m_dY, e2->m_sMin.m_dY);
|
||||
r->m_sMax.m_dY = A3DGL_MAX(e1->m_sMax.m_dY, e2->m_sMax.m_dY);
|
||||
r->m_sMin.m_dZ = A3DGL_MIN(e1->m_sMin.m_dZ, e2->m_sMin.m_dZ);
|
||||
r->m_sMax.m_dZ = A3DGL_MAX(e1->m_sMax.m_dZ, e2->m_sMax.m_dZ);
|
||||
}
|
||||
};
|
||||
|
||||
//######################################################################################################################
|
||||
static A3DDrawCallbacksData stsDrawCallbacksData;
|
||||
static A3DSDKHOOPSExchangeLoader* stpHOOPSExchangeLoader = NULL;
|
||||
|
||||
//######################################################################################################################
|
||||
static A3DPRCViewerGLInfo stsInfo;
|
||||
static A3DPRCViewerGLInfo stsInfo3D;
|
||||
static A3DPRCViewerGLInfo stsInfoMarkups;
|
||||
|
||||
//######################################################################################################################
|
||||
#define HEX_TO_RED(hexcolor) ((GLclampf) ((hexcolor & 0xFF0000) >> 16) / 255.0f)
|
||||
#define HEX_TO_GREEN(hexcolor) ((GLclampf) ((hexcolor & 0x00FF00) >> 8) / 255.0f)
|
||||
#define HEX_TO_BLUE(hexcolor) ((GLclampf) (hexcolor & 0x0000FF) / 255.0f)
|
||||
|
||||
//######################################################################################################################
|
||||
static enum
|
||||
{
|
||||
KE_NONE = 0,
|
||||
KE_ZOOMING,
|
||||
KE_PANNING
|
||||
} eMotionType;
|
||||
|
||||
//######################################################################################################################
|
||||
void Reshape(GLsizei w, GLsizei h)
|
||||
{
|
||||
tbReshape(w, h);
|
||||
|
||||
glViewport(0, 0, w, h);
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glLoadIdentity();
|
||||
double dLengthX = stsInfo.sBoundingBox.m_sMax.m_dX - stsInfo.sBoundingBox.m_sMin.m_dX;
|
||||
double dLengthY = stsInfo.sBoundingBox.m_sMax.m_dY - stsInfo.sBoundingBox.m_sMin.m_dY;
|
||||
|
||||
stsInfo.sDelta.m_dX = (dLengthY * w / h - dLengthX)/2.;
|
||||
stsInfo.sDelta.m_dY = (dLengthX * h / w - dLengthY)/2.;
|
||||
if(stsInfo.sDelta.m_dX > stsInfo.sDelta.m_dY)
|
||||
stsInfo.sDelta.m_dY = 0;
|
||||
else
|
||||
stsInfo.sDelta.m_dX = 0;
|
||||
|
||||
glOrtho(stsInfo.sBoundingBox.m_sMin.m_dX - stsInfo.sDelta.m_dX,
|
||||
stsInfo.sBoundingBox.m_sMax.m_dX + stsInfo.sDelta.m_dX,
|
||||
stsInfo.sBoundingBox.m_sMin.m_dY - stsInfo.sDelta.m_dY,
|
||||
stsInfo.sBoundingBox.m_sMax.m_dY + stsInfo.sDelta.m_dY,
|
||||
-1, 1);
|
||||
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
|
||||
glGetIntegerv(GL_VIEWPORT, staiViewport);
|
||||
|
||||
if(!stbFullScreen)
|
||||
{
|
||||
staiWinSize[0] = w;
|
||||
staiWinSize[1] = h;
|
||||
}
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
void InitGL(void)
|
||||
{
|
||||
glClearColor(HEX_TO_RED(stuiClearColor), HEX_TO_GREEN(stuiClearColor), HEX_TO_BLUE(stuiClearColor), 1.0f);
|
||||
|
||||
glPointSize(5.0f);
|
||||
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDepthFunc(GL_LEQUAL);
|
||||
glEnable(GL_NORMALIZE);
|
||||
glEnable(GL_CULL_FACE);
|
||||
glCullFace(GL_BACK);
|
||||
|
||||
stuiTriedronDisplayList = glGenLists(1);
|
||||
glNewList(stuiTriedronDisplayList, GL_COMPILE);
|
||||
{
|
||||
glPushAttrib(GL_LIGHTING_BIT | GL_LINE_BIT);
|
||||
glDisable(GL_LIGHTING);
|
||||
glLineWidth(2.0);
|
||||
glBegin(GL_LINES);
|
||||
glColor3f(1.0f, 0.0f, 0.0f);
|
||||
glVertex3f(0.0f, 0.0f, 0.0f);
|
||||
glVertex3f(TRIEDRON_SIZE, 0.0f, 0.0f);
|
||||
glColor3f(0.0f, 1.0f, 0.0f);
|
||||
glVertex3f(0.0f, 0.0f, 0.0f);
|
||||
glVertex3f(0.0f, TRIEDRON_SIZE, 0.0f);
|
||||
glColor3f(0.0f, 0.0f, 1.0f);
|
||||
glVertex3f(0.0f, 0.0f, 0.0f);
|
||||
glVertex3f(0.0f, 0.0f, TRIEDRON_SIZE);
|
||||
glEnd();
|
||||
glPopAttrib();
|
||||
}
|
||||
glEndList();
|
||||
|
||||
stdZoom = 1.;
|
||||
stdXPan = 0.0;
|
||||
stdYPan = 0.0;
|
||||
|
||||
#ifdef _DEBUG
|
||||
stiStart = clock();
|
||||
#endif
|
||||
|
||||
glClearDepth(1.0f);
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
static float stfX = 1.0f, stfY = 97.0f, stfLineH = 2.0f;
|
||||
static char stpcMsg[2048];
|
||||
|
||||
//######################################################################################################################
|
||||
void PrintString(const char* format, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
vsprintf(stpcMsg, format, args);
|
||||
va_end(args);
|
||||
|
||||
glRasterPos2f(stfX, stfY);
|
||||
char* pcPos = &stpcMsg[0];
|
||||
while(*pcPos)
|
||||
{
|
||||
if(*pcPos == '\n')
|
||||
{
|
||||
stfY -= stfLineH;
|
||||
glRasterPos2f(stfX, stfY);
|
||||
}
|
||||
else
|
||||
glutBitmapCharacter(GLUT_BITMAP_8_BY_13, *pcPos);
|
||||
pcPos++;
|
||||
}
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
void DrawStrings(void)
|
||||
{
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glPushMatrix();
|
||||
glLoadIdentity();
|
||||
gluOrtho2D(0.0, 100.0, 0.0, 100.0);
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glPushMatrix();
|
||||
glLoadIdentity();
|
||||
|
||||
glPushAttrib(GL_ENABLE_BIT);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glDisable(GL_LIGHTING);
|
||||
|
||||
glColor3fv(stafTextColor);
|
||||
|
||||
if(stbDisplayInfos)
|
||||
{
|
||||
stfX = 1.0f;
|
||||
stfY = 97.0f;
|
||||
|
||||
stiNbFrames++;
|
||||
stiEnd = clock();
|
||||
stfElapsed = (float)(stiEnd - stiStart) / CLOCKS_PER_SEC;
|
||||
if(stfElapsed >= 1.0)
|
||||
{
|
||||
stfFps = stiNbFrames/stfElapsed;
|
||||
stiStart = stiEnd;
|
||||
stiNbFrames = 0;
|
||||
}
|
||||
|
||||
PrintString("%.2f fps\n", stfFps);
|
||||
PrintString("Bounding box\n");
|
||||
A3DVector3dData& sMin = stsInfo.sBoundingBox.m_sMin;
|
||||
A3DVector3dData& sMax = stsInfo.sBoundingBox.m_sMax;
|
||||
PrintString(" Extent: [%.3f, %.3f, %.3f] -> [%.3f, %.3f, %.3f]\n", sMin.m_dX, sMin.m_dY, sMin.m_dZ,
|
||||
sMax.m_dX, sMax.m_dY, sMax.m_dZ);
|
||||
PrintString(" Radius: %.3f\n", stsInfo.dBoundingBoxRadius);
|
||||
}
|
||||
|
||||
if(stbDisplayHelp)
|
||||
{
|
||||
stfX = 1.0f;
|
||||
stfY = 70.0f;
|
||||
PrintString("HELP\n");
|
||||
PrintString(" MOUSE :\n");
|
||||
PrintString(" Left button: panning\n");
|
||||
PrintString(" Right button: zooming\n");
|
||||
PrintString("\n");
|
||||
PrintString(" KEYBOARD :\n");
|
||||
PrintString(" F1: print this help\n");
|
||||
PrintString(" F2: open a file (in the console)\n");
|
||||
PrintString(" F3: save file as Prc\n");
|
||||
PrintString(" F4: toggle display markups\n");
|
||||
PrintString(" F5: toggle full screen\n");
|
||||
PrintString(" F6: change background color\n");
|
||||
PrintString(" F11: toggle display information\n");
|
||||
PrintString(" PAGE_UP / PAGE_DOWN: change current sheet\n");
|
||||
}
|
||||
|
||||
glPopAttrib();
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glPopMatrix();
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glPopMatrix();
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
void Display(void)
|
||||
{
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glPushMatrix();
|
||||
{
|
||||
glLoadIdentity();
|
||||
|
||||
glLightfv(GL_LIGHT0, GL_POSITION, stafLightPosition);
|
||||
double dOffsetX = (stsInfo.sBoundingBox.m_sMax.m_dX-stsInfo.sBoundingBox.m_sMin.m_dX)/2. + stsInfo.sDelta.m_dX;
|
||||
double dOffsetY = (stsInfo.sBoundingBox.m_sMax.m_dY-stsInfo.sBoundingBox.m_sMin.m_dY)/2. + stsInfo.sDelta.m_dY;
|
||||
|
||||
glTranslated(dOffsetX, dOffsetY, 0.);
|
||||
|
||||
glScaled(stdZoom, stdZoom, 1.);
|
||||
|
||||
glTranslated(-dOffsetX, -dOffsetY, 0.);
|
||||
|
||||
glTranslated(-stsInfo.dBoundingBoxRadius*stdXPan, -stsInfo.dBoundingBoxRadius*stdYPan, 0);
|
||||
//-stsInfo.dBoundingBoxRadius*stdZoom);
|
||||
|
||||
if (st_aGLSheetDisplayList.size() > 0)
|
||||
{
|
||||
GLfloat afValues[3] = { 1, 1, 1 };
|
||||
glColor3fv(afValues);
|
||||
glCallList(st_aGLSheetDisplayList.at(size_t(st_CurrentSheetIndex)));
|
||||
}
|
||||
if (stbDisplayMarkups && st_aGLSheetMarkupDisplayList.size() > 0)
|
||||
{
|
||||
glCallList(st_aGLSheetMarkupDisplayList.at(size_t(st_CurrentSheetIndex)));
|
||||
}
|
||||
}
|
||||
glPopMatrix();
|
||||
|
||||
if(stbDisplayInfos || stbDisplayHelp)
|
||||
DrawStrings();
|
||||
|
||||
glFlush();
|
||||
glFinish();
|
||||
glutSwapBuffers();
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
static bool stbTBRunning = false;
|
||||
|
||||
//######################################################################################################################
|
||||
void MouseButton(int button, int state, GLsizei x, GLsizei y)
|
||||
{
|
||||
if(button == GLUT_LEFT_BUTTON)
|
||||
{
|
||||
if(state == GLUT_DOWN)
|
||||
stbLButtonDown = true;
|
||||
else if(state == GLUT_UP)
|
||||
stbLButtonDown = false;
|
||||
}
|
||||
else if(button == GLUT_RIGHT_BUTTON)
|
||||
{
|
||||
if(state == GLUT_DOWN)
|
||||
stbRButtonDown = true;
|
||||
else if(state == GLUT_UP)
|
||||
stbRButtonDown = false;
|
||||
}
|
||||
|
||||
if(!stbLButtonDown && !stbRButtonDown)
|
||||
glutSetCursor(GLUT_CURSOR_LEFT_ARROW);
|
||||
|
||||
eMotionType = KE_NONE;
|
||||
|
||||
if(stbLButtonDown)
|
||||
{
|
||||
if(stbTBRunning)
|
||||
tbMouse(GLUT_LEFT_BUTTON, GLUT_UP, x, y);
|
||||
eMotionType = KE_PANNING;
|
||||
glutSetCursor(GLUT_CURSOR_SPRAY);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(stbRButtonDown)
|
||||
{
|
||||
eMotionType = KE_ZOOMING;
|
||||
glutSetCursor(GLUT_CURSOR_UP_DOWN);
|
||||
}
|
||||
else
|
||||
{
|
||||
tbMouse(button, state, x, y);
|
||||
stbTBRunning = false;
|
||||
}
|
||||
}
|
||||
|
||||
stiXScreen = x;
|
||||
stiYScreen = y;
|
||||
|
||||
glutPostRedisplay();
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
void Motion(GLsizei x, GLsizei y)
|
||||
{
|
||||
tbMotion(x, y);
|
||||
|
||||
switch(eMotionType)
|
||||
{
|
||||
case KE_PANNING :
|
||||
{
|
||||
stdXPan -= (GLdouble)(x - stiXScreen)/(GLdouble)staiViewport[2] * 2.0 / stdZoom;
|
||||
stdYPan += (GLdouble)(y - stiYScreen)/(GLdouble)staiViewport[3] * 2.0 / stdZoom;
|
||||
break;
|
||||
}
|
||||
case KE_ZOOMING :
|
||||
{
|
||||
stdZoom += (GLdouble)(y - stiYScreen)/(GLdouble)staiViewport[3] * 10.0;
|
||||
if(stdZoom < 0.1)
|
||||
stdZoom = 0.1;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
stiXScreen = x;
|
||||
stiYScreen = y;
|
||||
|
||||
glutPostRedisplay();
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
A3DInt32 CloseFile()
|
||||
{
|
||||
A3DInt32 iRet = A3D_SUCCESS;
|
||||
|
||||
size_t uiList, uiNbList = st_aGLSheetDisplayList.size();
|
||||
for(uiList = 0; uiList < uiNbList; ++uiList)
|
||||
{
|
||||
glDeleteLists(st_aGLSheetDisplayList.back(), 1);
|
||||
st_aGLSheetDisplayList.pop_back();
|
||||
|
||||
glDeleteLists(st_aGLSheetMarkupDisplayList.back(), 1);
|
||||
st_aGLSheetMarkupDisplayList.pop_back();
|
||||
}
|
||||
|
||||
st_aGLSheetSize.clear();
|
||||
|
||||
glDeleteLists(stuiModelFileDisplayList, 1);
|
||||
glDeleteLists(stuiMarkupsDisplayList, 1);
|
||||
stuiModelFileDisplayList = stuiMarkupsDisplayList = 0;
|
||||
|
||||
return iRet;
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
A3DInt32 OpenFile(const A3DUTF8Char*pcCADFileName)
|
||||
{
|
||||
if(stpHOOPSExchangeLoader == NULL)
|
||||
return A3D_ERROR;
|
||||
|
||||
A3DImport sImport(pcCADFileName);
|
||||
sImport.m_sLoadData.m_sGeneral.m_eReadingMode2D3D = kA3DRead_Drawings;
|
||||
|
||||
A3DInt32 iRet = stpHOOPSExchangeLoader->Import(sImport);
|
||||
|
||||
printf("Done.\n");
|
||||
|
||||
return iRet;
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
A3DInt32 ProcessModelFile()
|
||||
{
|
||||
if(stpHOOPSExchangeLoader == NULL || stpHOOPSExchangeLoader->m_psModelFile == NULL)
|
||||
return A3D_ERROR;
|
||||
|
||||
// Collect all DrawingModels
|
||||
std::vector<A3DDrawingModel*> apDrawingModels;
|
||||
A3DInt32 iRet = CollectDrawing(stpHOOPSExchangeLoader->m_psModelFile, apDrawingModels);
|
||||
if(iRet != A3D_SUCCESS)
|
||||
return iRet;
|
||||
|
||||
if(apDrawingModels.size() == 0)
|
||||
return A3D_ERROR;
|
||||
|
||||
// Draws and stores all the sheets in list
|
||||
st_aGLSheetDisplayList.clear();
|
||||
size_t uiModel, uiNbModel = apDrawingModels.size();
|
||||
for(uiModel = 0; uiModel < uiNbModel; ++uiModel)
|
||||
{
|
||||
iRet = A3DDrawDrawing(apDrawingModels.at(uiModel), &stsDrawCallbacksData, st_aGLSheetDisplayList,
|
||||
&st_aGLSheetSize, false);
|
||||
if(iRet != A3D_SUCCESS)
|
||||
break;
|
||||
|
||||
iRet = A3DDrawDrawing(apDrawingModels.at(uiModel), &stsDrawCallbacksData, st_aGLSheetMarkupDisplayList,
|
||||
NULL, true);
|
||||
if(iRet != A3D_SUCCESS)
|
||||
break;
|
||||
}
|
||||
|
||||
if(iRet == A3D_SUCCESS && st_aGLSheetSize.size() > 0)
|
||||
{
|
||||
st_CurrentSheetIndex = 0;
|
||||
stsInfo.sBoundingBox.m_sMin.m_dX = 0.;
|
||||
stsInfo.sBoundingBox.m_sMin.m_dY = 0.;
|
||||
stsInfo.sBoundingBox.m_sMax.m_dX = st_aGLSheetSize[st_CurrentSheetIndex].m_dX;
|
||||
stsInfo.sBoundingBox.m_sMax.m_dY = st_aGLSheetSize[st_CurrentSheetIndex].m_dY;
|
||||
stsInfo.Calculate();
|
||||
}
|
||||
|
||||
stdZoom = 1.;
|
||||
stdXPan = 0.0;
|
||||
stdYPan = 0.0;
|
||||
|
||||
return iRet;
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
A3DInt32 SaveFileAsPrc()
|
||||
{
|
||||
A3DStatus iRet = A3D_SUCCESS;
|
||||
|
||||
if(stpHOOPSExchangeLoader->m_psModelFile != NULL)
|
||||
{
|
||||
PrintString("Enter file name in console\n");
|
||||
printf("Enter file name:\n");
|
||||
|
||||
A3DUTF8Char pcPRCFileName[_MAX_PATH];
|
||||
scanf("%s", pcPRCFileName);
|
||||
|
||||
A3DRWParamsExportPrcData sParamsExportData;
|
||||
A3D_INITIALIZE_DATA(A3DRWParamsExportPrcData, sParamsExportData);
|
||||
sParamsExportData.m_bCompressBrep = false;
|
||||
sParamsExportData.m_bCompressTessellation = false;
|
||||
|
||||
CHECK_RET(A3DAsmModelFileExportToPrcFile(stpHOOPSExchangeLoader->m_psModelFile, &sParamsExportData, pcPRCFileName, NULL));
|
||||
if(iRet == A3D_SUCCESS)
|
||||
printf("Done.\n");
|
||||
else
|
||||
printf("failure [%d]\n", iRet);
|
||||
}
|
||||
|
||||
return iRet;
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
void terminate2()
|
||||
{
|
||||
CloseFile();
|
||||
|
||||
delete stpHOOPSExchangeLoader;
|
||||
stpHOOPSExchangeLoader = NULL;
|
||||
ListLeaks();
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
void stChangeViewedSheet(bool bPrevious)
|
||||
{
|
||||
bool bChange = false;
|
||||
if(bPrevious)
|
||||
{
|
||||
if(st_CurrentSheetIndex > 0)
|
||||
{
|
||||
st_CurrentSheetIndex--;
|
||||
bChange = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(st_CurrentSheetIndex + 1 < unsigned(st_aGLSheetDisplayList.size()))
|
||||
{
|
||||
st_CurrentSheetIndex++;
|
||||
bChange = true;
|
||||
}
|
||||
}
|
||||
|
||||
if(bChange)
|
||||
{
|
||||
stsInfo.sBoundingBox.m_sMin.m_dX = 0.;
|
||||
stsInfo.sBoundingBox.m_sMin.m_dY = 0.;
|
||||
stsInfo.sBoundingBox.m_sMax.m_dX = st_aGLSheetSize[st_CurrentSheetIndex].m_dX;
|
||||
stsInfo.sBoundingBox.m_sMax.m_dY = st_aGLSheetSize[st_CurrentSheetIndex].m_dY;
|
||||
stsInfo.Calculate();
|
||||
|
||||
Reshape(staiWinSize[0], staiWinSize[1]);
|
||||
glutPostRedisplay();
|
||||
}
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
void Key(unsigned char key, int /* x */, int /* y */)
|
||||
{
|
||||
|
||||
switch(key)
|
||||
{
|
||||
case 27 :
|
||||
exit(0);
|
||||
|
||||
case GLUT_KEY_F1:
|
||||
stbDisplayHelp = !stbDisplayHelp;
|
||||
glutPostRedisplay();
|
||||
break;
|
||||
|
||||
case GLUT_KEY_F2:
|
||||
{
|
||||
A3DUTF8Char pcFilePath[_MAX_PATH];
|
||||
printf("\nFile path: ");
|
||||
scanf("%s", pcFilePath);
|
||||
|
||||
CloseFile();
|
||||
if (OpenFile(pcFilePath) == A3D_SUCCESS)
|
||||
{
|
||||
ProcessModelFile();
|
||||
Reshape(staiWinSize[0], staiWinSize[1]);
|
||||
}
|
||||
Display();
|
||||
}
|
||||
break;
|
||||
|
||||
case GLUT_KEY_F3:
|
||||
{
|
||||
SaveFileAsPrc();
|
||||
}
|
||||
break;
|
||||
|
||||
case GLUT_KEY_F4:
|
||||
stbDisplayMarkups = !stbDisplayMarkups;
|
||||
Reshape(staiWinSize[0], staiWinSize[1]);
|
||||
glutPostRedisplay();
|
||||
break;
|
||||
|
||||
case GLUT_KEY_F5:
|
||||
stbFullScreen = !stbFullScreen;
|
||||
if(stbFullScreen)
|
||||
glutFullScreen();
|
||||
else
|
||||
{
|
||||
glutPositionWindow(staiWinPosition[0], staiWinPosition[1]);
|
||||
glutReshapeWindow(staiWinSize[0], staiWinSize[1]);
|
||||
}
|
||||
break;
|
||||
|
||||
case GLUT_KEY_F6:
|
||||
{
|
||||
char pcNewColor[_MAX_PATH];
|
||||
printf("\nNew color (0xHHHHHH) : ");
|
||||
scanf("%s", pcNewColor);
|
||||
sscanf(pcNewColor, "%x", &stuiClearColor);
|
||||
glClearColor(HEX_TO_RED(stuiClearColor), HEX_TO_GREEN(stuiClearColor), HEX_TO_BLUE(stuiClearColor), 1.0f);
|
||||
glutPostRedisplay();
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case GLUT_KEY_F11:
|
||||
stbDisplayInfos = !stbDisplayInfos;
|
||||
glutPostRedisplay();
|
||||
break;
|
||||
|
||||
case GLUT_KEY_PAGE_UP:
|
||||
stChangeViewedSheet(true);
|
||||
break;
|
||||
|
||||
case GLUT_KEY_PAGE_DOWN:
|
||||
stChangeViewedSheet(false);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//######################################################################################################################
|
||||
void SpecialKey(int k, int x, int y)
|
||||
{
|
||||
Key((unsigned char) k, x, y);
|
||||
}
|
||||
|
||||
static MY_CHAR acSrcFileName[_MAX_PATH * 2];
|
||||
static MY_CHAR acLogFileName[_MAX_PATH * 2];
|
||||
|
||||
//######################################################################################################################
|
||||
// Main function
|
||||
#ifdef _MSC_VER
|
||||
int wmain(A3DInt32 iArgc, A3DUniChar** ppcArgv)
|
||||
#else
|
||||
int main(A3DInt32 iArgc, A3DUTF8Char** ppcArgv)
|
||||
#endif
|
||||
{
|
||||
//
|
||||
// ### COMMAND LINE ARGUMENTS
|
||||
//
|
||||
|
||||
if (iArgc > 4)
|
||||
{
|
||||
MY_PRINTF2("Usage:\n %s [input CATDrawing file] [Clear color value] [output LOG file]\n", ppcArgv[0]);
|
||||
MY_PRINTF(" Default output LOG file is [input CATDrawing file]_Log.txt\n\n");
|
||||
}
|
||||
|
||||
if (iArgc > 1) MY_STRCPY(acSrcFileName, ppcArgv[1]);
|
||||
else MY_STRCPY(acSrcFileName, DEFAULT_INPUT_DRAWING);
|
||||
if (iArgc > 2) MY_SSCANF(ppcArgv[2], "%x", &stuiClearColor);
|
||||
else stuiClearColor = 0xB2B2B2;
|
||||
if (iArgc > 3) MY_STRCPY(acLogFileName, ppcArgv[3]);
|
||||
else MY_SPRINTF(acLogFileName, "%s_Log.txt", acSrcFileName);
|
||||
GetLogFile(acLogFileName); // Initialize log file
|
||||
|
||||
//
|
||||
// ### INITIALIZE HOOPS EXCHANGE
|
||||
//
|
||||
|
||||
stpHOOPSExchangeLoader = new A3DSDKHOOPSExchangeLoader(_T(HOOPS_BINARY_DIRECTORY));
|
||||
if (stpHOOPSExchangeLoader->m_eSDKStatus != A3D_SUCCESS)
|
||||
{
|
||||
A3DStatus eSDKStatus = stpHOOPSExchangeLoader->m_eSDKStatus;
|
||||
delete stpHOOPSExchangeLoader;
|
||||
stpHOOPSExchangeLoader = NULL;
|
||||
return eSDKStatus;
|
||||
}
|
||||
|
||||
CHECK_RET(A3DDllSetCallbacksMemory(CheckMalloc, CheckFree));
|
||||
CHECK_RET(A3DDllSetCallbacksReport(PrintLogMessage, PrintLogWarning, PrintLogError));
|
||||
|
||||
//
|
||||
// ### PROCESS SAMPLE CODE
|
||||
//
|
||||
|
||||
A3DInt32 iRet = A3D_SUCCESS;
|
||||
glutInit((int*)(&iArgc), (char**)ppcArgv);
|
||||
GLsizei iScreenW = glutGet(GLUT_SCREEN_WIDTH);
|
||||
GLsizei iScreenH = glutGet(GLUT_SCREEN_HEIGHT);
|
||||
staiWinSize[0] = (GLsizei)((double)iScreenW * 0.7);
|
||||
staiWinSize[1] = (GLsizei)((double)iScreenH * 0.7);
|
||||
staiWinPosition[0] = (iScreenW - staiWinSize[0]) / 2;
|
||||
staiWinPosition[1] = (iScreenH - staiWinSize[1]) / 2;
|
||||
|
||||
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_STENCIL); // GLUT_DEPTH
|
||||
glutInitWindowPosition(staiWinPosition[0], staiWinPosition[1]);
|
||||
glutInitWindowSize(staiWinSize[0], staiWinSize[1]);
|
||||
|
||||
glutCreateWindow("A3DPRCDrawingViewerGL");
|
||||
glViewport(0, 0, staiWinSize[0], staiWinSize[1]);
|
||||
|
||||
tbInit(GLUT_LEFT_BUTTON);
|
||||
tbAnimate(stbTrackBallAnimate);
|
||||
|
||||
stsInfo.Init();
|
||||
stsInfo3D.Init();
|
||||
stsInfoMarkups.Init();
|
||||
|
||||
CHECK_RET(OpenGL_SetAndInitCallBack(stsDrawCallbacksData));
|
||||
|
||||
A3DUTF8Char sSrcFileNameUTF8[_MAX_PATH];
|
||||
#ifdef _MSC_VER
|
||||
A3DMiscUTF16ToUTF8(acSrcFileName, sSrcFileNameUTF8);
|
||||
#else
|
||||
MY_STRCPY(sSrcFileNameUTF8, acSrcFileName);
|
||||
#endif
|
||||
CHECK_RET_TERM(OpenFile(sSrcFileNameUTF8));
|
||||
|
||||
CHECK_RET_TERM(ProcessModelFile());
|
||||
|
||||
InitGL();
|
||||
|
||||
glutReshapeFunc(Reshape);
|
||||
glutDisplayFunc(Display);
|
||||
glutKeyboardFunc(Key);
|
||||
glutSpecialFunc(SpecialKey);
|
||||
glutMouseFunc(MouseButton);
|
||||
glutMotionFunc(Motion);
|
||||
glutIdleFunc(NULL);
|
||||
|
||||
printf("\nF1 for help\n");
|
||||
|
||||
// glut call exit(0) when closing windows, so set atexit to close properly dll
|
||||
atexit(terminate2);
|
||||
|
||||
glutMainLoop();
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user