home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / dtbase.cpp < prev    next >
C/C++ Source or Header  |  2000-02-01  |  56KB  |  1,634 lines
  1. /*******************************************************************************
  2. * DTBase.cpp *
  3. *------------*
  4. *   Description:
  5. *    This module contains the CDXBaseNTo1 transform
  6. *-------------------------------------------------------------------------------
  7. *  Created By: Edward W. Connell                            Date: 07/28/97
  8. *  Copyright (C) 1997 Microsoft Corporation
  9. *  All Rights Reserved
  10. *
  11. *-------------------------------------------------------------------------------
  12. *  Revisions:
  13. *
  14. *******************************************************************************/
  15. //--- Additional includes
  16. #include "stdafx.h"
  17. #include <DXTrans.h>
  18. #include "DTBase.h"
  19. #include "new.h"
  20.  
  21. //--- Initialize static member of debug scope class
  22. #ifdef _DEBUG
  23. CDXTDbgFlags CDXTDbgScope::m_DebugFlags;
  24. #endif
  25.  
  26. //--- This should only be used locally in this file. We duplicated this GUID
  27. //    value to avoid having to include DDraw.
  28. static const IID IID_IDXDupDirectDraw =
  29.     { 0x6C14DB80,0xA733,0x11CE, { 0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 } };
  30.  
  31. static const IID IID_IDXDupDDrawSurface =
  32.     { 0x6C14DB81,0xA733,0x11CE, { 0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 } };
  33.  
  34. static const IID IID_IDXDupDirect3DRM =
  35.     {0x2bc49361, 0x8327, 0x11cf, {0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1 } };
  36.  
  37. static const IID IID_IDXDupDirect3DRM3 =
  38.     {0x4516ec83, 0x8f20, 0x11d0, {0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3 } };
  39.  
  40. static const IID IID_IDXDupDirect3DRMMeshBuilder3 =
  41.     { 0x4516ec82, 0x8f20, 0x11d0, { 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3} };
  42.  
  43. HRESULT CDXDataPtr::Assign(BOOL bMesh, IUnknown * pObject, IDXSurfaceFactory *pSurfaceFactory)
  44. {
  45.     HRESULT hr = S_OK;
  46.     if (pObject)
  47.     {
  48.         IUnknown *pNative = NULL;
  49.         if (!bMesh)
  50.         {
  51.             //--- Try to get a DX surface
  52.             hr = pObject->QueryInterface( IID_IDXSurface, (void **)&pNative );
  53.             if( FAILED( hr ) )
  54.             {
  55.                 IDirectDrawSurface *pSurf;
  56.                 //--- Try to get a DDraw surface
  57.                 hr = pObject->QueryInterface( IID_IDXDupDDrawSurface, (void **)&pSurf );
  58.                 if( SUCCEEDED( hr ) )
  59.                 {
  60.                     //--- Create a DXSurface from the DDraw surface
  61.                     hr = pSurfaceFactory->CreateFromDDSurface(
  62.                                 pSurf, NULL, 0, NULL, IID_IDXSurface,
  63.                                 (void **)&pNative );
  64.                     pSurf->Release();
  65.                 }
  66.             }
  67.         }
  68.         else // Must be a mesh builder
  69.         {
  70.             hr = pObject->QueryInterface(IID_IDXDupDirect3DRMMeshBuilder3, (void **)&pNative);
  71.         }
  72.         if (SUCCEEDED(hr))
  73.         {
  74.             Release();
  75.             m_pNativeInterface = pNative;
  76.             pObject->AddRef();
  77.             m_pUnkOriginalObject = pObject;
  78.             if (SUCCEEDED(pNative->QueryInterface(IID_IDXBaseObject, (void **)&m_pBaseObj)))
  79.             {
  80.                 m_pBaseObj->GetGenerationId(&m_dwLastDirtyGenId);
  81.                 m_dwLastDirtyGenId--;
  82.             }
  83.             if (!bMesh)
  84.             {   
  85.                 ((IDXSurface *)pNative)->GetPixelFormat(NULL, &m_SampleFormat);
  86.             }
  87.         }
  88.         else
  89.         {
  90.             if (hr == E_NOINTERFACE)
  91.             {
  92.                 hr = E_INVALIDARG;
  93.             }
  94.         }
  95.     }
  96.     else 
  97.     {
  98.         Release();
  99.     }
  100.     return hr;
  101. } /* CDXDataPtr::Assign */
  102.  
  103. bool CDXDataPtr::IsDirty(void)
  104. {
  105.     if (m_pBaseObj)
  106.     {
  107.         DWORD dwOldId = m_dwLastDirtyGenId;
  108.         m_pBaseObj->GetGenerationId(&m_dwLastDirtyGenId);
  109.         return dwOldId != m_dwLastDirtyGenId;
  110.     }
  111.     else
  112.     {
  113.         return false;
  114.     }
  115.  
  116. }
  117.  
  118. DWORD CDXDataPtr::GenerationId(void)
  119. {
  120.     if (m_pBaseObj)
  121.     {
  122.         DWORD dwGenId;
  123.         m_pBaseObj->GetGenerationId(&dwGenId);
  124.         return dwGenId;
  125.     }
  126.     else
  127.     {
  128.         return 0;
  129.     }
  130. }
  131.  
  132.  
  133. bool CDXDataPtr::UpdateGenerationId(void)
  134. {
  135.     if (m_pBaseObj)
  136.     {
  137.         DWORD dwOldId = m_dwLastUpdGenId;
  138.         m_pBaseObj->GetGenerationId(&m_dwLastUpdGenId);
  139.         return dwOldId != m_dwLastUpdGenId;
  140.     }
  141.     else
  142.     {
  143.         return false;
  144.     }
  145. } /* CDXDataPtr::UpdateGenerationId */
  146.  
  147. ULONG CDXDataPtr::ObjectSize(void)
  148. {
  149.     ULONG ulSize = 0;
  150.     if (m_pBaseObj)
  151.     {
  152.         m_pBaseObj->GetObjectSize(&ulSize);
  153.     }
  154.     return ulSize;    
  155. }
  156.  
  157. /*****************************************************************************
  158. * CDXBaseNTo1::CDXBaseNTo1 *
  159. *--------------------------*
  160. *   Description:
  161. *       Constructor
  162. *-----------------------------------------------------------------------------
  163. *   Created By: Ed Connell                            Date: 07/28/97
  164. *-----------------------------------------------------------------------------
  165. *   Parameters:
  166. *****************************************************************************/
  167. CDXBaseNTo1::CDXBaseNTo1() :
  168.     m_aInputs(NULL),
  169.     m_ulNumInputs(0),
  170.     m_ulNumProcessors(1),   // Default to one until task manager is set
  171.     m_dwGenerationId(1),
  172.     m_dwCleanGenId(0),
  173.     m_Duration(1.0f),
  174.     m_StepResolution(0.0f),
  175.     m_Progress(0.0f),
  176.     m_dwBltFlags(0),
  177.     m_bPickDoneByBase(false),
  178.     m_bInMultiThreadWorkProc(FALSE),
  179.     m_fQuality(0.5f),   // Default to normal quality.
  180.     //  Wait forever before timing out on a lock by default
  181.     m_ulLockTimeOut(INFINITE),
  182.     //
  183.     //  Override these flags if your object does not support one or more of these options.
  184.     //  Typically, 3-D effects should set this member to 0.
  185.     //
  186.     m_dwMiscFlags(DXTMF_BLEND_WITH_OUTPUT | DXTMF_DITHER_OUTPUT |
  187.                   DXTMF_BLEND_SUPPORTED | DXTMF_DITHER_SUPPORTED | DXTMF_BOUNDS_SUPPORTED | DXTMF_PLACEMENT_SUPPORTED),
  188.     //
  189.     //  If your object has a different number of objects or a different number of
  190.     //  required objects than 1, simply set these members in the body of your
  191.     //  constructor or in FinalConstruct().  For every input that is > the number
  192.     //  required, that input will be reported as optional.
  193.     //
  194.     //  If your transform takes 2 required inputs, set both to 2.
  195.     //  If your transform takes 2 optional inputs, set MaxInputs = 2, NumInRequired = 0
  196.     //  If your transform takes 1 required and 2 optional inputs,
  197.     //      set MaxInputs = 2, NumInRequired = 1
  198.     //
  199.     //  For more complex combinations of optinal/required, you will need to override
  200.     //  the OnSetup method of this base class, and override the methods
  201.     //      GetInOutInfo
  202.     //
  203.     m_ulMaxInputs(1),
  204.     m_ulNumInRequired(1),
  205.     //
  206.     //  If the intputs or output types are not surfaces then set appropriate object type
  207.     //
  208.     m_dwOptionFlags(0),     // Inputs and output are surfaces, don't have to be the same size
  209.     m_ulMaxImageBands(DXB_MAX_IMAGE_BANDS)
  210. {
  211.     DXTDBG_FUNC( "CDXBaseNTo1::CDXBaseNTo1" );
  212.     //
  213.     //  Set event handles to NULL.
  214.     //
  215.     memset(m_aEvent, 0, sizeof(m_aEvent));
  216. } /* CDXBaseNTo1::CDXBaseNTo1 */
  217.  
  218. /*****************************************************************************
  219. * CDXBaseNTo1::~CDXBaseNTo1 *
  220. *---------------------------*
  221. *   Description:
  222. *       Constructor
  223. *-----------------------------------------------------------------------------
  224. *   Created By: Ed Connell                            Date: 07/28/97
  225. *-----------------------------------------------------------------------------
  226. *   Parameters:
  227. *****************************************************************************/
  228. CDXBaseNTo1::~CDXBaseNTo1()
  229. {
  230.     DXTDBG_FUNC( "CDXBaseNTo1::~CDXBaseNTo1" );
  231.     _ReleaseReferences();
  232.     delete[] m_aInputs;
  233.  
  234.     //--- Release event objects
  235.     for(ULONG i = 0; i < DXB_MAX_IMAGE_BANDS; ++i )
  236.     {
  237.         if( m_aEvent[i] ) ::CloseHandle( m_aEvent[i] );
  238.     }
  239. } /* CDXBaseNTo1::~CDXBaseNTo1 */
  240.  
  241.  
  242. /*****************************************************************************
  243. * CDXBaseNTo1::_ReleaseRefernces *
  244. *--------------------------------*
  245. *   Description:
  246. *       Releases all references to input and output objects
  247. *-----------------------------------------------------------------------------
  248. *   Created By: RAL
  249. *-----------------------------------------------------------------------------
  250. *   Parameters:
  251. *****************************************************************************/
  252. void CDXBaseNTo1::_ReleaseReferences()
  253. {
  254.     //--- Release data objects
  255.     if( m_aInputs )
  256.     {
  257.         for( ULONG i = 0; i < m_ulNumInputs; ++i )
  258.         {
  259.             m_aInputs[i].Release();
  260.         }
  261.     }
  262.  
  263.     m_Output.Release();
  264. } /* CDXBaseNTo1::_ReleaseRefernces */
  265.  
  266.  
  267.  
  268. STDMETHODIMP CDXBaseNTo1::GetGenerationId(ULONG *pGenerationId)
  269. {
  270.     DXTDBG_FUNC( "CDXBaseNTo1::GetGenerationId" );
  271.     if (DXIsBadWritePtr(pGenerationId, sizeof(*pGenerationId)))
  272.     {
  273.         return E_POINTER;
  274.     }
  275.     Lock();
  276.     OnUpdateGenerationId();
  277.     *pGenerationId = m_dwGenerationId;
  278.     Unlock();
  279.     return S_OK;
  280. }
  281.  
  282. STDMETHODIMP CDXBaseNTo1::IncrementGenerationId(BOOL bRefresh)
  283. {
  284.     DXTDBG_FUNC( "CDXBaseNTo1::IncrementGenerationId" );
  285.     HRESULT hr = S_OK;
  286.     Lock();
  287.     m_dwGenerationId++;
  288.     if (bRefresh)
  289.     {
  290.         //
  291.         //  If we have any inputs or outputs, call Setup again to refresh all internal
  292.         //  knowledge about the surfaces (formats, height or width could change, etc.)
  293.         //
  294.         //  Note that we need to AddRef the objects prior to calling Setup becuase the
  295.         //  DXTransform may be the only object holding a referec
  296.         //
  297.         ULONG cInputs = m_ulNumInputs;
  298.         ULONG cOutputs = 0;
  299.         IUnknown *pOutput = m_Output.m_pUnkOriginalObject;
  300.         if (pOutput)
  301.         {
  302.             cOutputs = 1;
  303.             pOutput->AddRef();
  304.         }
  305.         IUnknown ** ppInputs = NULL;
  306.         if (cInputs)
  307.         {
  308.             ppInputs = (IUnknown **)_alloca(m_ulNumInputs * sizeof(IUnknown *));
  309.             for (ULONG i = 0; i < cInputs; i++)
  310.             {
  311.                 ppInputs[i] = m_aInputs[i].m_pUnkOriginalObject;
  312.                 if (ppInputs[i]) ppInputs[i]->AddRef();
  313.             }
  314.         }
  315.         if (cInputs || cOutputs)    // If we're not setup, skip this step.
  316.         {
  317.             hr = Setup(ppInputs, cInputs, &pOutput, cOutputs, 0);
  318.             if (pOutput) pOutput->Release();
  319.             for (ULONG i = 0; i < cInputs; i++)
  320.             {
  321.                 if (ppInputs[i]) ppInputs[i]->Release();
  322.             }
  323.         }
  324.     }
  325.     Unlock();
  326.     return hr;
  327. }
  328.  
  329.  
  330. STDMETHODIMP CDXBaseNTo1::GetObjectSize(ULONG *pcbSize)
  331. {
  332.     DXTDBG_FUNC( "CDXBaseNTo1::GetObjectSize" );
  333.     HRESULT hr = S_OK;
  334.     if (DXIsBadWritePtr(pcbSize, sizeof(*pcbSize)))
  335.     {
  336.         hr = E_POINTER;
  337.     }
  338.     else
  339.     {
  340.     Lock();
  341.         *pcbSize = OnGetObjectSize();
  342.         Unlock();
  343.     }
  344.     return hr;
  345. }
  346.  
  347.  
  348. void CDXBaseNTo1::_ReleaseServices(void)
  349. {
  350.     m_cpTransFact.Release();
  351.     m_cpSurfFact.Release();
  352.     m_cpTaskMgr.Release();
  353.     m_cpDirectDraw.Release();
  354.     m_cpDirect3DRM.Release();
  355. }
  356.  
  357. //
  358. //  The documentation for SetSite indicates that it is invaid to return
  359. //  an error from this function, even if the site does not support the
  360. //  functionality we want.  So, even if there is no service provider, or
  361. //  the required services are not available, we will return S_OK.
  362. //
  363. STDMETHODIMP CDXBaseNTo1::SetSite(IUnknown * pUnkSite)
  364. {
  365.     DXTDBG_FUNC( "CDXBaseNTo1::SetSite" );
  366.     HRESULT hr = S_OK;
  367.     Lock();
  368.     m_cpUnkSite = pUnkSite;
  369.     _ReleaseServices();
  370.     if (pUnkSite)
  371.     {
  372.         if (DXIsBadInterfacePtr(pUnkSite))
  373.         {
  374.             hr = E_INVALIDARG;
  375.         }
  376.         else
  377.         {
  378.             HRESULT hr2;
  379.             hr2 = pUnkSite->QueryInterface(IID_IDXTransformFactory, (void **)&m_cpTransFact);
  380.         if (SUCCEEDED(hr2))
  381.         {
  382.                 //
  383.                 //  Allocate memory for inputs if necessary
  384.                 //
  385.                 if (m_aInputs == NULL && m_ulMaxInputs)
  386.                 {
  387.                     m_aInputs  = new CDXDataPtr[m_ulMaxInputs];
  388.                     if (!m_aInputs)
  389.                     {
  390.                         _ASSERT(TRUE);
  391.                         hr2 = E_OUTOFMEMORY;
  392.                     }
  393.                 }
  394.                 hr2 = m_cpTransFact->QueryService( SID_SDXSurfaceFactory, IID_IDXSurfaceFactory, (void **)&m_cpSurfFact);
  395.                 if (SUCCEEDED(hr2))
  396.                 {
  397.                     hr2 = m_cpTransFact->QueryService( SID_SDXTaskManager, IID_IDXTaskManager, (void **)&m_cpTaskMgr);
  398.                 }
  399.                 if (SUCCEEDED(hr2))
  400.                 {
  401.                     m_cpTaskMgr->QueryNumProcessors(&m_ulNumProcessors);
  402.                     if (m_ulMaxImageBands && (m_dwOptionFlags & (DXBOF_INPUTS_MESHBUILDER | DXBOF_OUTPUT_MESHBUILDER)) == 0)
  403.                     {
  404.                         for (ULONG i = 0; SUCCEEDED(hr2) && i < m_ulMaxImageBands; i++)
  405.                         {
  406.                             //
  407.                             // In theory we could get back here after failing to create an event, or
  408.                             // by getting a new site, so make sure it's non-null before creating one.
  409.                             //
  410.                             if (m_aEvent[i] == NULL)
  411.                             {
  412.                                 m_aEvent[i] = ::CreateEvent(NULL, true, false, NULL);
  413.                                 if (m_aEvent[i] == NULL)
  414.                                 {
  415.                                     hr2 = E_OUTOFMEMORY;
  416.                                 }
  417.                             }
  418.  
  419.                         }
  420.                     }
  421.                 }
  422.                 if (SUCCEEDED(hr2))
  423.                 {
  424.                     hr2 = m_cpTransFact->QueryService(SID_SDirectDraw, IID_IDXDupDirectDraw, (void**)&m_cpDirectDraw);
  425.                 }
  426.                 if (SUCCEEDED(hr2) && 
  427.                     (m_dwOptionFlags & (DXBOF_INPUTS_MESHBUILDER | DXBOF_OUTPUT_MESHBUILDER)))
  428.                 {
  429.                     hr2 = m_cpTransFact->QueryService(SID_SDirect3DRM, IID_IDXDupDirect3DRM3, (void **)&m_cpDirect3DRM);
  430.                 }
  431.                 if (FAILED(hr2))
  432.                 {
  433.                     _ASSERT(TRUE);
  434.                     _ReleaseServices();
  435.                 }
  436.             }
  437.         }
  438.     }
  439.     Unlock();
  440.     return hr;
  441. }
  442.  
  443.  
  444. STDMETHODIMP CDXBaseNTo1::GetSite(REFIID riid, void **ppv)
  445. {
  446.     DXTDBG_FUNC( "CDXBaseNTo1::GetSite" );
  447.     HRESULT hr = S_OK;
  448.     if( DXIsBadWritePtr(ppv, sizeof(*ppv)) )
  449.     {
  450.         hr = E_POINTER;
  451.     }
  452.     else
  453.     {
  454.         Lock();
  455.         if (m_cpUnkSite)
  456.         {
  457.             hr = m_cpUnkSite->QueryInterface(riid, ppv);
  458.         }
  459.         else
  460.         {
  461.             *ppv = NULL;
  462.             hr = E_FAIL;    // This is the proper documented return code
  463.                             // for this interface if no service provider.
  464.         }
  465.         Unlock();
  466.     }
  467.     return hr;
  468. } 
  469.  
  470.  
  471. void CDXBaseNTo1::_UpdateBltFlags(void)
  472. {
  473.     m_dwBltFlags = 0;
  474.     if ((m_dwOptionFlags & DXBOF_OUTPUT_MESHBUILDER) == 0)
  475.     {
  476.         if (m_dwMiscFlags & DXTMF_BLEND_WITH_OUTPUT) 
  477.         {
  478.             if ((m_dwOptionFlags & DXBOF_INPUTS_MESHBUILDER) || m_ulNumInputs == 0)
  479.             {
  480.                 m_dwBltFlags |= DXBOF_DO_OVER;
  481.             }
  482.             else
  483.             {
  484.                 for(ULONG i = 0; i < m_ulNumInputs; ++i )
  485.                 {
  486.                     if (InputSampleFormat(i) & DXPF_TRANSPARENCY)
  487.                     {
  488.                         m_dwBltFlags |= DXBOF_DO_OVER;
  489.                         break;
  490.                     }
  491.                 }
  492.             }
  493.         }
  494.         //
  495.         //  Set the dither flag to true only if output error is > at least one input
  496.         //
  497.         if (m_dwMiscFlags & DXTMF_DITHER_OUTPUT)
  498.         {
  499.             ULONG OutputErr = (OutputSampleFormat() & DXPF_ERRORMASK);
  500.             if (OutputErr)
  501.             {
  502.                 if (m_ulNumInputs)
  503.                 {
  504.                     for(ULONG i = 0; i < m_ulNumInputs; ++i )
  505.                     {
  506.                         if (InputSurface(i) && (ULONG)(InputSampleFormat(i) & DXPF_ERRORMASK) < OutputErr)
  507.                         {
  508.                             m_dwBltFlags |= DXBOF_DITHER;
  509.                             break;
  510.                         }
  511.                     }
  512.                 }
  513.                 else
  514.                 {
  515.                     //
  516.                     // If output has no error then don't set dither in blt flags
  517.                     //  
  518.                     if (OutputErr)
  519.                     {
  520.                         m_dwBltFlags |= DXBOF_DITHER; 
  521.                     }
  522.                 }
  523.             }
  524.         }
  525.     }
  526. }
  527.  
  528.  
  529.  
  530. /*****************************************************************************
  531. * CDXBaseNTo1::Setup *
  532. *--------------------*
  533. *   Description:
  534. *       The Setup method is used to perform any required one-time setup
  535. *   before the Execute method is called. Single surfaces or SurfaceSets may
  536. *   be used as arguments in any combination. 
  537. *   If punkOutputs is NULL, Execute will allocate an output result of the
  538. *   appropriate size and return it.
  539. *   if punkInputs and punkOutputs are NULL and it is a quick setup, the current
  540. *   input and output objects are released.
  541. *-----------------------------------------------------------------------------
  542. *   Created By: Ed Connell                            Date: 07/28/97
  543. *-----------------------------------------------------------------------------
  544. *   Parameters:
  545. *****************************************************************************/
  546. STDMETHODIMP CDXBaseNTo1::Setup( IUnknown * const * punkInputs, ULONG ulNumInputs,
  547.                                  IUnknown * const * punkOutputs, ULONG ulNumOutputs, DWORD dwFlags )
  548. {
  549.     DXTDBG_FUNC( "CDXBaseNTo1::Setup" );
  550.     //--- Lock object so state cannot change during setup
  551.     DXAUTO_OBJ_LOCK
  552.     HRESULT hr = S_OK;
  553.     ULONG i;
  554.  
  555.     //
  556.     //  Early out for null setup.  Forget about all other param validation, just do it.
  557.     //  
  558.     if (ulNumInputs == 0 && ulNumOutputs == 0)
  559.     {
  560.         _ReleaseReferences();
  561.         OnReleaseObjects();
  562.         return hr;
  563.     }
  564.  
  565.     //--- Validate Params
  566.     //--- Make sure we have a reference to the transform factory
  567.     if( !m_cpTransFact )
  568.     {
  569.         hr = DXTERR_UNINITIALIZED;
  570.         DXTDBG_MSG0( _CRT_ERROR, "\nTransform has not been initialized" );
  571.     }
  572.     else
  573.     {
  574.         //
  575.         //  We know that if we have a transform factory that we must also have
  576.         //  allocated m_aInputs since this is done on SetSite to avoid work during
  577.         //  each setup.
  578.         //
  579.         _ASSERT(m_aInputs || m_ulMaxInputs == 0);
  580.         if( dwFlags ||              // No flags are valid
  581.             ulNumOutputs != 1 ||
  582.             ulNumInputs < m_ulNumInRequired ||
  583.             ulNumInputs > m_ulMaxInputs ||
  584.             (ulNumInputs && DXIsBadReadPtr( punkInputs , sizeof( *punkInputs ) * ulNumInputs )) ||
  585.             DXIsBadReadPtr(punkOutputs, sizeof(*punkOutputs)) ||
  586.             DXIsBadInterfacePtr(punkOutputs[0]))
  587.         {
  588.             hr = E_INVALIDARG;
  589.             DXTDBG_MSG0( _CRT_ERROR, "\nTransform setup with invalid args" );
  590.         }
  591.         else
  592.         {
  593.             for( i = 0; i < ulNumInputs; ++i )
  594.             {
  595.                 if((punkInputs[i] && DXIsBadInterfacePtr(punkInputs[i])) ||
  596.                     (punkInputs[i] == NULL && i < m_ulNumInRequired))
  597.                 {
  598.                     hr = E_INVALIDARG;
  599.                     DXTDBG_MSG0( _CRT_ERROR, "\nTransform setup with invalid args" );
  600.                     break;
  601.                 }
  602.             }        
  603.         }
  604.     }
  605.  
  606.     //--- Allocate slots for input data object pointers
  607.     if( SUCCEEDED( hr ) )
  608.     {
  609.         //--- Release data objects
  610.         _ReleaseReferences();
  611.         m_ulNumInputs = ulNumInputs;
  612.     }
  613.  
  614.     //
  615.     //  Assign 
  616.     //
  617.     for( i = 0; SUCCEEDED(hr) && i < m_ulNumInputs; ++i )
  618.     {
  619.         hr = m_aInputs[i].Assign((m_dwOptionFlags & DXBOF_INPUTS_MESHBUILDER), punkInputs[i], m_cpSurfFact);
  620.     }
  621.  
  622.     if( SUCCEEDED(hr) )
  623.     {
  624.         hr = m_Output.Assign((m_dwOptionFlags & DXBOF_OUTPUT_MESHBUILDER), punkOutputs[0], m_cpSurfFact);
  625.     }   
  626.  
  627.     if (SUCCEEDED(hr) && (m_dwOptionFlags & DXBOF_SAME_SIZE_INPUTS))
  628.     {
  629.         hr = _MakeInputsSameSize();
  630.     }
  631.  
  632.     if (SUCCEEDED(hr))
  633.     {
  634.         _UpdateBltFlags();      // Do this before calling OnSetup...
  635.         hr = OnSetup(dwFlags);
  636.     }
  637.     
  638.     if (FAILED(hr))
  639.     {
  640.         _ReleaseReferences();
  641.         OnReleaseObjects();
  642.         DXTDBG_MSG0( _CRT_ERROR, "\nTransform setup failed" );
  643.     }
  644.  
  645.     return hr;
  646. } /* CDXBaseNTo1::Setup */
  647.  
  648.  
  649. /*****************************************************************************
  650. * CDXBaseNTo1::_MakeInputsSameSize *
  651. *----------------------------------*
  652. *   Description:
  653. *-----------------------------------------------------------------------------
  654. *   Created By: RAL                            Date: 03/31/98
  655. *-----------------------------------------------------------------------------
  656. *   Parameters:
  657. *****************************************************************************/
  658.  
  659. HRESULT CDXBaseNTo1::_MakeInputsSameSize(void)
  660. {
  661.     _ASSERT((m_dwOptionFlags & DXBOF_INPUTS_MESHBUILDER) == 0);
  662.  
  663.     HRESULT hr = S_OK;
  664.     if (m_ulNumInputs > 1)      // No need to do this for just one input!
  665.     {
  666.         CDXDBnds SurfBnds(false);
  667.         CDXDBnds Union(true);
  668.         for (ULONG i = 0; SUCCEEDED(hr) && i < m_ulNumInputs; i++)
  669.         {
  670.             if (InputSurface(i))
  671.             {
  672.                 hr = SurfBnds.SetToSurfaceBounds(InputSurface(i));
  673.                 Union |= SurfBnds;
  674.             }
  675.         }
  676.         for (i = 0; SUCCEEDED(hr) && i < m_ulNumInputs; i++)
  677.         {
  678.             if (InputSurface(i))
  679.             {
  680.                 hr = SurfBnds.SetToSurfaceBounds(InputSurface(i));
  681.                 if (SUCCEEDED(hr) && SurfBnds != Union)
  682.                 {
  683.                     IDXSurfaceModifier *pSurfMod;
  684.                     hr = ::CoCreateInstance(CLSID_DXSurfaceModifier, NULL, CLSCTX_INPROC,
  685.                                             IID_IDXSurfaceModifier, (void **)&pSurfMod);
  686.                     if (SUCCEEDED(hr))
  687.                     {
  688.                         POINT p;
  689.                         p.x = p.y = 0;
  690.                         if (m_dwOptionFlags & DXBOF_CENTER_INPUTS)
  691.                         {
  692.                             p.x = (Union.Width() - SurfBnds.Width()) / 2;
  693.                             p.y = (Union.Height() - SurfBnds.Height()) / 2;
  694.                         }
  695.                         pSurfMod->SetForeground(InputSurface(i), FALSE, &p);
  696.                         pSurfMod->SetBounds(&Union);
  697.                         InputSurface(i)->Release();
  698.                         pSurfMod->QueryInterface(IID_IDXSurface, (void **)&(m_aInputs[i].m_pNativeInterface));
  699.                         ((IDXSurface *)m_aInputs[i].m_pNativeInterface)->GetPixelFormat(NULL, &m_aInputs[i].m_SampleFormat);
  700.                         pSurfMod->Release();
  701.                     }
  702.                 }
  703.             }
  704.         }
  705.     }
  706.     return hr;
  707. }
  708.  
  709.  
  710. /*****************************************************************************
  711. * CDXBaseNTo1::Execute *
  712. *----------------------*
  713. *   Description:
  714. *       The Execute method is used to walk the inputs/outputs and break up the
  715. *   work into suitably sized pieces to spread symetrically accross the available
  716. *   processors in the system.
  717. *-----------------------------------------------------------------------------
  718. *   Created By: Ed Connell                            Date: 07/28/97
  719. *-----------------------------------------------------------------------------
  720. *   Parameters:
  721. *****************************************************************************/
  722. STDMETHODIMP CDXBaseNTo1::
  723.     Execute( const GUID* pRequestID, const DXBNDS *pClipBnds, const DXVEC *pPlacement )
  724. {
  725.     DXTDBG_FUNC( "CDXBaseNTo1::Execute" );
  726.     //--- Lock object so state cannot change during execution
  727.     DXAUTO_OBJ_LOCK
  728.     HRESULT hr = S_OK;
  729.  
  730.     //--- Check args
  731.     if( !HaveOutput() )
  732.     {
  733.         DXTDBG_MSG0( _CRT_ERROR, "\nTransform has not been initialized" );
  734.         return DXTERR_UNINITIALIZED;
  735.     }
  736.  
  737.     if (m_ulMaxImageBands == 0 ||
  738.         (m_dwOptionFlags & (DXBOF_INPUTS_MESHBUILDER | DXBOF_OUTPUT_MESHBUILDER)))
  739.     {
  740.         if ((pClipBnds && (m_dwMiscFlags & DXTMF_BOUNDS_SUPPORTED) == 0) ||
  741.             (pPlacement && (m_dwMiscFlags & DXTMF_PLACEMENT_SUPPORTED) == 0) )
  742.         {
  743.             DXTDBG_MSG0( _CRT_ERROR, "\nTransform setup with invalid args" );
  744.             return E_INVALIDARG;
  745.         }
  746.         return OnExecute( pRequestID, pClipBnds, pPlacement );
  747.     }
  748.  
  749.     //--- Banded image working variables
  750.     CDXTWorkInfoNTo1 WI;
  751.  
  752.     if ((pClipBnds && pClipBnds->eType != DXBT_DISCRETE) ||
  753.         (pPlacement && pPlacement->eType != DXBT_DISCRETE))
  754.     {
  755.         hr = E_INVALIDARG;
  756.         DXTDBG_MSG0( _CRT_ERROR, "\nTransform setup with invalid args" );
  757.     }
  758.     else
  759.     {
  760.         hr = MapBoundsIn2Out( NULL, 0, 0, &WI.DoBnds );
  761.         if( hr == S_OK )
  762.         {
  763.             hr = WI.OutputBnds.SetToSurfaceBounds(OutputSurface());
  764.             if (hr == S_OK)
  765.             {
  766.                 hr = DXClipToOutputWithPlacement(WI.DoBnds, (CDXDBnds *)pClipBnds, WI.OutputBnds, (CDXDVec *)pPlacement);
  767.             }
  768.         }
  769.     }
  770.  
  771.     //--- Check for clipping early exit
  772.     if( hr != S_OK )
  773.     {
  774.         return hr;
  775.     }
  776.  
  777.     //=== Process ====================================================
  778.     _ASSERT(m_ulMaxImageBands <= DXB_MAX_IMAGE_BANDS);
  779.     ULONG ulNumBandsToDo = m_ulNumProcessors;
  780.     if( ulNumBandsToDo > 1 )
  781.     {
  782.         ulNumBandsToDo = 1 + ((WI.OutputBnds.Width() * WI.OutputBnds.Height()) / 0x1000);
  783.         if (ulNumBandsToDo > m_ulMaxImageBands)
  784.         {
  785.             ulNumBandsToDo = m_ulMaxImageBands;
  786.         }
  787.         if (ulNumBandsToDo > m_ulNumProcessors)
  788.         {
  789.             ulNumBandsToDo = m_ulNumProcessors;
  790.         }
  791.     }
  792.     hr = OnInitInstData(WI, ulNumBandsToDo);
  793.     if( SUCCEEDED( hr ) )
  794.     {
  795.         if (ulNumBandsToDo == 1 && pRequestID == NULL)
  796.         {
  797.             static BOOL bContinue = TRUE;
  798.             hr = WorkProc(WI, &bContinue);
  799.         }
  800.         else
  801.         {
  802.             _ASSERT( ulNumBandsToDo <= DXB_MAX_IMAGE_BANDS );
  803.             _ASSERT( m_aEvent[ulNumBandsToDo-1] );
  804.  
  805.             long lStartAtRow = WI.DoBnds[DXB_Y].Min;
  806.             ULONG ulRowCount = WI.DoBnds[DXB_Y].Max - lStartAtRow;
  807.             _ASSERT( ( ulRowCount / ulNumBandsToDo ) != 0 );
  808.  
  809.             //--- Init the work info structures
  810.             ULONG ulBand, RowsPerBand = ulRowCount / ulNumBandsToDo;
  811.             CDXTWorkInfoNTo1 *WIArray = (CDXTWorkInfoNTo1*)alloca( sizeof(CDXTWorkInfoNTo1) *
  812.                                                          ulNumBandsToDo );
  813.             DWORD *TaskIDs = (DWORD*)alloca( sizeof(DWORD) * ulNumBandsToDo );
  814.             DXTMTASKINFO* TaskInfo = (DXTMTASKINFO*)alloca( sizeof( DXTMTASKINFO ) *
  815.                                                             ulNumBandsToDo );
  816.  
  817.             //--- Build task info list
  818.             WI.hr       = S_OK;
  819.             WI.pvThis   =  this;
  820.             long Start  = lStartAtRow;
  821.             ULONG Count = RowsPerBand;
  822.             long OutputYDelta = WI.OutputBnds[DXB_Y].Min - WI.DoBnds[DXB_Y].Min;
  823.  
  824.             for( ulBand = 0; ulBand < ulNumBandsToDo; ++ulBand )
  825.             {
  826.                 memcpy( &WIArray[ulBand], &WI, sizeof( WI ) );
  827.                 WIArray[ulBand].DoBnds[DXB_Y].Min = Start;
  828.                 WIArray[ulBand].OutputBnds[DXB_Y].Min = Start + OutputYDelta;
  829.                 WIArray[ulBand].DoBnds[DXB_Y].Max = Start + Count;
  830.                 WIArray[ulBand].OutputBnds[DXB_Y].Max = Start + Count + OutputYDelta;
  831.  
  832.                 TaskInfo[ulBand].pfnTaskProc      = _TaskProc;
  833.                 TaskInfo[ulBand].pTaskData        = &WIArray[ulBand];
  834.                 TaskInfo[ulBand].pfnCompletionAPC = NULL;
  835.                 TaskInfo[ulBand].dwCompletionData = 0;
  836.                 TaskInfo[ulBand].pRequestID       = pRequestID;
  837.  
  838.                 //--- Advance
  839.                 Start += Count;
  840.                 //--- Check for a remainder and add on to the last band.
  841.                 if( ( ulRowCount - ( Start + Count ) ) < Count )
  842.                 {
  843.                     Count = ulRowCount - Start;
  844.                 }
  845.             }
  846.  
  847.             //
  848.             //  Procedural surfaces (and perhaps some transforms) need to "know" that
  849.             //  they are in a multi-threaded work procedure to avoid deadlocks.  Procedural
  850.             //  surfaces need to allow LockSurface to work WITHOUT taking the object
  851.             //  critical section.  Other transforms may also want to know this information
  852.             //  to avoid deadlocks.
  853.             //
  854.             m_bInMultiThreadWorkProc = TRUE;
  855.  
  856.             //--- Schedule the work and wait for it to complete
  857.             hr = m_cpTaskMgr->ScheduleTasks( TaskInfo, m_aEvent,
  858.                                              TaskIDs, ulNumBandsToDo, m_ulLockTimeOut );
  859.  
  860.             m_bInMultiThreadWorkProc = FALSE;
  861.  
  862.             //--- Check return codes from work info structures
  863.             //    return the first bad hr if any
  864.             for( ulBand = 0; SUCCEEDED( hr ) && ( ulBand < ulNumBandsToDo ); ++ulBand )
  865.             {
  866.                 hr = WIArray[ulBand].hr;
  867.                 if( hr != S_OK ) break;
  868.             }
  869.         }
  870.         OnFreeInstData( WI );
  871.     }
  872.  
  873. #ifdef _DEBUG
  874.     if( FAILED( hr ) ) DXTDBG_MSG1( _CRT_ERROR, "\nExecute failed. HR = %X", hr );
  875. #endif
  876.  
  877.     return hr;
  878. } /* CDXBaseNTo1::Execute */
  879.  
  880. /*****************************************************************************
  881. * CDXBaseNTo1::_ImageMapIn2Out *
  882. *------------------------------*
  883. *   Description:
  884. *-----------------------------------------------------------------------------
  885. *   Created By: RAL                            Date: 07/28/97
  886. *****************************************************************************/
  887. HRESULT CDXBaseNTo1::_ImageMapIn2Out( CDXDBnds & bnds, ULONG ulNumInBnds,
  888.                                       const CDXDBnds * pInBounds )
  889. {
  890.     HRESULT hr = S_OK;
  891.     if(ulNumInBnds)
  892.     {
  893.         for(ULONG i = 0; i < ulNumInBnds; ++i )
  894.         {
  895.             bnds |= pInBounds[i];
  896.         }
  897.     }
  898.     else
  899.     {
  900.         for( ULONG i = 0; SUCCEEDED(hr) && i < m_ulNumInputs; ++i )
  901.         {
  902.             if (InputSurface(i))
  903.             {
  904.                 CDXDBnds SurfBnds(InputSurface(i), hr);
  905.                 bnds |= SurfBnds;
  906.             }
  907.         }
  908.     }
  909.     if (SUCCEEDED(hr))
  910.     {
  911.         hr = DetermineBnds(bnds);
  912.     }
  913.     return hr;
  914. } /* CDXBaseNTo1::_ImageMapIn2Out */
  915.  
  916. /*****************************************************************************
  917. * CDXBaseNTo1::_MeshMapIn2Out *
  918. *-----------------------------*
  919. *   Description:
  920. *-----------------------------------------------------------------------------
  921. *   Created By: RAL                            Date: 07/28/97
  922. *****************************************************************************/
  923. HRESULT CDXBaseNTo1::_MeshMapIn2Out(CDXCBnds & bnds, ULONG ulNumInBnds, CDXCBnds * pInBounds)
  924. {
  925.     HRESULT hr = S_OK;
  926.     if (m_dwOptionFlags & DXBOF_INPUTS_MESHBUILDER)
  927.     {
  928.         if(ulNumInBnds)
  929.         {
  930.             for(ULONG i = 0; i < ulNumInBnds; ++i )
  931.             {
  932.                 bnds |= pInBounds[i];
  933.             }
  934.         }
  935.         else
  936.         {
  937.             for(ULONG i = 0; SUCCEEDED(hr) && i < m_ulNumInputs; ++i )
  938.             {
  939.                 if (InputMeshBuilder(i))
  940.                 {
  941.                     CDXCBnds MeshBnds(InputMeshBuilder(i), hr);
  942.                     bnds |= MeshBnds;
  943.                 }
  944.             }
  945.  
  946.         }
  947.     }
  948.     else
  949.     {
  950.         //  Already done -> bnds[DXB_T].Min = 0.0f;
  951.         bnds[DXB_X].Min = bnds[DXB_Y].Min = bnds[DXB_Z].Min = -1.0f;
  952.         bnds[DXB_X].Max = bnds[DXB_Y].Max = bnds[DXB_Z].Max = bnds[DXB_T].Max = 1.0f;
  953.     }
  954.  
  955.     //
  956.     //  Call the derived class to get the scale values.
  957.     //
  958.     if (SUCCEEDED(hr))
  959.     {
  960.     // Increase the size just a bit so we won't have rounding errors
  961.     // result in bounds that don't actually contain the result.
  962.     const float fBndsIncrease = 0.0001F;
  963.     float fTemp = bnds.Width() * fBndsIncrease;
  964.  
  965.     bnds[DXB_X].Min -= fTemp;
  966.     bnds[DXB_X].Max += fTemp;
  967.  
  968.     fTemp = fBndsIncrease * bnds.Height();
  969.     bnds[DXB_Y].Min -= fTemp;
  970.     bnds[DXB_Y].Max += fTemp;
  971.  
  972.     fTemp = fBndsIncrease * bnds.Depth();
  973.     bnds[DXB_Z].Min -= fTemp;
  974.     bnds[DXB_Z].Max += fTemp;
  975.  
  976.         hr = DetermineBnds(bnds);
  977.     }
  978.     return hr;
  979. } /* CDXBaseNTo1::_MeshMapIn2Out */
  980.  
  981. /*****************************************************************************
  982. * CDXBaseNTo1::MapBoundsIn2Out *
  983. *------------------------------*
  984. *   Description:
  985. *       The MapBoundsIn2Out method is used to perform coordinate transformation
  986. *   from the input to the output coordinate space.
  987. *-----------------------------------------------------------------------------
  988. *   Created By: Ed Connell                            Date: 07/28/97
  989. *-----------------------------------------------------------------------------
  990. *   Parameters:
  991. *****************************************************************************/
  992. STDMETHODIMP CDXBaseNTo1::MapBoundsIn2Out( const DXBNDS *pInBounds, ULONG ulNumInBnds,
  993.                                            ULONG ulOutIndex, DXBNDS *pOutBounds )
  994. {
  995.     DXTDBG_FUNC( "CDXBaseNTo1::MapBoundsIn2Out" );
  996.     if((ulNumInBnds && DXIsBadReadPtr( pInBounds, ulNumInBnds * sizeof( *pInBounds ) )) ||
  997.         ulOutIndex)
  998.     {
  999.         return E_INVALIDARG;
  1000.     }
  1001.  
  1002.     if( DXIsBadWritePtr( pOutBounds, sizeof( *pOutBounds ) ) )
  1003.     {
  1004.         return E_POINTER;
  1005.     }
  1006.     //
  1007.     //  Set the bounds to empty and the appropriate type.
  1008.     //
  1009.     memset(pOutBounds, 0, sizeof(*pOutBounds));
  1010.     _ASSERT(DXBT_DISCRETE == 0);
  1011.     if (m_dwOptionFlags & DXBOF_OUTPUT_MESHBUILDER)
  1012.     {
  1013.         pOutBounds->eType = DXBT_CONTINUOUS;
  1014.     }
  1015.  
  1016.     //
  1017.     //  Make sure all input bounds are of the correct type.
  1018.     //
  1019.     if( ulNumInBnds )
  1020.     {
  1021.         DXBNDTYPE eType = (m_dwOptionFlags & DXBOF_INPUTS_MESHBUILDER) ? DXBT_CONTINUOUS : DXBT_DISCRETE;
  1022.         for (ULONG i = 0; i < ulNumInBnds; i++)
  1023.         {
  1024.             if (pInBounds[i].eType != eType)
  1025.             {
  1026.                 return E_INVALIDARG;
  1027.             }
  1028.         }
  1029.     }
  1030.  
  1031.     //
  1032.     //  Now do the appropriate mapping
  1033.     //
  1034.     if (m_dwOptionFlags & DXBOF_OUTPUT_MESHBUILDER)
  1035.     {
  1036.         //
  1037.         //  NOTE:  In the case of non-mesh inputs, the inputs are discrete, but they will
  1038.         //         be completely ignored by the function so it's OK to cast them to CDXCBnds
  1039.         //
  1040.         return _MeshMapIn2Out(*((CDXCBnds *)pOutBounds), ulNumInBnds, (CDXCBnds *)pInBounds);
  1041.     }
  1042.     else 
  1043.     {
  1044.         return _ImageMapIn2Out(*(CDXDBnds *)pOutBounds, ulNumInBnds, (CDXDBnds *)pInBounds);
  1045.     }
  1046. } /* CDXBaseNTo1::MapBoundsIn2Out */
  1047.  
  1048. /*****************************************************************************
  1049. * CDXBaseNTo1::MapBoundsOut2In *
  1050. *------------------------------*
  1051. *   Description:
  1052. *       The MapBoundsOut2In method is used to perform coordinate transformation
  1053. *   from the input to the output coordinate space.
  1054. *-----------------------------------------------------------------------------
  1055. *   Created By: Ed Connell                            Date: 07/28/97
  1056. *-----------------------------------------------------------------------------
  1057. *   Parameters:
  1058. *****************************************************************************/
  1059. STDMETHODIMP CDXBaseNTo1::
  1060.     MapBoundsOut2In( ULONG ulOutIndex, const DXBNDS *pOutBounds, ULONG ulInIndex, DXBNDS *pInBounds )
  1061. {
  1062.     DXTDBG_FUNC( "CDXBaseNTo1::MapBoundsOut2In" );
  1063.     HRESULT hr = S_OK;
  1064.     
  1065.     if (m_dwOptionFlags & DXBOF_OUTPUT_MESHBUILDER)
  1066.     {
  1067.         hr = E_NOTIMPL;     // This is pointless for meshes.
  1068.     }
  1069.     else if(ulInIndex >= m_ulMaxInputs || ulOutIndex || DXIsBadReadPtr( pOutBounds, sizeof( *pOutBounds ) ) )
  1070.     {
  1071.         hr = E_INVALIDARG;
  1072.     }
  1073.     else if( DXIsBadWritePtr( pInBounds, sizeof( *pInBounds ) ) )
  1074.     {
  1075.         hr = E_POINTER;
  1076.     }
  1077.     else
  1078.     {
  1079.         *pInBounds = *pOutBounds;
  1080.     }
  1081.     return hr;
  1082. } /* CDXBaseNTo1::MapBoundsOut2In */
  1083.  
  1084. /*****************************************************************************
  1085. * CDXBaseNTo1::SetMiscFlags *
  1086. *---------------------------*
  1087. *   Description:
  1088. *-----------------------------------------------------------------------------
  1089. *   Created By: RAL                            Date: 10/30.97
  1090. *-----------------------------------------------------------------------------
  1091. *   Parameters:
  1092. *       bMiscFlags - New value to set 
  1093. *****************************************************************************/
  1094. STDMETHODIMP CDXBaseNTo1::SetMiscFlags( DWORD dwMiscFlags )
  1095. { 
  1096.     DXTDBG_FUNC( "CDXBaseNTo1::SetMiscFlags" );
  1097.     HRESULT hr = S_OK;
  1098.     Lock();
  1099.     WORD wOpts = (WORD)dwMiscFlags;     // Ignore high word.  Only set low word.
  1100.     if (((WORD)m_dwMiscFlags) != wOpts)
  1101.     {
  1102.         if ((wOpts & (~DXTMF_VALID_OPTIONS)) ||
  1103.             ((wOpts & DXTMF_BLEND_WITH_OUTPUT) && (m_dwMiscFlags & DXTMF_BLEND_SUPPORTED) == 0) ||
  1104.             ((wOpts & DXTMF_DITHER_OUTPUT) && (m_dwMiscFlags & DXTMF_DITHER_SUPPORTED) == 0))
  1105.         {
  1106.             hr = E_INVALIDARG;
  1107.         }
  1108.         else
  1109.         {
  1110.             m_dwMiscFlags &= 0xFFFF0000;
  1111.             m_dwMiscFlags |= wOpts;
  1112.             _UpdateBltFlags();
  1113.             m_dwGenerationId++;
  1114.         }
  1115.     }
  1116.     Unlock();  
  1117.     return hr;
  1118. } /* CDXBaseNTo1::SetMiscFlags */
  1119.  
  1120. /*****************************************************************************
  1121. * CDXBaseNTo1::GetMiscFlags *
  1122. *----------------------------*
  1123. *   Description:
  1124. *-----------------------------------------------------------------------------
  1125. *   Created By: RAL                            Date: 10/30/97
  1126. *-----------------------------------------------------------------------------
  1127. *   Parameters:
  1128. *****************************************************************************/
  1129. STDMETHODIMP CDXBaseNTo1::GetMiscFlags( DWORD* pdwMiscFlags )
  1130. {
  1131.     if( DXIsBadWritePtr( pdwMiscFlags, sizeof( *pdwMiscFlags ) ) )
  1132.     {
  1133.         return E_POINTER;
  1134.     }
  1135.     *pdwMiscFlags = m_dwMiscFlags;
  1136.     return S_OK;
  1137. } /* CDXBaseNTo1::GetMiscFlags */
  1138.  
  1139.  
  1140. /*****************************************************************************
  1141. * CDXBaseNTo1::SetQuality *
  1142. *----------------------------*
  1143. *   Description:
  1144. *-----------------------------------------------------------------------------
  1145. *   Created By: RAL                            Date: 10/30/97
  1146. *-----------------------------------------------------------------------------
  1147. *   Parameters:
  1148. *****************************************************************************/
  1149. STDMETHODIMP CDXBaseNTo1::SetQuality(float fQuality)
  1150. {
  1151.     if ((m_dwMiscFlags & DXTMF_QUALITY_SUPPORTED) == 0)
  1152.     {
  1153.         return E_NOTIMPL;
  1154.     }
  1155.  
  1156.     if (fQuality < 0.0f || fQuality > 1.0f)
  1157.     {
  1158.         return E_INVALIDARG;
  1159.     }
  1160.  
  1161.     Lock();
  1162.     if (m_fQuality != fQuality)
  1163.     {
  1164.         m_fQuality = fQuality;
  1165.         m_dwGenerationId++;
  1166.     }
  1167.     Unlock();
  1168.  
  1169.     return S_OK;
  1170. }
  1171.  
  1172. /*****************************************************************************
  1173. * CDXBaseNTo1::GetQuality *
  1174. *-------------------------*
  1175. *   Description:
  1176. *-----------------------------------------------------------------------------
  1177. *   Created By: RAL                            Date: 10/30/97
  1178. *-----------------------------------------------------------------------------
  1179. *   Parameters:
  1180. *****************************************************************************/
  1181.  
  1182. STDMETHODIMP CDXBaseNTo1::GetQuality(float *pfQuality)
  1183. {
  1184.     HRESULT hr = S_OK;
  1185.  
  1186.     if ((m_dwMiscFlags & DXTMF_QUALITY_SUPPORTED) == 0)
  1187.     {
  1188.         hr = E_NOTIMPL;
  1189.     }
  1190.     else 
  1191.     {
  1192.         if( DXIsBadWritePtr( pfQuality, sizeof( *pfQuality ) ) )
  1193.         {
  1194.             hr = E_POINTER;
  1195.         }
  1196.         else
  1197.         {
  1198.             *pfQuality = m_fQuality;
  1199.         }
  1200.     }
  1201.     return hr;
  1202. }
  1203.  
  1204.  
  1205.  
  1206. /*****************************************************************************
  1207. * GetInOutInfo
  1208. *-----------------------------------------------------------------------------
  1209. *   Description:
  1210. *-----------------------------------------------------------------------------
  1211. *   Created By: RAL                                 Date: 12/10/97
  1212. *-----------------------------------------------------------------------------
  1213. *   Parameters:
  1214. *****************************************************************************/
  1215. STDMETHODIMP CDXBaseNTo1::GetInOutInfo( BOOL bOutput, ULONG ulIndex, DWORD *pdwFlags,
  1216.                                         GUID * pIDs, ULONG *pcIDs, IUnknown **ppUnkCurObj )
  1217. {
  1218.     DXTDBG_FUNC( "CDXBaseNTo1::GetInOutInfo" );
  1219.     HRESULT hr = S_FALSE;
  1220.     DWORD dwFlags = 0;
  1221.     BOOL bImage;
  1222.     if( bOutput )
  1223.     {
  1224.         bImage = !(m_dwOptionFlags & DXBOF_OUTPUT_MESHBUILDER);
  1225.         if (ulIndex == 0)
  1226.         {
  1227.             hr = S_OK;
  1228.         }
  1229.     }
  1230.     else
  1231.     {
  1232.         bImage = !(m_dwOptionFlags & DXBOF_INPUTS_MESHBUILDER);
  1233.         if (ulIndex < m_ulMaxInputs)
  1234.         {
  1235.             hr = S_OK;
  1236.             if (ulIndex >= m_ulNumInRequired)
  1237.             {
  1238.                 dwFlags = DXINOUTF_OPTIONAL;
  1239.             }
  1240.         }
  1241.     }
  1242.     if( hr == S_OK )
  1243.     {
  1244.         if( pdwFlags && !DXIsBadWritePtr( pdwFlags, sizeof( *pdwFlags ) ) )
  1245.         {
  1246.             *pdwFlags = dwFlags;
  1247.         }
  1248.  
  1249.         if( pIDs )
  1250.         {
  1251.             if( DXIsBadWritePtr( pcIDs, sizeof( *pcIDs ) ) ||
  1252.                 DXIsBadWritePtr( pIDs, *pcIDs * sizeof( *pIDs ) ) )
  1253.             {
  1254.                 hr = E_INVALIDARG;
  1255.             }
  1256.             else
  1257.             {
  1258.                 if (bImage)
  1259.                 {
  1260.                     if (*pcIDs > 0)
  1261.                     {
  1262.                         pIDs[0] = IID_IDXSurface;
  1263.                     }
  1264.                     if (*pcIDs > 1)
  1265.                     {
  1266.                         pIDs[1] = IID_IDXDupDDrawSurface;
  1267.                     }
  1268.                     else
  1269.                     {
  1270.                         hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
  1271.                     }
  1272.                     *pcIDs = 2;
  1273.                 }
  1274.                 else
  1275.                 {
  1276.                     if (*pcIDs > 0)
  1277.                     {
  1278.                         pIDs[0] = IID_IDXDupDirect3DRMMeshBuilder3;
  1279.                     }
  1280.                     else
  1281.                     {
  1282.                         hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
  1283.                     }
  1284.                     *pcIDs = 1;
  1285.                 }
  1286.             }
  1287.         }
  1288.         else if( pcIDs )
  1289.         {
  1290.             if( DXIsBadWritePtr( pcIDs, sizeof( *pcIDs ) ) )
  1291.             {
  1292.                 hr = E_POINTER;
  1293.             }
  1294.             else
  1295.             {
  1296.                 *pcIDs = bImage ? 2 : 1;
  1297.             }
  1298.         }
  1299.         if (hr == S_OK && ppUnkCurObj)
  1300.         {
  1301.             if (DXIsBadWritePtr(ppUnkCurObj, sizeof(*ppUnkCurObj)))
  1302.             {
  1303.                 hr = E_POINTER;
  1304.             }
  1305.             else
  1306.             {
  1307.                 if (bOutput)
  1308.                 {
  1309.                     *ppUnkCurObj = m_Output.m_pNativeInterface;
  1310.                 }
  1311.                 else
  1312.                 {
  1313.                     *ppUnkCurObj = NULL;
  1314.                     if (ulIndex < GetNumInputs())
  1315.                     {
  1316.                         *ppUnkCurObj = m_aInputs[ulIndex].m_pUnkOriginalObject;
  1317.                     }
  1318.                 }
  1319.                 if (*ppUnkCurObj)
  1320.                 {
  1321.                     (*ppUnkCurObj)->AddRef();
  1322.                 }
  1323.             }
  1324.         }
  1325.     }
  1326.     return hr;
  1327. } /* CDXBaseNTo1::GetInOutInfo */
  1328.  
  1329. /*****************************************************************************
  1330. * CDXBaseNTo1::OnUpdateGenerationId *
  1331. *-----------------------------------*
  1332. *   Description:
  1333. *-----------------------------------------------------------------------------
  1334. *   Created By: RAL                                 Date: 12/10/97
  1335. *-----------------------------------------------------------------------------
  1336. *   Parameters:
  1337. *****************************************************************************/
  1338. void CDXBaseNTo1::OnUpdateGenerationId(void)
  1339. {
  1340.     DXTDBG_FUNC( "CDXBaseNTo1::OnUpdateGenerationId" );
  1341.     if( (m_dwMiscFlags & DXTMF_INPLACE_OPERATION) &&
  1342.         m_Output.UpdateGenerationId())
  1343.     {
  1344.         m_dwGenerationId++;
  1345.     }
  1346.     for (ULONG i = 0; i < m_ulNumInputs; i++)
  1347.     {
  1348.         if (m_aInputs[i].UpdateGenerationId())
  1349.         {
  1350.             m_dwGenerationId++;
  1351.         }
  1352.     }
  1353. } /* CDXBaseNTo1::OnUpdateGenerationId */
  1354.  
  1355. /*****************************************************************************
  1356. * CDXBaseNTo1::OnGetObjectSize *
  1357. *------------------------------*
  1358. *   Description:
  1359. *-----------------------------------------------------------------------------
  1360. *   Created By: RAL                                 Date: 12/10/97
  1361. *****************************************************************************/
  1362. ULONG CDXBaseNTo1::OnGetObjectSize(void)
  1363. {
  1364.     return sizeof(*this);
  1365. }
  1366.  
  1367. //
  1368. //  Effect interface
  1369. //
  1370.  
  1371. /*****************************************************************************
  1372. * CDXBaseNTo1::get_Progress *
  1373. *---------------------------*
  1374. *   Description:
  1375. *-----------------------------------------------------------------------------
  1376. *   Created By: RAL                                 Date: 12/10/97
  1377. *****************************************************************************/
  1378. STDMETHODIMP CDXBaseNTo1::get_Progress(float *pVal)
  1379. {
  1380.     DXTDBG_FUNC( "CDXBaseNTo1::get_Progress" );
  1381.     HRESULT hr = S_OK;
  1382.     if( DXIsBadWritePtr(pVal, sizeof(*pVal)) )
  1383.     {
  1384.         hr = E_POINTER;
  1385.     }
  1386.     else
  1387.     {
  1388.         *pVal = m_Progress;
  1389.     }
  1390.     return hr;
  1391. }
  1392.  
  1393. /*****************************************************************************
  1394. * CDXBaseNTo1::put_Progress *
  1395. *---------------------------*
  1396. *   Description:
  1397. *-----------------------------------------------------------------------------
  1398. *   Created By: RAL                                 Date: 12/10/97
  1399. *****************************************************************************/
  1400. STDMETHODIMP CDXBaseNTo1::put_Progress(float newVal)
  1401. {
  1402.     DXTDBG_FUNC( "CDXBaseNTo1::put_Progress" );
  1403.     HRESULT hr = S_OK;
  1404.     if (newVal < 0.0 || newVal > 1.0f)
  1405.     {
  1406.         hr = E_INVALIDARG;
  1407.     }
  1408.     else
  1409.     {
  1410.         Lock();
  1411.         m_Progress = newVal;
  1412.         m_dwCleanGenId++;       // This should not make the transform "dirty" internally
  1413.         m_dwGenerationId++;     
  1414.         Unlock();
  1415.     }
  1416.     return hr;
  1417. }
  1418.  
  1419. /*****************************************************************************
  1420. * CDXBaseNTo1::get_StepResolution *
  1421. *---------------------------------*
  1422. *   Description:
  1423. *-----------------------------------------------------------------------------
  1424. *   Created By: RAL                                 Date: 12/10/97
  1425. *****************************************************************************/
  1426. STDMETHODIMP CDXBaseNTo1::get_StepResolution(float *pVal)
  1427. {
  1428.     DXTDBG_FUNC( "CDXBaseNTo1::get_StepResolution" );
  1429.     HRESULT hr = S_OK;
  1430.     if( DXIsBadWritePtr(pVal, sizeof(*pVal)) )
  1431.     {
  1432.         hr = E_POINTER;
  1433.     }
  1434.     else
  1435.     {
  1436.         *pVal = m_StepResolution;
  1437.     }
  1438.     return hr;
  1439. }
  1440.  
  1441. /*****************************************************************************
  1442. * CDXBaseNTo1::get_Duration *
  1443. *---------------------------*
  1444. *   Description:
  1445. *-----------------------------------------------------------------------------
  1446. *   Created By: RAL                                 Date: 12/10/97
  1447. *****************************************************************************/
  1448. STDMETHODIMP CDXBaseNTo1::get_Duration(float *pVal)
  1449. {
  1450.     DXTDBG_FUNC( "CDXBaseNTo1::get_Duration" );
  1451.     if( DXIsBadWritePtr(pVal, sizeof(*pVal)) )
  1452.     {
  1453.         return E_POINTER;
  1454.     }
  1455.     else
  1456.     {
  1457.         *pVal = m_Duration;
  1458.     }
  1459.     return S_OK;
  1460. }
  1461.  
  1462. /*****************************************************************************
  1463. * CDXBaseNTo1::put_Duration *
  1464. *---------------------------*
  1465. *   Description:
  1466. *-----------------------------------------------------------------------------
  1467. *   Created By: RAL                                 Date: 12/10/97
  1468. *****************************************************************************/
  1469. STDMETHODIMP CDXBaseNTo1::put_Duration(float newVal)
  1470. {
  1471.     DXTDBG_FUNC( "CDXBaseNTo1::put_Duration" );
  1472.     if (newVal <= 0.)
  1473.     {
  1474.         return E_INVALIDARG;
  1475.     }
  1476.     if(newVal != m_Duration)
  1477.     {
  1478.     Lock();
  1479.     m_dwGenerationId++;
  1480.         m_dwCleanGenId++;       // This should not make the transform "dirty" internally
  1481.         m_Duration = newVal;
  1482.         Unlock();
  1483.     }
  1484.     return S_OK;
  1485. }
  1486.  
  1487.  
  1488. /*****************************************************************************
  1489. * CDXBaseNTo1::PointPick *
  1490. *------------------------*
  1491. *   Description:
  1492. *-----------------------------------------------------------------------------
  1493. *   Created By: RAL                                 Date: 5/5/98
  1494. *****************************************************************************/
  1495. STDMETHODIMP CDXBaseNTo1::PointPick(const DXVEC *pPoint,
  1496.                                     ULONG * pulInputSurfaceIndex,
  1497.                                     DXVEC *pInputPoint)
  1498. {
  1499.     HRESULT hr = S_OK;
  1500.     BOOL bFoundIt = FALSE;
  1501.     if (DXIsBadReadPtr(pPoint, sizeof(*pPoint)) || pPoint->eType != DXBT_DISCRETE)
  1502.     {
  1503.         hr = E_INVALIDARG;
  1504.     }
  1505.     else 
  1506.     {
  1507.         if (DXIsBadWritePtr(pulInputSurfaceIndex, sizeof(*pulInputSurfaceIndex)) ||
  1508.             DXIsBadWritePtr(pInputPoint, sizeof(*pInputPoint)))
  1509.         {
  1510.             hr = E_POINTER;
  1511.         }
  1512.         else 
  1513.         {
  1514.             CDXDBnds OutBndsPoint(*((CDXDVec *)pPoint));
  1515.             CDXDVec & InVec = *(new(pInputPoint) CDXDVec(*((CDXDVec *)pPoint)));
  1516.             HRESULT hr2 = OnSurfacePick(OutBndsPoint, *pulInputSurfaceIndex, InVec);
  1517.             if (hr2 != E_NOTIMPL)
  1518.             {
  1519.                 hr = hr2;
  1520.             }
  1521.             else
  1522.             {
  1523.                 //--- The derived class does not implement so we will do
  1524.                 //    the hit test against the input for them.
  1525.                 ULONG * aulInIndex = (ULONG *)_alloca(sizeof(ULONG) * m_ulMaxInputs);
  1526.                 BYTE * aWeights = (BYTE *)_alloca(sizeof(BYTE) * m_ulMaxInputs);
  1527.                 ULONG ulNumToTest;
  1528.                 OnGetSurfacePickOrder(OutBndsPoint, ulNumToTest, aulInIndex, aWeights);
  1529.  
  1530.                 if( m_bPickDoneByBase && ( m_ulNumInputs > 1 ) )
  1531.                 {
  1532.                     //--- We don't know how to do multi-input picking from the base.
  1533.                     hr = E_NOTIMPL;
  1534.                 }
  1535.  
  1536.                 for (ULONG i = 0; SUCCEEDED(hr) && i < ulNumToTest; i++)
  1537.                 {
  1538.                     ULONG ulInput = aulInIndex[i];
  1539.                     if (HaveInput(ulInput) && aWeights[i])
  1540.                     {
  1541.                         CDXDBnds Out2InBnds(false);
  1542.                         hr = MapBoundsOut2In(0, &OutBndsPoint, ulInput, &Out2InBnds);
  1543.                         if (SUCCEEDED(hr))
  1544.                         {
  1545.                             CDXDBnds InSurfBnds(InputSurface(ulInput), hr);
  1546.                             if (SUCCEEDED(hr) && InSurfBnds.IntersectBounds(Out2InBnds))
  1547.                             {
  1548.                                 IDXARGBReadPtr * pPtr;
  1549.                                 hr = InputSurface(ulInput)->LockSurface(&InSurfBnds, m_ulLockTimeOut, DXLOCKF_READ, 
  1550.                                                                         IID_IDXARGBReadPtr, (void **)&pPtr, NULL);
  1551.                                 if( SUCCEEDED(hr) )
  1552.                                 {
  1553.                                     DXPMSAMPLE val;
  1554.                                     pPtr->UnpackPremult(&val, 1, FALSE);
  1555.                                     pPtr->Release();
  1556.                                     if (val.Alpha * aWeights[i] / 255)
  1557.                                     {
  1558.                                         InSurfBnds.GetMinVector(InVec);
  1559.                                         bFoundIt = TRUE;
  1560.                                         *pulInputSurfaceIndex = ulInput;
  1561.                                         break;
  1562.                                     }
  1563.                                 }
  1564.                             }   
  1565.                         }
  1566.                     }
  1567.                 }
  1568.                 if (SUCCEEDED(hr) & (!bFoundIt))
  1569.                 {
  1570.                     hr = S_FALSE;
  1571.                 }
  1572.             }
  1573.         }
  1574.     }
  1575.     return hr;
  1576. } /* CDXBaseNTo1::PointPick */
  1577.  
  1578. /*****************************************************************************
  1579. * RegisterTansform (STATIC member function)
  1580. *-----------------------------------------------------------------------------
  1581. *   Description:
  1582. *-----------------------------------------------------------------------------
  1583. *   Created By: RAL                                 Date: 12/10/97
  1584. *-----------------------------------------------------------------------------
  1585. *   Parameters:
  1586. *****************************************************************************/
  1587. HRESULT CDXBaseNTo1::
  1588. RegisterTransform(REFCLSID rcid, int ResourceId, ULONG cCatImpl, const CATID * pCatImpl,
  1589.                   ULONG cCatReq, const CATID * pCatReq, BOOL bRegister)
  1590. {
  1591.     DXTDBG_FUNC( "CDXBaseNTo1::RegisterTransform" );
  1592.     HRESULT hr = bRegister ? _Module.UpdateRegistryFromResource(ResourceId, bRegister) : S_OK;
  1593.     if (SUCCEEDED(hr))
  1594.     {
  1595.         CComPtr<ICatRegister> pCatRegister;
  1596.         HRESULT hr = ::CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC, IID_ICatRegister, (void **)&pCatRegister);
  1597.         if (SUCCEEDED(hr))
  1598.         {
  1599.             if (bRegister)
  1600.             {
  1601.                 hr = pCatRegister->RegisterClassImplCategories(rcid, cCatImpl, (CATID *)pCatImpl);
  1602.                 if (SUCCEEDED(hr) && cCatReq && pCatReq) {
  1603.                     hr = pCatRegister->RegisterClassReqCategories(rcid, cCatReq, (CATID *)pCatReq);
  1604.                 }
  1605.             } 
  1606.             else
  1607.             {
  1608.                 pCatRegister->UnRegisterClassImplCategories(rcid, cCatImpl, (CATID *)pCatImpl);
  1609.                 if (cCatReq && pCatReq)
  1610.                 {
  1611.                     pCatRegister->UnRegisterClassReqCategories(rcid, cCatReq, (CATID *)pCatReq);
  1612.                 }
  1613.             }
  1614.         }
  1615.     }
  1616.     if ((!bRegister) && SUCCEEDED(hr)) 
  1617.     { 
  1618.         _Module.UpdateRegistryFromResource(ResourceId, bRegister);
  1619.     }
  1620.     return hr;
  1621. }
  1622.  
  1623. //
  1624. //  BUGBUG -- try/except around this !
  1625. //  
  1626. void CDXBaseNTo1::_TaskProc(void* pTaskInfo, BOOL* pbContinue )
  1627. { 
  1628.     _ASSERT( pTaskInfo );
  1629.     CDXTWorkInfoNTo1& WI = *((CDXTWorkInfoNTo1 *)pTaskInfo);
  1630.     CDXBaseNTo1& This = *((CDXBaseNTo1 *)WI.pvThis);
  1631.     WI.hr = This.WorkProc(WI, pbContinue);
  1632. }
  1633.  
  1634.