void UnzipBase::__init(void* handle) // ownership is passed in, must be called after __openUnzip()
{
finish();
_handle=handle;
buildIndices();
}
dae_reader_t *createDAEReader(char *path)
{
dae_reader_t *reader = init();
MSXML2::IXMLDOMDocument2Ptr xmlDoc = setupXMLParser(path);
if (!xmlDoc)
{
printf("Cannot open model file %s\n", path);
return NULL;
}
getAxisOrientation(reader, xmlDoc);
readGeometry(reader, xmlDoc);
long l0 = clock();
for (uint32_t i = 0; i < reader->geometry.size(); i++)
{
buildIndices(reader, i);
}
long l1 = clock();
printf("%i\n", l1 - l0);
return reader;
}
void ElTerrain::render(ElCamera* camera, TimeValue t)
{
buildIndices(camera);
if (mNumIndex == 0)
return;
IDirect3DDevice9* d3dDevice = ElDeviceManager::getDevice();
d3dDevice->SetVertexDeclaration(mVertexDeclaration);
d3dDevice->SetStreamSource(0, mVertexBuffer, 0, sizeof(VERTEX));
d3dDevice->SetIndices(mIndexBuffer);
mShader->render(camera);
}
QMatchData QUnsortedModelEngine::filter(const QString& part, const QModelIndex& parent, int n)
{
QMatchData hint;
QVector<int> v;
QIndexMapper im(v);
QMatchData m(im, -1, true);
const QAbstractItemModel *model = c->proxy->sourceModel();
bool foundInCache = lookupCache(part, parent, &m);
if (!foundInCache) {
if (matchHint(part, parent, &hint) && !hint.isValid())
return QMatchData();
}
if (!foundInCache && !hint.isValid()) {
const int lastRow = model->rowCount(parent) - 1;
QIndexMapper all(0, lastRow);
int lastIndex = buildIndices(part, parent, n, all, &m);
m.partial = (lastIndex != lastRow);
} else {
if (!foundInCache) { // build from hint as much as we can
buildIndices(part, parent, INT_MAX, hint.indices, &m);
m.partial = hint.partial;
}
if (m.partial && ((n == -1 && m.exactMatchIndex == -1) || (m.indices.count() < n))) {
// need more and have more
const int lastRow = model->rowCount(parent) - 1;
QIndexMapper rest(hint.indices.last() + 1, lastRow);
int want = n == -1 ? -1 : n - m.indices.count();
int lastIndex = buildIndices(part, parent, want, rest, &m);
m.partial = (lastRow != lastIndex);
}
}
saveInCache(part, parent, m);
return m;
}
void QUnsortedModelEngine::filterOnDemand(int n)
{
Q_ASSERT(matchCount());
if (!curMatch.partial)
return;
Q_ASSERT(n >= -1);
const QAbstractItemModel *model = c->proxy->sourceModel();
int lastRow = model->rowCount(curParent) - 1;
QIndexMapper im(curMatch.indices.last() + 1, lastRow);
int lastIndex = buildIndices(curParts.last(), curParent, n, im, &curMatch);
curMatch.partial = (lastRow != lastIndex);
saveInCache(curParts.last(), curParent, curMatch);
}
void CpuClipmapRenderer::onRender( const ClipmapRenderParameters& renderParameters )
{
// activate the gpu program:
//glDisable( GL_LIGHTING );
#ifdef OLD_GEOCLIP
terrainShader_.activate();
if( programTextChanged_ )
{
reloadShader();
programTextChanged_ = false;
}
#else
_pTerrainShader->activate(renderParameters.drawEnv);
#endif
// bool useDependentTextureLookup = false;
if( renderParameters.globalTextureObj != NULL )
{
renderParameters.globalTextureObj->activate( renderParameters.drawEnv );
renderParameters.globalTextureEnv->activate( renderParameters.drawEnv );
}
else if( renderParameters.heightColorTexture != NULL )
{
// todo: use a different pixel shader here
// useDependentTextureLookup = true;
renderParameters.heightColorTexture->activate( renderParameters.drawEnv );
}
// render all levels from finest to coarsest:
const int levelCount = int(levels_.size());
// for( int i = 0; i < levelCount; ++i )
for( int i = 0; i < levelCount; ++i )
{
int levelIdx = levelCount - i - 1;
//std::cerr << "Rendering Level " << levelIdx << std::endl;
GeometryClipmapLevel& level = geoClipmaps_->getLevel( levelIdx );
GeometryClipmapLevel* coarserLevel = 0;
GeometryClipmapLevel* finerLevel = 0;
if( levelIdx > 0 )
{
coarserLevel = &geoClipmaps_->getLevel( levelIdx - 1 );
}
if( levelIdx + 1 < levelCount )
{
finerLevel = &geoClipmaps_->getLevel( levelIdx + 1 );
}
const Color3f& debugColor = getDebugColor( levelIdx );
#ifdef OLD_GEOCLIP
terrainShader_.setUniform(
"baseColor0", colorToVector( debugColor ) );
terrainShader_.setUniform(
"sampleDistance",
renderParameters.worldTransform.sampleDistance );
terrainShader_.setUniform(
"worldOffset",
renderParameters.worldTransform.offset );
terrainShader_.setUniform(
"heightScale",
renderParameters.worldTransform.heightScale );
terrainShader_.setUniform(
"heightOffset",
renderParameters.worldTransform.heightOffset );
#else
#ifdef NOTUSED
_pTerrainShader->setUniformParameter(
"baseColor0", colorToVector( debugColor ) );
#endif
_pTerrainShader->addUniformVariable(
"sampleDistance",
renderParameters.worldTransform.sampleDistance );
_pTerrainShader->addUniformVariable(
"worldOffset",
renderParameters.worldTransform.offset );
_pTerrainShader->addUniformVariable(
"heightScale",
renderParameters.worldTransform.heightScale );
_pTerrainShader->addUniformVariable(
"heightOffset",
renderParameters.worldTransform.heightOffset );
#endif
if( renderParameters.showTransitionRegions )
{
// todo: add a sensible debug representation..
drawSampleRectangle( level.getCoveredSampleRect(),
debugColor,
renderParameters.worldTransform );
//drawSamples( level, Color3f( 0, 1, 0 ) );
//drawVertices( level, debugColor );
drawBlendLines( level,
debugColor,
renderParameters.worldTransform );
}
if( !level.isActive )
{
continue;
}
// only use the finer level, if it is active:
if( finerLevel && !finerLevel->isActive )
{
finerLevel = 0;
}
// buildIndices dynamically builds the indices for this level and
// does frustum culling
// the method returns false if nothing is visible
// todo: dont rebuild the indices every time.. just rebuild them if
// something changed (inside the update() call)
if( buildIndices( level, finerLevel ) )
{
// finally: draw the block:
renderBlock( level, coarserLevel, renderParameters, debugColor );
}
stats_.drawnLevelCount++;
}
if( renderParameters.globalTextureObj != NULL )
{
renderParameters.globalTextureObj->deactivate(
renderParameters.drawEnv );
renderParameters.globalTextureEnv->deactivate(
renderParameters.drawEnv );
}
else if(renderParameters.heightColorTexture != NULL)
{
renderParameters.heightColorTexture->deactivate(
renderParameters.drawEnv );
}
#ifdef OLD_GEOCLIP
terrainShader_.deactivate();
#else
_pTerrainShader->deactivate(renderParameters.drawEnv);
#endif
}
IndexVector buildCircuitIndices(const std::string& expr) const {
return buildIndices(expr, circuitBegin(), circuitEnd());
}
IndexVector buildContactIndices(const std::string& expr) const {
return buildIndices(expr, contactBegin(), contactEnd());
}
void Manager::initialize(const std::string & f )
{
parseIndexDefinitions( f );
buildDeviceList();
buildIndices();
}
