void restoreDirectory (GmZipFileReader * pSetReader
, const wxString & szDestPath
, GmWriter * pWriter
, GmRestOp option
, GmExecUnitBase * pExecUnit
, GmTempEvent * pEvent
, GmUifSourceEntry * pEntry
, GmDirectoryNode<GmLeafNode> * pDirectory
, ubyte4 uiTotalSets
, const wxString & prefixPath)
{
if ((option & GRP_NEW_PLACE) == GRP_NEW_PLACE) {
assert (pWriter);
wxString path = getSourcePath (pWriter, pEntry, szDestPath);
pWriter->SetDestPath (path);
pSetReader->restoreFile (pWriter, pDirectory, prefixPath, uiTotalSets, pEvent);
}
else { // !GRP_NEW_PLACE
assert (pWriter == 0);
GmWriter * pWriter2 = createWriter (pSetReader, pEntry, option, pExecUnit, 0);
if (pWriter2 == 0) {
wxString msg;
throw GmException (msg);
}
pSetReader->restoreFile (pWriter2, pDirectory, prefixPath, uiTotalSets, 0);
delete pWriter2;
}
return;
}
FileFsType::FileFsType(QWidget *parent, QString _type) :
_FsType(parent, _type)
{
source->setPlaceholderText("Source host file");
target->setPlaceholderText("Target guest directory");
connect(sourceLabel, SIGNAL(clicked()),
this, SLOT(getSourcePath()));
}
void TranslatorHLSL::translate(TIntermNode *root, int compileOptions)
{
const ShBuiltInResources &resources = getResources();
int numRenderTargets = resources.EXT_draw_buffers ? resources.MaxDrawBuffers : 1;
sh::OutputHLSL outputHLSL(getShaderType(), getShaderVersion(), getExtensionBehavior(),
getSourcePath(), getOutputType(), numRenderTargets, getUniforms(), compileOptions);
outputHLSL.output(root, getInfoSink().obj);
mInterfaceBlockRegisterMap = outputHLSL.getInterfaceBlockRegisterMap();
mUniformRegisterMap = outputHLSL.getUniformRegisterMap();
}
void PathCache::precache(const SkPath* path, const SkPaint* paint) {
if (!Caches::getInstance().tasks.canRunTasks()) {
return;
}
path = getSourcePath(path);
PathDescription entry(kShapePath, paint);
entry.shape.path.mPath = path;
PathTexture* texture = mCache.get(entry);
bool generate = false;
if (!texture) {
generate = true;
} else if (path->getGenerationID() != texture->generation) {
mCache.remove(entry);
generate = true;
}
if (generate) {
// It is important to specify the generation ID so we do not
// attempt to precache the same path several times
texture = createTexture(0.0f, 0.0f, 0.0f, 0, 0, path->getGenerationID());
sp<PathTask> task = new PathTask(path, paint, texture);
texture->setTask(task);
// During the precaching phase we insert path texture objects into
// the cache that do not point to any GL texture. They are instead
// treated as a task for the precaching worker thread. This is why
// we do not check the cache limit when inserting these objects.
// The conversion into GL texture will happen in get(), when a client
// asks for a path texture. This is also when the cache limit will
// be enforced.
mCache.put(entry, texture);
if (mProcessor == NULL) {
mProcessor = new PathProcessor(Caches::getInstance());
}
mProcessor->add(task);
}
}
PathTexture* PathCache::get(const SkPath* path, const SkPaint* paint) {
path = getSourcePath(path);
PathDescription entry(kShapePath, paint);
entry.shape.path.mPath = path;
PathTexture* texture = mCache.get(entry);
if (!texture) {
texture = addTexture(entry, path, paint);
} else {
// A bitmap is attached to the texture, this means we need to
// upload it as a GL texture
const sp<Task<SkBitmap*> >& task = texture->task();
if (task != NULL) {
// But we must first wait for the worker thread to be done
// producing the bitmap, so let's wait
SkBitmap* bitmap = task->getResult();
if (bitmap) {
generateTexture(entry, bitmap, texture, false);
texture->clearTask();
} else {
ALOGW("Path too large to be rendered into a texture");
texture->clearTask();
texture = NULL;
mCache.remove(entry);
}
} else if (path->getGenerationID() != texture->generation) {
// The size of the path might have changed so we first
// remove the entry from the cache
mCache.remove(entry);
texture = addTexture(entry, path, paint);
}
}
return texture;
}
FileFsType::FileFsType(QWidget *parent, QString _type) :
_FsType(parent, _type)
{
source->setPlaceholderText(tr("Source host file"));
target->setPlaceholderText(tr("Target guest directory"));
connect(sourceLabel, SIGNAL(clicked()),
this, SLOT(getSourcePath()));
// dataChanged connections
connect(source, SIGNAL(textEdited(QString)),
this, SLOT(stateChanged()));
connect(target, SIGNAL(textEdited(QString)),
this, SLOT(stateChanged()));
connect(readOnly, SIGNAL(toggled(bool)),
this, SLOT(stateChanged()));
// Currently this only works with type='mount' for the QEMU/KVM driver.
//connect(accessMode, SIGNAL(currentIndexChanged(int)),
// this, SLOT(stateChanged()));
connect(driver, SIGNAL(currentIndexChanged(int)),
this, SLOT(stateChanged()));
connect(wrPolicy, SIGNAL(currentIndexChanged(int)),
this, SLOT(stateChanged()));
connect(format, SIGNAL(currentIndexChanged(int)),
this, SLOT(stateChanged()));
}
void TranslatorHLSL::translate(TIntermNode *root, int compileOptions)
{
const ShBuiltInResources &resources = getResources();
int numRenderTargets = resources.EXT_draw_buffers ? resources.MaxDrawBuffers : 1;
sh::AddDefaultReturnStatements(root);
SeparateDeclarations(root);
// TODO (oetuaho): Sequence operators should also be split in case there is dynamic indexing of
// a vector or matrix as an l-value inside (RemoveDynamicIndexing transformation step generates
// statements in this case).
SplitSequenceOperator(root,
IntermNodePatternMatcher::kExpressionReturningArray |
IntermNodePatternMatcher::kUnfoldedShortCircuitExpression |
IntermNodePatternMatcher::kDynamicIndexingOfVectorOrMatrixInLValue,
getTemporaryIndex(), getSymbolTable(), getShaderVersion());
// Note that SeparateDeclarations needs to be run before UnfoldShortCircuitToIf.
UnfoldShortCircuitToIf(root, getTemporaryIndex());
SeparateExpressionsReturningArrays(root, getTemporaryIndex());
// Note that SeparateDeclarations needs to be run before SeparateArrayInitialization.
SeparateArrayInitialization(root);
// HLSL doesn't support arrays as return values, we'll need to make functions that have an array
// as a return value to use an out parameter to transfer the array data instead.
ArrayReturnValueToOutParameter(root, getTemporaryIndex());
if (!shouldRunLoopAndIndexingValidation(compileOptions))
{
// HLSL doesn't support dynamic indexing of vectors and matrices.
RemoveDynamicIndexing(root, getTemporaryIndex(), getSymbolTable(), getShaderVersion());
}
// Work around D3D9 bug that would manifest in vertex shaders with selection blocks which
// use a vertex attribute as a condition, and some related computation in the else block.
if (getOutputType() == SH_HLSL_3_0_OUTPUT && getShaderType() == GL_VERTEX_SHADER)
{
sh::RewriteElseBlocks(root, getTemporaryIndex());
}
bool precisionEmulation =
getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision;
if (precisionEmulation)
{
EmulatePrecision emulatePrecision(getSymbolTable(), getShaderVersion());
root->traverse(&emulatePrecision);
emulatePrecision.updateTree();
emulatePrecision.writeEmulationHelpers(getInfoSink().obj, getShaderVersion(),
getOutputType());
}
if ((compileOptions & SH_EXPAND_SELECT_HLSL_INTEGER_POW_EXPRESSIONS) != 0)
{
sh::ExpandIntegerPowExpressions(root, getTemporaryIndex());
}
sh::OutputHLSL outputHLSL(getShaderType(), getShaderVersion(), getExtensionBehavior(),
getSourcePath(), getOutputType(), numRenderTargets, getUniforms(), compileOptions);
outputHLSL.output(root, getInfoSink().obj);
mInterfaceBlockRegisterMap = outputHLSL.getInterfaceBlockRegisterMap();
mUniformRegisterMap = outputHLSL.getUniformRegisterMap();
}
