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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
PLASMAOB.CXX
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：25k
源码类别：

Windows编程

开发平台：

Visual C++

PLASMAOB.CXX：源码内容
  1. //+---------------------------------------------------------------------------
  2. //
  3. //  Microsoft Windows
  4. //  Copyright 1992 - 1997 Microsoft Corporation.
  5. //
  6. //  File:       plasmaob.cxx
  7. //
  8. //  Contents:   Plasma Fractal engine object
  9. //
  10. //  Classes:    CPlasma
  11. //
  12. //  Functions:  StartGraphicsThread
  13. //              Normalize
  14. //
  15. //  History:    4-23-94   stevebl   Created
  16. //
  17. //----------------------------------------------------------------------------
  19. #include <windows.h>
  20. #include <ole2.h>
  21. #include <plasmcid.h>
  22. #include "plasma.h"
  23. #include <stdio.h>
  24. #include <strmhelp.h>
  25. #include <palsize.h>
  26. #include <math.h>
  28. #define MAX_RANDOM 50.0
  29. #define MIN_RANDOM 0
  31. //+---------------------------------------------------------------------------
  32. //
  33. //  Function:   StartGraphicsThread
  34. //
  35. //  Synopsis:   Global function used to bootstrap into the GraphicsThread
  36. //              member of the CPlasma class.
  37. //
  38. //  Arguments:  [lpdwParam] - not used
  39. //
  40. //  History:    4-15-94   stevebl   Created
  41. //
  42. //----------------------------------------------------------------------------
  44. DWORD StartGraphicsThread(LPDWORD lpdwParam)
  45. {
  46.     return (((CPlasma *)lpdwParam)->GraphicsThread());
  47. }
  50. //+---------------------------------------------------------------------------
  51. //
  52. //  Member:     CPlasma::QueryInterface
  53. //
  54. //  Synopsis:   standard OLE method
  55. //
  56. //  Arguments:  [riid] - id of desired interface
  57. //              [ppv]  - pointer to receive interface
  58. //
  59. //  Returns:    S_OK on success
  60. //              E_NOINTERFACE if the requested interface isn't supported
  61. //
  62. //  History:    4-23-94   stevebl   Created
  63. //
  64. //----------------------------------------------------------------------------
  66. HRESULT STDMETHODCALLTYPE CPlasma::QueryInterface(REFIID riid, LPVOID * ppv)
  67. {
  68.     *ppv = NULL;
  69.     if (IsEqualGUID(IID_IFractalEngine, riid))
  70.     {
  71.         *ppv = (IFractalEngine *)this;
  72.     }
  73.     else if (IsEqualGUID(IID_IPersist, riid))
  74.     {
  75.         *ppv = (IPersist *)this;
  76.     }
  77.     else if (IsEqualGUID(IID_IPersistStream, riid))
  78.     {
  79.         *ppv = (IPersistStream *)this;
  80.     }
  81.     else if (IsEqualGUID(IID_IUnknown, riid))
  82.     {
  83.         *ppv = (IUnknown *)(IFractalEngine *)this;
  84.     }
  85.     if (*ppv)
  86.     {
  87.         ((IUnknown *)*ppv)->AddRef();
  88.         return(S_OK);
  89.     }
  90.     return(E_NOINTERFACE);
  91. }
  93. //+---------------------------------------------------------------------------
  94. //
  95. //  Member:     CPlasma::AddRef
  96. //
  97. //  Synopsis:   increments the reference count
  98. //
  99. //  Returns:    new reference count
  100. //
  101. //  History:    4-23-94   stevebl   Created
  102. //
  103. //----------------------------------------------------------------------------
  105. ULONG STDMETHODCALLTYPE CPlasma::AddRef(void)
  106. {
  107.     return(++_cRef);
  108. }
  110. //+---------------------------------------------------------------------------
  111. //
  112. //  Member:     CPlasma::Release
  113. //
  114. //  Synopsis:   decrements the reference count
  115. //
  116. //  Returns:    new reference count
  117. //
  118. //  History:    4-23-94   stevebl   Created
  119. //
  120. //----------------------------------------------------------------------------
  122. ULONG STDMETHODCALLTYPE CPlasma::Release(void)
  123. {
  124.     ULONG cRef = --_cRef;
  125.     if (0 == cRef)
  126.     {
  127.         delete this;
  128.         gcRef--;
  129.     }
  130.     return(cRef);
  131. }
  133. // IPersist methods
  135. //+---------------------------------------------------------------------------
  136. //
  137. //  Member:     CPlasma::GetClassID
  138. //
  139. //  Synopsis:   returns the object's class ID
  140. //
  141. //  Arguments:  [pclsid] - pointer to recieve the class ID
  142. //
  143. //  Returns:    S_OK
  144. //
  145. //  History:    4-23-94   stevebl   Created
  146. //
  147. //----------------------------------------------------------------------------
  149. HRESULT CPlasma::GetClassID(LPCLSID pclsid)
  150. {
  151.     memcpy(pclsid, &CLSID_PLASMA, sizeof(GUID));
  152.     return(S_OK);
  153. }
  155. // IPersistStream methods
  157. //+---------------------------------------------------------------------------
  158. //
  159. //  Member:     CPlasma::IsDirty
  160. //
  161. //  Synopsis:   used to determine if the state of the object has changed
  162. //
  163. //  Returns:    S_OK if it is dirty
  164. //              S_FALSE if it is not dirty
  165. //
  166. //  History:    4-23-94   stevebl   Created
  167. //
  168. //----------------------------------------------------------------------------
  170. HRESULT CPlasma::IsDirty(void)
  171. {
  172.     if (_fDirty)
  173.     {
  174.         return(S_OK);
  175.     }
  176.     else
  177.     {
  178.         return(S_FALSE);
  179.     }
  180. }
  182. //+---------------------------------------------------------------------------
  183. //
  184. //  Member:     CPlasma::Load
  185. //
  186. //  Synopsis:   loads the fractal properties from a stream
  187. //
  188. //  Arguments:  [pStm] - pointer to an IStream interface
  189. //
  190. //  Returns:    S_OK on success
  191. //              E_FAIL on error
  192. //              E_OUTOFMEMORY if there's not enough memory (can't happen here)
  193. //
  194. //  History:    4-23-94   stevebl   Created
  195. //
  196. //----------------------------------------------------------------------------
  198. HRESULT CPlasma::Load(LPSTREAM pStm)
  199. {
  200.     if (WAIT_OBJECT_0 == WaitForSingleObject(_hRunning, 0))
  201.     {
  202.         return(E_FAIL);
  203.     }
  204.     HRESULT hr;
  205.     if (FAILED(hr = ReadDouble(pStm, &_dRandomnessFactor, NULL)))
  206.     {
  207.         return(hr);
  208.     }
  209.     _fDirty = FALSE;
  210.     return(S_OK);
  211. }
  213. //+---------------------------------------------------------------------------
  214. //
  215. //  Member:     CPlasma::Save
  216. //
  217. //  Synopsis:   saves the fractal properties to a stream
  218. //
  219. //  Arguments:  [pStm]        - pointer to an IStream interface
  220. //              [fClearDirty] - TRUE if the dirty flag should be cleared
  221. //
  222. //  Returns:    S_OK on success
  223. //
  224. //  History:    4-23-94   stevebl   Created
  225. //
  226. //----------------------------------------------------------------------------
  228. HRESULT CPlasma::Save(LPSTREAM pStm, BOOL fClearDirty)
  229. {
  230.     if (WAIT_OBJECT_0 == WaitForSingleObject(_hRunning, 0))
  231.     {
  232.         return(E_FAIL);
  233.     }
  234.     HRESULT hr;
  235.     if (FAILED(hr = WriteDouble(pStm, _dRandomnessFactor, NULL)))
  236.     {
  237.         return(hr);
  238.     }
  239.     if (fClearDirty)
  240.     {
  241.         _fDirty = FALSE;
  242.     }
  243.     return(S_OK);
  244. }
  246. //+---------------------------------------------------------------------------
  247. //
  248. //  Member:     CPlasma::GetSizeMax
  249. //
  250. //  Synopsis:   used to determine the maximum size of the object's data
  251. //
  252. //  Arguments:  [pcbSize] - pointer to recieve the max size
  253. //
  254. //  Returns:    S_OK
  255. //
  256. //  History:    4-23-94   stevebl   Created
  257. //
  258. //----------------------------------------------------------------------------
  260. HRESULT CPlasma::GetSizeMax(ULARGE_INTEGER * pcbSize)
  261. {
  262.     pcbSize->HighPart = 0;
  263.     pcbSize->LowPart = SizeDouble();
  264.     return(S_OK);
  265. }
  267. // IFractalEngine methods
  269. //+---------------------------------------------------------------------------
  270. //
  271. //  Member:     CPlasma::Init
  272. //
  273. //  Synopsis:   Initializes the graph engine and saves a pointer to the
  274. //              IFractalHost interface that WinFract passes in as
  275. //              the engine is initialized.
  276. //
  277. //  Arguments:  [pfh] - pointer to an IFractalHost interface
  278. //
  279. //  Returns:    S_OK
  280. //
  281. //  History:    4-23-94   stevebl   Created
  282. //
  283. //----------------------------------------------------------------------------
  285. HRESULT STDMETHODCALLTYPE CPlasma::Init(IFractalHost *pfh)
  286. {
  287.     _pfh = pfh;
  288.     // NOTE that I don't addref this pointer!  That would create a circular
  289.     // reference count paradox.
  290.     return(S_OK);
  291. }
  293. //+---------------------------------------------------------------------------
  294. //
  295. //  Member:     CPlasma::SetDefaults
  296. //
  297. //  Synopsis:   initializes the graph engine with its default values
  298. //
  299. //  Returns:    S_OK
  300. //
  301. //  History:    4-23-94   stevebl   Created
  302. //
  303. //----------------------------------------------------------------------------
  305. HRESULT STDMETHODCALLTYPE CPlasma::SetDefaults(void)
  306. {
  307.     _dRandomnessFactor = 2.0;
  308.     _fDirty = TRUE;
  309.     SetEvent(_hRestart);
  310.     return(S_OK);
  311. }
  313. //+---------------------------------------------------------------------------
  314. //
  315. //  Member:     CPlasma::SetProperties
  316. //
  317. //  Synopsis:   Displays the graph engine's property dialog box.
  318. //
  319. //  Arguments:  [hwnd] - handle to the parent window
  320. //
  321. //  Returns:    S_OK
  322. //
  323. //  History:    4-23-94   stevebl   Created
  324. //
  325. //----------------------------------------------------------------------------
  327. HRESULT STDMETHODCALLTYPE CPlasma::SetProperties(HWND hwnd)
  328. {
  329.     ShowDialog(ghinst, MAKEINTRESOURCE(PROPERTIES), hwnd);
  330.     return(S_OK);
  331. }
  333. //+---------------------------------------------------------------------------
  334. //
  335. //  Member:     CPlasma::GetExtent
  336. //
  337. //  Synopsis:   retrieves the extent of the graph
  338. //
  339. //  Arguments:  [pdLeft]   - x value at the left of the graph
  340. //              [pdTop]    - y value at the top of the graph
  341. //              [pdRight]  - x value at the right of the graph
  342. //              [pdBottom] - y value at the bottom of the graph
  343. //
  344. //  Returns:    S_OK
  345. //
  346. //  History:    4-23-94   stevebl   Created
  347. //
  348. //----------------------------------------------------------------------------
  350. HRESULT STDMETHODCALLTYPE CPlasma::GetExtent(
  351.     double *pdLeft,
  352.     double *pdTop,
  353.     double *pdRight,
  354.     double *pdBottom)
  355. {
  356.     *pdLeft = -1.0;
  357.     *pdTop = 1.0;
  358.     *pdRight = 1.0;
  359.     *pdBottom = -1.0;
  360.     return(S_OK);
  361. }
  363. //+---------------------------------------------------------------------------
  364. //
  365. //  Member:     CPlasma::SetExtent
  366. //
  367. //  Synopsis:   sets the graph's extent
  368. //
  369. //  Arguments:  [dLeft]   - x value at the left of the graph
  370. //              [dTop]    - y value at the top of the graph
  371. //              [dRight]  - x value at the right of the graph
  372. //              [dBottom] - y value at the bottom of the graph
  373. //
  374. //  Returns:    S_OK - extents set
  375. //              E_FAIL - the graph was running so the extents couldn't be set
  376. //
  377. //  History:    4-23-94   stevebl   Created
  378. //
  379. //----------------------------------------------------------------------------
  381. HRESULT STDMETHODCALLTYPE CPlasma::SetExtent(
  382.     double dLeft,
  383.     double dTop,
  384.     double dRight,
  385.     double dBottom)
  386. {
  387.     if (WAIT_OBJECT_0 == WaitForSingleObject(_hRunning, 0))
  388.     {
  389.         return(E_FAIL);
  390.     }
  391.     _fDirty = TRUE;
  392.     SetEvent(_hRestart);
  393.     return(S_OK);
  394. }
  396. //+---------------------------------------------------------------------------
  397. //
  398. //  Member:     CPlasma::SetGraphSize
  399. //
  400. //  Synopsis:   Tells the graph engine how big the graph is
  401. //
  402. //  Arguments:  [uWidth]  - width of graph (in pixels)
  403. //              [uHeight] - height of graph (in pixels)
  404. //
  405. //  Returns:    S_OK - success
  406. //              E_FAIL - the graph was running or a value was illegal
  407. //
  408. //  History:    4-23-94   stevebl   Created
  409. //
  410. //----------------------------------------------------------------------------
  412. HRESULT STDMETHODCALLTYPE CPlasma::SetGraphSize(
  413.     unsigned int uWidth,
  414.     unsigned int uHeight)
  415. {
  416.     if (WAIT_OBJECT_0 == WaitForSingleObject(_hRunning, 0))
  417.     {
  418.         return(E_FAIL);
  419.     }
  420.     if (uWidth == 0 || uHeight == 0)
  421.     {
  422.         return(E_FAIL);
  423.     }
  424.     _uWidth = uWidth;
  425.     _uHeight = uHeight;
  426.     SetEvent(_hRestart);
  427.     return(S_OK);
  428. }
  430. //+---------------------------------------------------------------------------
  431. //
  432. //  Member:     CPlasma::Start
  433. //
  434. //  Synopsis:   starts the graph engine
  435. //
  436. //  Returns:    S_OK on success
  437. //
  438. //  History:    4-23-94   stevebl   Created
  439. //
  440. //----------------------------------------------------------------------------
  442. HRESULT STDMETHODCALLTYPE CPlasma::Start(void)
  443. {
  444.     SetEvent(_hRunning);
  445.     return(S_OK);
  446. }
  448. //+---------------------------------------------------------------------------
  449. //
  450. //  Member:     CPlasma::Stop
  451. //
  452. //  Synopsis:   stops the graph engine
  453. //
  454. //  Returns:    S_OK on success
  455. //
  456. //  History:    4-23-94   stevebl   Created
  457. //
  458. //----------------------------------------------------------------------------
  460. HRESULT STDMETHODCALLTYPE CPlasma::Stop(void)
  461. {
  462.     ResetEvent(_hRunning);
  463.     return(S_OK);
  464. }
  466. // Methods that aren't part of any interface
  468. //+---------------------------------------------------------------------------
  469. //
  470. //  Member:     CPlasma::Initialize
  471. //
  472. //  Synopsis:   called by the clas factory to initialize the object
  473. //
  474. //  Returns:    TRUE on success
  475. //              FALSE if the object couldn't be initialized
  476. //
  477. //  History:    4-23-94   stevebl   Created
  478. //
  479. //----------------------------------------------------------------------------
  481. BOOL CPlasma::Initialize(void)
  482. {
  483.     _hRestart = CreateEvent(
  484.         NULL,
  485.         TRUE,   // must be manually reset
  486.         TRUE,   // initially signaled
  487.         NULL);
  488.     if (_hRestart == NULL)
  489.     {
  490.         return(FALSE);  // couldn't create an event
  491.     }
  492.     _hRunning = CreateEvent(
  493.         NULL,
  494.         TRUE,
  495.         FALSE,
  496.         NULL);
  497.     if (_hRunning == NULL)
  498.     {
  499.         return(FALSE);
  500.     }
  501.     _hEngine = CreateThread(
  502.         (LPSECURITY_ATTRIBUTES)NULL,
  503.         0,
  504.         (LPTHREAD_START_ROUTINE) StartGraphicsThread,
  505.         this,
  506.         0,
  507.         &_dwThreadId);
  508.     if (_hEngine == NULL)
  509.     {
  510.         return(FALSE);  // couldn't start the graphics thread
  511.     }
  512.     return(TRUE);
  513. }
  515. //+---------------------------------------------------------------------------
  516. //
  517. //  Member:     CPlasma::GraphicsThread
  518. //
  519. //  Synopsis:   main entry point for the engine's graphics thread
  520. //
  521. //  History:    4-23-94   stevebl   Created
  522. //
  523. //  Notes:      This routine enters into an eternal loop.  It will continue
  524. //              looping until the class is destroyed at which point this
  525. //              thread will be simply terminated.
  526. //
  527. //  Algorithm:  Wait for the engine to be started.
  528. //              Clear the graph.
  529. //              Plot the points at the graph's four corners.
  530. //              Divide it into four quadrants and call Subdivide for each.
  531. //              After falling out of the recursion, check to see if the
  532. //              graph has been aborted.
  533. //              If not, notify that the graph has been completed.
  534. //              Loop back around to the beginning.
  535. //
  536. //----------------------------------------------------------------------------
  537. DWORD CPlasma::GraphicsThread(void)
  538. {
  539.     do
  540.     {
  541.         // wait here until someone starts the graphics engine
  542.         WaitForSingleObject(_hRunning, INFINITE);
  544.         // reset the _hRestart event so that we won't immediately fall out
  545.         // of the engine
  546.         ResetEvent(_hRestart);
  548.         // Now begin drawing the graph
  550.         // erase the background
  551.         _pfh->Rect(0, 0, (int) _uWidth - 1, (int) _uHeight - 1, 0);
  553.         // Seed the random number generator
  554.         srand((UINT)GetTickCount());
  556.         // plot the upper corner
  557.         _pfh->Point(0, 0, rand() % (PALETTESIZE -1 ));
  559.         // begin the recursion
  560.         Subdivide(0, 0, (int) _uWidth, (int) _uHeight);
  562.         // We're either done drawing the graph now or we have been restarted
  563.         if (WAIT_TIMEOUT == WaitForSingleObject(_hRestart, 0))
  564.         {
  565.             // Tell our clients that we're finished
  566.             _pfh->DoneDrawingGraph();
  567.             ResetEvent(_hRunning);
  568.         }
  569.     } while (TRUE);
  570.     return(0);
  571. }
  573. //+---------------------------------------------------------------------------
  574. //
  575. //  Function:   Normalize
  576. //
  577. //  Synopsis:   Makes sure that the value is within the legal color set.
  578. //
  579. //  Arguments:  [iTemp] - color index value
  580. //
  581. //  Returns:    0 <= iTemp < (PALETTESIZE - 1)
  582. //
  583. //  History:    4-28-94   stevebl   Created
  584. //
  585. //  Notes:      There are a couple ways this could be achieved, most of them
  586. //              are undesirable.
  587. //
  588. //              For instance, we could just perform a modulus operation on
  589. //              the value:
  590. //
  591. //                  iTemp = iTemp % (PALETTESIZE - 1)
  592. //
  593. //              This would have the effect of causing numbers to wrap
  594. //              around (PALETTESIZE - 1 would become 0).  This would be bad because
  595. //              in order for the graph to look good we want all the points to
  596. //              transition as smoothley as possible.  Doing it this way
  597. //              would cause the graph to have an area where the elevation
  598. //              suddenly changed dramaticaly when it should have been very
  599. //              smooth.
  600. //
  601. //              Another option would be to just truncate the value:
  602. //
  603. //              if (iTemp) > PALETTESIZE - 2) iTemp = PALETTESIZE - 2
  604. //
  605. //              This would cause our graph to have areas where it is
  606. //              artificially flat.
  607. //
  608. //              Instead, this routine reflects the value back down into a
  609. //              range of values.  For every unit the value is over
  610. //              PALETTESIZE - 2, it is made to be that many units under
  611. //              PALETTESIZE - 1.  This avoids both sudden elevation changes
  612. //              and flat spots.
  613. //
  614. //----------------------------------------------------------------------------
  616. inline void Normalize(int & iTemp)
  617. {
  618.     while (iTemp < 0 || iTemp >= PALETTESIZE - 1)
  619.     {
  620.         if (iTemp < 0)
  621.         {
  622.             iTemp = 0 - iTemp;
  623.         }
  624.         else
  625.         {
  626.             iTemp = ((PALETTESIZE - 1) * 2) - (iTemp + 1);
  627.         }
  628.     }
  629. }
  631. //+---------------------------------------------------------------------------
  632. //
  633. //  Member:     CPlasma::Subdivide
  634. //
  635. //  Synopsis:   recurses into  a rectangle
  636. //
  637. //  Arguments:  [xl] - left side
  638. //              [yl] - top side
  639. //              [xh] - right side
  640. //              [yh] - bottom side
  641. //
  642. //  Returns:    nothing
  643. //
  644. //  History:    4-25-94   stevebl   Created
  645. //
  646. //  Notes:      Each ittertation is responsible for drawing the
  647. //              points marked X below if the haven't already been drawn.
  648. //              The O's are points drawn by previous ittertations.
  649. //              The .'s represent points to be drawn by future itterations.
  650. //
  651. //              O . . . . . X . . . . . O
  652. //              . . . . . . . . . . . . .
  653. //              . . . . . . . . . . . . .
  654. //              . . . . . . . . . . . . .
  655. //              . . . . . . . . . . . . .
  656. //              . . . . . . . . . . . . .
  657. //              X . . . . . X . . . . . X
  658. //              . . . . . . . . . . . . .
  659. //              . . . . . . . . . . . . .
  660. //              . . . . . . . . . . . . .
  661. //              . . . . . . . . . . . . .
  662. //              . . . . . . . . . . . . .
  663. //              O . . . . . X . . . . . O
  664. //
  665. //              Once the routine has plotted its points, it divides
  666. //              the graph into quarters and calls itself
  667. //              for each quarter.
  668. //
  669. //              Since the graph is erased to color 0 before itterations are
  670. //              begun, testing if a point has already been plotted is simple:
  671. //              if the point contians color 0 then it hasn't been plotted yet.
  672. //
  673. //----------------------------------------------------------------------------
  675. void CPlasma::Subdivide(int xl, int yl, int xh, int yh)
  676. {
  677.     if (WAIT_TIMEOUT == WaitForSingleObject(_hRestart, 0))
  678.     {
  679.         WaitForSingleObject(_hRunning, INFINITE);
  680.         // find the midpoints
  681.         int iMidX = (xh + xl) / 2;
  682.         int iMidY = (yh + yl) / 2;
  684.         // find the four corner colors
  685.         unsigned char cTL, cTR, cBL, cBR;
  686.         unsigned uTemp;
  687.         _pfh->GetPoint(&uTemp, xl, yl);
  688.         cTL = uTemp - 1;
  689.         _pfh->GetPoint(&uTemp, xh % _uWidth, yl);
  690.         cTR = uTemp - 1;
  691.         _pfh->GetPoint(&uTemp, xl, yh % _uHeight);
  692.         cBL = uTemp - 1;
  693.         _pfh->GetPoint(&uTemp, xh % _uWidth, yh % _uHeight);
  694.         cBR = uTemp - 1;
  695.         int cTM, cLM, cRM, cBM;
  697.         unsigned uSpread = (unsigned)((xh - xl) * _dRandomnessFactor);
  699.         // choose the top point
  700.         _pfh->GetPoint(&uTemp, iMidX, yl);
  701.         if (0 == uTemp)
  702.         {
  703.             cTM = (rand() % (uSpread * 2 + 1)) - uSpread;
  704.             cTM += (cTL + cTR) / 2;
  705.             Normalize(cTM);
  706.             _pfh->Point(iMidX, yl, cTM + 1);
  707.         }
  709.         // choose the bottom point
  710.         _pfh->GetPoint(&uTemp, iMidX, yh % _uHeight);
  711.         if (0 == uTemp)
  712.         {
  713.             cBM = (rand() % (uSpread * 2 + 1)) - uSpread;
  714.             cBM += (cBL + cBR) / 2;
  715.             Normalize(cBM);
  716.             // Don't need to use yh % _uHeight here because the only
  717.             // way we can get here is if yh < _uHeight.
  718.             _pfh->Point(iMidX, yh, cBM + 1);
  719.         }
  721.         uSpread = (unsigned)((yh - yl) * _dRandomnessFactor);
  723.         // choose the left point
  724.         _pfh->GetPoint(&uTemp,xl, iMidY);
  725.         if (0 == uTemp)
  726.         {
  727.             cLM = (rand() % (uSpread * 2 + 1)) - uSpread;
  728.             cLM += (cTL + cBL) / 2;
  729.             Normalize(cLM);
  730.             _pfh->Point(xl, iMidY, cLM + 1);
  731.         }
  733.         // choose the right point
  734.         _pfh->GetPoint(&uTemp, xh % _uWidth, iMidY);
  735.         if (0 == uTemp)
  736.         {
  737.             cRM = (rand() % (uSpread * 2 + 1)) - uSpread;
  738.             cRM += (cTR + cBR) / 2;
  739.             Normalize(cRM);
  740.             // Don't need to use xh % _uWidth here because the only
  741.             // way we can get here is if xh < _uWidth.
  742.             _pfh->Point(xh, iMidY, cRM + 1);
  743.         }
  745.         _pfh->GetPoint(&uTemp, iMidX, iMidY);
  746.         if (0 == uTemp)
  747.         {
  748.             // choose the center point
  749.             uSpread = (unsigned)((sqrt(((float)(xh - xl) * (xh - xl) + (yh - yl) * (yh - yl))) / 2) * _dRandomnessFactor);
  750.             int cC = (rand() % (uSpread * 2 + 1)) - uSpread;
  751.             cC += (cTL + cBR + cTR + cBL) / 4;
  752.             Normalize(cC);
  753.             _pfh->Point(iMidX, iMidY, cC + 1);
  754.         }
  756.         // now recurse
  757.         if (xh - xl > 2 || yh - yl > 2)
  758.         {
  759.             Subdivide(xl, yl, iMidX, iMidY);
  760.             Subdivide(iMidX, yl, xh, iMidY);
  761.             Subdivide(xl, iMidY, iMidX, yh);
  762.             Subdivide(iMidX, iMidY, xh, yh);
  763.         }
  764.     }
  765. }
  767. //+---------------------------------------------------------------------------
  768. //
  769. //  Member:     CPlasma::CPlasma
  770. //
  771. //  Synopsis:   constructor
  772. //
  773. //  History:    4-23-94   stevebl   Created
  774. //
  775. //----------------------------------------------------------------------------
  777. CPlasma::CPlasma()
  778. {
  779.     _uWidth = 160;
  780.     _uHeight = 120;
  781.     _dRandomnessFactor = 2.0;
  782.     _hRestart = _hRunning = _hEngine = NULL;
  783.     _dwThreadId = 0;
  784.     _cRef = 0;
  785.     _pfh = NULL;
  786.     _fDirty = TRUE;
  787. }
  789. //+---------------------------------------------------------------------------
  790. //
  791. //  Member:     CPlasma::~CPlasma
  792. //
  793. //  Synopsis:   destructor
  794. //
  795. //  History:    4-23-94   stevebl   Created
  796. //
  797. //----------------------------------------------------------------------------
  799. CPlasma::~CPlasma()
  800. {
  801.     if (_hRestart)
  802.     {
  803.         CloseHandle(_hRestart);
  804.     }
  805.     if (_hRunning)
  806.     {
  807.         CloseHandle(_hRunning);
  808.     }
  809.     if (_hEngine)
  810.     {
  811.         TerminateThread(_hEngine, 0);
  812.         CloseHandle(_hEngine);
  813.     }
  814. }
  816. #define LENGTH 50
  817. #define ABOUT_STRING_LENGTH 256
  819. //+---------------------------------------------------------------------------
  820. //
  821. //  Member:     CPlasma::DialogProc
  822. //
  823. //  Synopsis:   Dialog proc for the Properties dialog box
  824. //
  825. //  Arguments:  [hwndDlg] - the dialog's window handle
  826. //              [uMsg]    - message
  827. //              [wParam]  - first message parameter
  828. //              [lParam]  - second message parameter
  829. //
  830. //  History:    4-23-94   stevebl   Created
  831. //
  832. //----------------------------------------------------------------------------
  834. BOOL CPlasma::DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
  835. {
  836.     char mbs[LENGTH + 1];
  838.     switch (uMsg)
  839.     {
  840.     case WM_INITDIALOG:
  841.         sprintf(mbs, "%.13g", _dRandomnessFactor);
  842.         SetDlgItemTextA(hwndDlg, IDM_RANDOMNESS, mbs);
  843.         return(TRUE);
  844.     case WM_COMMAND:
  845.         switch (LOWORD(wParam))
  846.         {
  847.         case IDOK:
  848.             GetDlgItemTextA(hwndDlg, IDM_RANDOMNESS, mbs, LENGTH);
  849.             sscanf(mbs, "%lg", &_dRandomnessFactor);
  850.             if (_dRandomnessFactor < MIN_RANDOM)
  851.             {
  852.                 _dRandomnessFactor = MIN_RANDOM;
  853.             }
  854.             if (_dRandomnessFactor > MAX_RANDOM)
  855.             {
  856.                 _dRandomnessFactor = MAX_RANDOM;
  857.             }
  858.             _fDirty = TRUE;
  859.             SetEvent(_hRestart);
  860.             EndDialog(hwndDlg, TRUE);
  861.             return(TRUE);
  862.         case IDM_ABOUT:
  863.             {
  864.                 TCHAR szTitle[ABOUT_STRING_LENGTH];
  865.                 TCHAR szText[ABOUT_STRING_LENGTH];
  866.                 if (LoadString(ghinst, IDS_ABOUT_TITLE, szTitle, ABOUT_STRING_LENGTH))
  867.                 {
  868.                     if (LoadString(ghinst, IDS_ABOUT_TEXT, szText, ABOUT_STRING_LENGTH))
  869.                     {
  870.                         MessageBox(
  871.                             hwndDlg,
  872.                             szText,
  873.                             szTitle,
  874.                             MB_OK | MB_ICONINFORMATION);
  875.                     }
  876.                 }
  877.             }
  878.             return(TRUE);
  879.         case IDCANCEL:
  880.             EndDialog(hwndDlg, FALSE);
  881.             return(TRUE);
  882.         default:
  883.             return(FALSE);
  884.         }
  885.     }
  886.     return(FALSE);
  887. }