STDMETHODIMP CAVIStreamRemote::QueryInterface(const IID& iid, void **ppv) { _RPT1(0,"%08lx->CAVIStreamRemote::QueryInterface()\n", this); _RPT3(0,"\tGUID: {%08lx-%04x-%04x-", iid.Data1, iid.Data2, iid.Data3); _RPT4(0,"%02x%02x-%02x%02x", iid.Data4[0], iid.Data4[1], iid.Data4[2], iid.Data4[3]); _RPT4(0,"%02x%02x%02x%02x} (", iid.Data4[4], iid.Data4[5], iid.Data4[6], iid.Data4[7]); if (iid == IID_IUnknown) { *ppv = (IUnknown *)this; _RPT0(0,"IUnknown)\n"); } else if (iid == IID_IClassFactory) { *ppv = (IClassFactory *)&iclassfactory; _RPT0(0,"IClassFactory)\n"); } else if (iid == IID_IAVIStream) { *ppv = (IAVIStream *)this; _RPT0(0,"IAVIStream)\n"); } else { _RPT0(0,"unknown)\n"); *ppv = NULL; return ResultFromScode(E_NOINTERFACE); } AddRef(); return NULL; }
void RemapVertices(BOOL bAsOpened) { {INDEX ctSurf = 0; // fill remap array with indices of vertices in order how they appear per polygons {FOREACHINDYNAMICCONTAINER(acmMaterials, ConversionMaterial, itcm) { _RPT1(_CRT_WARN, "Indices of polygons in surface %d:", ctSurf); // for each polygon in surface {FOREACHINDYNAMICCONTAINER(itcm->ms_Polygons, INDEX, itipol) { _RPT1(_CRT_WARN, " %d,", *itipol); }} _RPT0(_CRT_WARN, "\n"); ctSurf++; }} _RPT0(_CRT_WARN, "Polygons and their vertex indices:\n"); for( INDEX ipol=0; ipol<actTriangles.Count(); ipol++) { INDEX idxVtx0 = actTriangles[ipol].ct_iVtx[0]; INDEX idxVtx1 = actTriangles[ipol].ct_iVtx[1]; INDEX idxVtx2 = actTriangles[ipol].ct_iVtx[2]; _RPT4(_CRT_WARN, "Indices of vertices in polygon %d : (%d, %d, %d)\n", ipol, idxVtx0, idxVtx1, idxVtx2); }}
/*!*************************************************************************** @Function PVRTGeometrySort @Modified pVtxData Pointer to array of vertices @Modified pwIdx Pointer to array of indices @Input nStride Size of a vertex (in bytes) @Input nVertNum Number of vertices. Length of pVtxData array @Input nTriNum Number of triangles. Length of pwIdx array is 3* this @Input nBufferVtxLimit Number of vertices that can be stored in a buffer @Input nBufferTriLimit Number of triangles that can be stored in a buffer @Input dwFlags PVRTGEOMETRY_SORT_* flags @Description Triangle sorter *****************************************************************************/ void PVRTGeometrySort( void * const pVtxData, PVRTGEOMETRY_IDX * const pwIdx, const int nStride, const int nVertNum, const int nTriNum, const int nBufferVtxLimit, const int nBufferTriLimit, const unsigned int dwFlags) { CObject sOb(pwIdx, nVertNum, nTriNum, nBufferVtxLimit, nBufferTriLimit); CBlock sBlock(nBufferVtxLimit, nBufferTriLimit); PVRTGEOMETRY_IDX *pwIdxOut; int nTriCnt, nVtxCnt; int nOutTriCnt, nOutVtxCnt, nOutBlockCnt; int nMeshToResize; #ifdef PVRTRISORT_ENABLE_VERIFY_RESULTS int i; int pnBlockTriCnt[PVRVGPBLOCKTEST_MAX_BLOCKS]; SVGPModel sVGPMdlBefore; SVGPModel sVGPMdlAfter; #endif if(dwFlags & PVRTGEOMETRY_SORT_VERTEXCACHE) { #ifdef PVRTRISORT_ENABLE_VERIFY_RESULTS VGP590Test(&sVGPMdlBefore, pwIdx, nTriNum); _RPT4(_CRT_WARN, "OptimiseTriListPVR() Before: Tri: %d, Vtx: %d, vtx/tri=%f Blocks=%d\n", nTriNum, sVGPMdlBefore.nVtxCnt, (float)sVGPMdlBefore.nVtxCnt / (float)nTriNum, sVGPMdlBefore.nBlockCnt); #endif pwIdxOut = (PVRTGEOMETRY_IDX*)malloc(nTriNum * 3 * sizeof(*pwIdxOut)); _ASSERT(pwIdxOut); // Sort geometry into blocks nOutTriCnt = 0; nOutVtxCnt = 0; nOutBlockCnt = 0; do { // Clear & fill the block sBlock.Clear(); nMeshToResize = sBlock.Fill(&sOb); // Copy indices into output sBlock.Output(&pwIdxOut[3*nOutTriCnt], &nVtxCnt, &nTriCnt, &sOb); sOb.m_nTriNumFree -= nTriCnt; nOutTriCnt += nTriCnt; if(nMeshToResize >= 0) { SMesh *pMesh; _ASSERT(nMeshToResize <= (nBufferVtxLimit-3)); pMesh = &sOb.m_pvMesh[nMeshToResize].back(); sOb.ResizeMesh(pMesh->nVtxNum, pMesh->ppVtx); sOb.m_pvMesh[nMeshToResize].pop_back(); } _ASSERT(nVtxCnt <= nBufferVtxLimit); _ASSERT(nTriCnt <= nBufferTriLimit); #ifdef PVRTRISORT_ENABLE_VERIFY_RESULTS _ASSERT(nOutBlockCnt < PVRVGPBLOCKTEST_MAX_BLOCKS); pnBlockTriCnt[nOutBlockCnt] = nTriCnt; #endif nOutVtxCnt += nVtxCnt; nOutBlockCnt++; // _RPT4(_CRT_WARN, "%d/%d tris (+%d), %d blocks\n", nOutTriCnt, nTriNum, nTriCnt, nOutBlockCnt); _ASSERT(nTriCnt == nBufferTriLimit || (nBufferVtxLimit - nVtxCnt) < 3 || nOutTriCnt == nTriNum); } while(nOutTriCnt < nTriNum); _ASSERT(nOutTriCnt == nTriNum); // The following will fail if optimising a subset of the mesh (e.g. a bone batching) //_ASSERT(nOutVtxCnt >= nVertNum); // Done! memcpy(pwIdx, pwIdxOut, nTriNum * 3 * sizeof(*pwIdx)); FREE(pwIdxOut); _RPT3(_CRT_WARN, "OptimiseTriListPVR() In: Tri: %d, Vtx: %d, vtx/tri=%f\n", nTriNum, nVertNum, (float)nVertNum / (float)nTriNum); _RPT4(_CRT_WARN, "OptimiseTriListPVR() HW: Tri: %d, Vtx: %d, vtx/tri=%f Blocks=%d\n", nOutTriCnt, nOutVtxCnt, (float)nOutVtxCnt / (float)nOutTriCnt, nOutBlockCnt); #ifdef PVRTRISORT_ENABLE_VERIFY_RESULTS VGP590Test(&sVGPMdlAfter, pwIdx, nTriNum); _RPT4(_CRT_WARN, "OptimiseTriListPVR() After : Tri: %d, Vtx: %d, vtx/tri=%f Blocks=%d\n", nTriNum, sVGPMdlAfter.nVtxCnt, (float)sVGPMdlAfter.nVtxCnt / (float)nTriNum, sVGPMdlAfter.nBlockCnt); _ASSERTE(sVGPMdlAfter.nVtxCnt <= sVGPMdlBefore.nVtxCnt); _ASSERTE(sVGPMdlAfter.nBlockCnt <= sVGPMdlBefore.nBlockCnt); for(i = 0; i < nOutBlockCnt; ++i) { _ASSERT(pnBlockTriCnt[i] == sVGPMdlAfter.pnBlockTriCnt[i]); } #endif } if(!(dwFlags & PVRTGEOMETRY_SORT_IGNOREVERTS)) { // Re-order the vertices so maybe they're accessed in a more linear // manner. Should cut page-breaks on the initial memory read of // vertices. Affects both the order of vertices, and the values // of indices, but the triangle order is unchanged. SortVertices(pVtxData, pwIdx, nStride, nVertNum, nTriNum*3); } }