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);
}
}
