开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
3dPointArray.cpp
资源名称：gloop.zip　[点击查看]
上传用户：shxiangxiu
上传日期：2007-01-03
资源大小：1101k
文件大小：10k
源码类别：

OpenGL

开发平台：

Visual C++

3dPointArray.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // 3dPointArray.cpp : implementation file
  3. //
  4. // glOOP (OpenGL Object Oriented Programming library)
  5. // Copyright (c) Craig Fahrnbach 1997, 1998
  6. //
  7. // OpenGL is a registered trademark of Silicon Graphics
  8. //
  9. //
  10. // This program is provided for educational and personal use only and
  11. // is provided without guarantee or warrantee expressed or implied.
  12. //
  13. // Commercial use is strickly prohibited without written permission
  14. // from ImageWare Development.
  15. //
  16. // This program is -not- in the public domain.
  17. //
  18. /////////////////////////////////////////////////////////////////////////////
  20. #include "stdafx.h"
  21. #include "glOOP.h"
  24. #ifdef _DEBUG
  25. #define new DEBUG_NEW
  26. #undef THIS_FILE
  27. static char THIS_FILE[] = __FILE__;
  28. #endif
  31. //////////////////////////////////////////////////////////////////
  32. // C3dPointArray
  33. IMPLEMENT_DYNAMIC(C3dPointArray, CObject)
  37. /////////////////////////////////////////////////////////////////////////////
  38. // C3dPointArray construction
  39. C3dPointArray::C3dPointArray()
  40. {
  41. // Initialize our data members
  42. m_hPoints = NULL;
  43. m_pPoints = NULL;
  44. m_iNumPoints = 0;
  45. }
  48. /////////////////////////////////////////////////////////////////////////////
  49. // C3dPointArray Destructor
  50. C3dPointArray::~C3dPointArray()
  51. {
  52. // Free our points array memory
  53. if(m_hPoints)
  54. {
  55. GlobalUnlock(m_hPoints);
  56. GlobalFree(m_hPoints);
  57. m_hPoints = NULL;
  58. m_pPoints = NULL;
  59. }
  60. }
  63. /////////////////////////////////////////////////////////////////////////////
  64. // C3dPointArray function implimentation
  66. BOOL C3dPointArray::Create(int iNumPoints)
  67. {
  68. if(!iNumPoints)
  69. return -1;
  71. m_iNumPoints = iNumPoints;
  72. m_hPoints = GlobalAlloc(GPTR, iNumPoints*sizeof(C3dPoint));
  73. if(m_hPoints == NULL) {
  74. AfxMessageBox("Not enought memory to create Point Array!", MB_OK, NULL);
  75. return(-1);
  76. }
  77. m_pPoints = (C3dPoint*)GlobalLock(m_hPoints);
  78. if(m_pPoints == NULL) {
  79. AfxMessageBox("Not enought memory to create Point Array!", MB_OK, NULL);
  80. GlobalFree(m_hPoints);
  81. m_hPoints = NULL;
  82. return(-1);
  83. }
  85. return 0;
  86. }
  88. BOOL C3dPointArray::SetArraySize(int iNumPoints)
  89. {
  90. if(!iNumPoints)
  91. return -1;
  93. // Unlock the memory handle
  94. GlobalUnlock(m_hPoints);
  96. // Reallocate the memory block
  97. m_hPoints = GlobalReAlloc(m_hPoints, iNumPoints*sizeof(C3dPoint), GMEM_MOVEABLE | GMEM_ZEROINIT);
  98. if(m_hPoints == NULL) {
  99. AfxMessageBox("Not enought memory to resize Point Array!", MB_OK, NULL);
  100. return(-1);
  101. }
  102. m_pPoints = (C3dPoint*)GlobalLock(m_hPoints);
  103. if(m_pPoints == NULL) {
  104. AfxMessageBox("Not enought memory to resize Point Array!", MB_OK, NULL);
  105. GlobalFree(m_hPoints);
  106. m_hPoints = NULL;
  107. return(-1);
  108. }
  110. // Save the number of points in our array
  111. m_iNumPoints = iNumPoints;
  113. return 0;
  114. }
  116. BOOL C3dPointArray::Add(float x, float y, float z)
  117. {
  118. // Unlock the memory handle
  119. GlobalUnlock(m_hPoints);
  121. // Reallocate the memory block
  122. m_hPoints = GlobalReAlloc(m_hPoints, (m_iNumPoints+1)*sizeof(C3dPoint), GMEM_MOVEABLE | GMEM_ZEROINIT);
  123. if(m_hPoints == NULL) {
  124. AfxMessageBox("Not enought memory to add Point to Point Array!", MB_OK, NULL);
  125. return(-1);
  126. }
  127. m_pPoints = (C3dPoint*)GlobalLock(m_hPoints);
  128. if(m_pPoints == NULL) {
  129. AfxMessageBox("Not enought memory to add Point to Point Array!", MB_OK, NULL);
  130. GlobalFree(m_hPoints);
  131. m_hPoints = NULL;
  132. return(-1);
  133. }
  135. // We sucessfully increased the size of the array, so add the point
  136. m_pPoints[m_iNumPoints].SetOrigin(x, y, z);
  138. // Increment the number of points in the array
  139. m_iNumPoints++;
  141. return 0;
  142. }
  144. BOOL C3dPointArray::CopyFromList(C3dPointList* pPointList)
  145. {
  146. ASSERT(pPointList);
  148. if(pPointList->GetCount() > m_iNumPoints)
  149. return FALSE;
  151. // Copy the points from the point list to our
  152. // members point/vertice array
  154. C3dPoint* pPoint = NULL;
  155. int iPoint = 0;
  156. // walk the list
  157. POSITION Pos = pPointList->GetHeadPosition();
  158. while (Pos) {
  159. pPoint = pPointList->GetAt(Pos);
  160. m_pPoints[iPoint].m_fOrigin[0] = pPoint->m_fOrigin[0];
  161. m_pPoints[iPoint].m_fOrigin[1] = pPoint->m_fOrigin[1];
  162. m_pPoints[iPoint].m_fOrigin[2] = pPoint->m_fOrigin[2];
  163. pPoint = pPointList->GetNext(Pos);
  164. ++iPoint;
  165. }
  167. return 0;
  168. }
  170. void C3dPointArray::Display(C3dWorld* pWorld, C3dCamera* pCamera, C3dObject* pObject, float fPointSize, BOOL bConnectPoints){
  171. GLfloat fPointColor[4]   = { 0.0f, 0.6f, 0.2f, 1.0f }; // Dark Green
  172. GLfloat fSelectedColor[4] = { 0.9f, 0.9f, 0.0f, 1.0f }; // Yellow
  173. GLfloat fLineColor[4]   = { 0.5f, 0.6f, 0.2f, 1.0f }; // Light Green
  174. GLfloat fLastOrigin[4];
  175. BOOL bMoreThanOnePoint = FALSE;
  177. VECTORF CameraPosn, PointPosn, CameraToPoint;
  178. float distance;
  179. GLfloat fRadius;
  180. Matx4x4 ObjXformMatrix;
  181. float fPointScale = fPointSize/.01f;
  184. // Transform the camera's origin to world coordinates
  185. Transformf(pCamera->m_fOrigin, CameraPosn, pCamera->m_dModelViewMatrix);
  187. // Get the objects transformation matrix.  We will use this to
  188. // transform each point in the array to world coordinates.
  189. pObject->GetTransformMatrix(ObjXformMatrix);
  192. // Disable lighting calculations
  193. glDisable(GL_LIGHTING);
  195. glLineWidth(2.0f);
  197. for(int i=0; i<m_iNumPoints; i++)
  198. {
  199. // Calculate the points world position
  200. VecTransformf(m_pPoints[i].m_fOrigin, PointPosn, ObjXformMatrix);
  202. // Subtract the cameras' world coordinate from the points's 
  203. // world coordinate, then calculate the distance between them.
  204. VecSubf(CameraPosn, PointPosn, CameraToPoint);
  205. distance = VecLenf(CameraToPoint);
  207. // Now that we have the distance between the camera and the point, 
  208. // calculate our points' radius.  (We don't want the point to
  209. // be too small or too large)
  210. fRadius = distance/fPointScale;
  212. if(pWorld->m_pSelectedPnt == &m_pPoints[i])
  213. m_pPoints[i].Display(fRadius, fSelectedColor, TRUE);
  214. else
  215. m_pPoints[i].Display(fRadius, fPointColor, TRUE);
  217. glColor4fv(fLineColor);
  219. if(bConnectPoints && bMoreThanOnePoint) {
  220. glBegin(GL_LINES);
  221. glVertex3fv(fLastOrigin);
  222. glVertex3fv(m_pPoints[i].m_fOrigin);
  223. glEnd();
  224. }
  226. fLastOrigin[0] = m_pPoints[i].m_fOrigin[0];
  227. fLastOrigin[1] = m_pPoints[i].m_fOrigin[1];
  228. fLastOrigin[2] = m_pPoints[i].m_fOrigin[2];
  229. fLastOrigin[3] = m_pPoints[i].m_fOrigin[3];
  231. bMoreThanOnePoint = TRUE;
  232. }
  234. // Enable lighting calculations
  235. glEnable(GL_LIGHTING);
  237. glLineWidth(1.0f);
  238. }
  240. C3dPoint* C3dPointArray::Find(C3dCamera* pCamera, C3dObject* pObject, 
  241.   float x, float y, float z)
  242. {
  243. static C3dPoint* pLastPoint = NULL;
  244. BOOL bFoundMatch = FALSE;
  245. Matx4x4 ObjXformMatrix;
  247. // Get the objects transformation matrix.  We will use this to
  248. // transform each point in the array to world coordinates.
  249. pObject->GetTransformMatrix(ObjXformMatrix);
  251. // Search the array of C3dPoints to find a match
  252. for(int i=0; i<m_iNumPoints; i++)
  253. {
  254. if(m_pPoints[i].IsPoint(pCamera, ObjXformMatrix, x, y, z))
  255. {
  256. bFoundMatch = TRUE;
  257. if(&m_pPoints[i] != pLastPoint)
  258. {
  259. pLastPoint = &m_pPoints[i];
  260. return &m_pPoints[i];
  261. }
  262. }
  263. }
  265. // We found only one point in the array matching the xyz value
  266. if(bFoundMatch)
  267. return pLastPoint;
  269. return NULL;
  270. }
  272. void C3dPointArray::GetMinMax(C3dBoundingBox* pBox)
  273. {
  274. C3dPoint* pPoint;
  276. // Set to large positive number
  277. pBox->m_fMin[X] = (GLfloat)LARGE_NUMBER;
  278. pBox->m_fMin[Y] = (GLfloat)LARGE_NUMBER;
  279. pBox->m_fMin[Z] = (GLfloat)LARGE_NUMBER;
  281. // Set to large negative number
  282. pBox->m_fMax[X] = -(GLfloat)LARGE_NUMBER;
  283. pBox->m_fMax[Y] = -(GLfloat)LARGE_NUMBER;
  284. pBox->m_fMax[Z] = -(GLfloat)LARGE_NUMBER;
  287. // Search through the array to find the min/max
  288. // object coordinates
  289. for(int i=0; i<m_iNumPoints; i++)
  290. {
  291. pPoint = &m_pPoints[i];
  293. if(pPoint->m_fOrigin[X] > pBox->m_fMax[X])
  294. pBox->m_fMax[X] = pPoint->m_fOrigin[X];
  296. if(pPoint->m_fOrigin[Y] > pBox->m_fMax[Y])
  297. pBox->m_fMax[Y] = pPoint->m_fOrigin[Y];
  299. if(pPoint->m_fOrigin[Z] > pBox->m_fMax[Z])
  300. pBox->m_fMax[Z] = pPoint->m_fOrigin[Z];
  303. if(pPoint->m_fOrigin[X] < pBox->m_fMin[X])
  304. pBox->m_fMin[X] = pPoint->m_fOrigin[X];
  306. if(pPoint->m_fOrigin[Y] < pBox->m_fMin[Y])
  307. pBox->m_fMin[Y] = pPoint->m_fOrigin[Y];
  309. if(pPoint->m_fOrigin[Z] < pBox->m_fMin[Z])
  310. pBox->m_fMin[Z] = pPoint->m_fOrigin[Z];
  311. }
  312. }
  314. void C3dPointArray::Serialize(CArchive& ar, int iVersion, BOOL bReadColorData)
  315. {
  316. CString szBuffer;
  317. int i;
  319. if (ar.IsStoring())
  320. {
  321. for(i=0; i<m_iNumPoints; i++)
  322. {
  323. szBuffer.Format("%stt        < %f, %f, %f >n", szIndent, m_pPoints[i].m_fOrigin[0],
  324. m_pPoints[i].m_fOrigin[1],
  325. m_pPoints[i].m_fOrigin[2]);
  326. ar.WriteString(szBuffer);
  327. }
  328. if(bReadColorData)
  329. {
  330. szBuffer.Format("%st[color]n", szIndent);
  331. ar.WriteString(szBuffer);
  332. for(i=0; i<m_iNumPoints; i++)
  333. {
  334. szBuffer.Format("%stt        < %f, %f, %f, %f >n", szIndent, m_pPoints[i].m_Color.m_fColor[0],
  335. m_pPoints[i].m_Color.m_fColor[1],
  336. m_pPoints[i].m_Color.m_fColor[2],
  337. m_pPoints[i].m_Color.m_fColor[3]);
  338. ar.WriteString(szBuffer);
  339. }
  340. }
  341. }
  342. else
  343. {
  344. // Read the shape vertice, or point data
  345. for(i=0; i<m_iNumPoints; i++)
  346. {
  347. ar.ReadString(szBuffer);
  348. szBuffer.TrimLeft();
  349. sscanf(szBuffer, "< %f, %f, %f >n", &m_pPoints[i].m_fOrigin[X],
  350.  &m_pPoints[i].m_fOrigin[Y],
  351.  &m_pPoints[i].m_fOrigin[Z]);
  352. }
  353. if(iVersion > 110 && bReadColorData)
  354. {
  355. ar.ReadString(szBuffer); // [color] header
  357. // Read the shape vertice, or point data
  358. for(int i=0; i<m_iNumPoints; i++)
  359. {
  360. ar.ReadString(szBuffer);
  361. szBuffer.TrimLeft();
  362. sscanf(szBuffer, "< %f, %f, %f, %f >n", &m_pPoints[i].m_Color.m_fColor[0],
  363.  &m_pPoints[i].m_Color.m_fColor[1],
  364.  &m_pPoints[i].m_Color.m_fColor[2],
  365.  &m_pPoints[i].m_Color.m_fColor[3]);
  366. }
  367. }
  368. }
  369. }