void SkBitmapDevice::drawSpecial(const SkDraw& draw, SkSpecialImage* srcImg, int x, int y,
const SkPaint& paint) {
SkASSERT(!srcImg->isTextureBacked());
SkBitmap resultBM;
SkImageFilter* filter = paint.getImageFilter();
if (filter) {
SkIPoint offset = SkIPoint::Make(0, 0);
SkMatrix matrix = *draw.fMatrix;
matrix.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
const SkIRect clipBounds = draw.fRC->getBounds().makeOffset(-x, -y);
SkAutoTUnref<SkImageFilterCache> cache(this->getImageFilterCache());
SkImageFilter::OutputProperties outputProperties(fBitmap.colorSpace());
SkImageFilter::Context ctx(matrix, clipBounds, cache.get(), outputProperties);
sk_sp<SkSpecialImage> resultImg(filter->filterImage(srcImg, ctx, &offset));
if (resultImg) {
SkPaint tmpUnfiltered(paint);
tmpUnfiltered.setImageFilter(nullptr);
if (resultImg->getROPixels(&resultBM)) {
this->drawSprite(draw, resultBM, x + offset.x(), y + offset.y(), tmpUnfiltered);
}
}
} else {
if (srcImg->getROPixels(&resultBM)) {
this->drawSprite(draw, resultBM, x, y, paint);
}
}
}
sk_sp<SkImage> SkImage::makeWithFilter(const SkImageFilter* filter, const SkIRect& subset,
const SkIRect& clipBounds, SkIRect* outSubset,
SkIPoint* offset) const {
if (!filter || !outSubset || !offset || !this->bounds().contains(subset)) {
return nullptr;
}
SkColorSpace* colorSpace = as_IB(this)->onImageInfo().colorSpace();
sk_sp<SkSpecialImage> srcSpecialImage = SkSpecialImage::MakeFromImage(
subset, sk_ref_sp(const_cast<SkImage*>(this)), colorSpace);
if (!srcSpecialImage) {
return nullptr;
}
sk_sp<SkImageFilterCache> cache(
SkImageFilterCache::Create(SkImageFilterCache::kDefaultTransientSize));
SkImageFilter::OutputProperties outputProperties(colorSpace);
SkImageFilter::Context context(SkMatrix::I(), clipBounds, cache.get(), outputProperties);
sk_sp<SkSpecialImage> result = filter->filterImage(srcSpecialImage.get(), context, offset);
if (!result) {
return nullptr;
}
*outSubset = SkIRect::MakeWH(result->width(), result->height());
if (!outSubset->intersect(clipBounds.makeOffset(-offset->x(), -offset->y()))) {
return nullptr;
}
offset->fX += outSubset->x();
offset->fY += outSubset->y();
// Note that here we're returning the special image's entire backing store, loose padding
// and all!
return result->asImage();
}
void kinematicSingleLayer::info()
{
Info<< "\nSurface film: " << type() << endl;
const scalarField& deltaInternal = delta_;
const vectorField& Uinternal = U_;
scalar addedMassTotal = 0.0;
outputProperties().readIfPresent("addedMassTotal", addedMassTotal);
addedMassTotal += returnReduce(addedMassTotal_, sumOp<scalar>());
Info<< indent << "added mass = " << addedMassTotal << nl
<< indent << "current mass = "
<< gSum((deltaRho_*magSf())()) << nl
<< indent << "min/max(mag(U)) = " << gMin(mag(Uinternal)) << ", "
<< gMax(mag(Uinternal)) << nl
<< indent << "min/max(delta) = " << gMin(deltaInternal) << ", "
<< gMax(deltaInternal) << nl
<< indent << "coverage = "
<< gSum(alpha_.primitiveField()*magSf())/gSum(magSf()) << nl;
injection_.info(Info);
transfer_.info(Info);
}
//------------------------------------------------------------------------------
bool GetCmd::doExecute() {
TreeArgHandler* handler = static_cast<TreeArgHandler*>(mArgHandler);
const std::string& branch = handler->getMatchedBranch();
if (branch != "0" && branch != "1" && branch != "2" && branch != "3" &&
branch != "4" && branch != "5")
PAC_EXCEPT(Exception::ERR_INVALID_STATE, "invalid branch:" + branch);
AbsDir* curDir = sgConsole.getCwd();
std::string param;
// get path param ("4")
// get path ltl_regex regex("5")
if (branch == "0" || branch == "1" || branch == "2") {
if (branch == "0") {
// get ("0")
outputProperties(curDir);
} else if (branch == "1") {
// get param ("1")
outputProperties(curDir, handler->getMatchedNodeValue("param"));
} else {
// get ltl_regex regex("2")
outputProperties(curDir, "", handler->getMatchedNodeValue("regex"));
}
} else if (branch == "3" || branch == "4" || branch == "5") {
AbsDir* dir =
AbsDirUtil::findPath(handler->getMatchedNodeValue("path"), curDir);
if (branch == "3") {
// get path ("3")
outputProperties(dir);
} else if (branch == "4") {
// get param ("1")
outputProperties(dir, handler->getMatchedNodeValue("param"));
} else {
// get ltl_regex regex("2")
outputProperties(dir, "", handler->getMatchedNodeValue("regex"));
}
} else {
PAC_EXCEPT(Exception::ERR_INVALID_STATE, "invalid branch:" + branch);
}
return true;
}
void MSBuildProvider::createProjectFile(const std::string &name, const std::string &uuid, const BuildSetup &setup, const std::string &moduleDir,
const StringList &includeList, const StringList &excludeList) {
const std::string projectFile = setup.outputDir + '/' + name + getProjectExtension();
std::ofstream project(projectFile.c_str());
if (!project)
error("Could not open \"" + projectFile + "\" for writing");
project << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
"<Project DefaultTargets=\"Build\" ToolsVersion=\"" << (_version >= 12 ? _version : 4) << ".0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n"
"\t<ItemGroup Label=\"ProjectConfigurations\">\n";
outputConfiguration(project, "Debug", "Win32");
outputConfiguration(project, "Debug", "x64");
outputConfiguration(project, "Analysis", "Win32");
outputConfiguration(project, "Analysis", "x64");
outputConfiguration(project, "Release", "Win32");
outputConfiguration(project, "Release", "x64");
project << "\t</ItemGroup>\n";
// Project name & Guid
project << "\t<PropertyGroup Label=\"Globals\">\n"
"\t\t<ProjectGuid>{" << uuid << "}</ProjectGuid>\n"
"\t\t<RootNamespace>" << name << "</RootNamespace>\n"
"\t\t<Keyword>Win32Proj</Keyword>\n"
"\t\t<VCTargetsPath Condition=\"'$(VCTargetsPath" << _version << ")' != '' and '$(VSVersion)' == '' and $(VisualStudioVersion) == ''\">$(VCTargetsPath" << _version << ")</VCTargetsPath>\n"
"\t</PropertyGroup>\n";
// Shared configuration
project << "\t<Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.Default.props\" />\n";
outputConfigurationType(setup, project, name, "Release|Win32", _version);
outputConfigurationType(setup, project, name, "Analysis|Win32", _version);
outputConfigurationType(setup, project, name, "Debug|Win32", _version);
outputConfigurationType(setup, project, name, "Release|x64", _version);
outputConfigurationType(setup, project, name, "Analysis|x64", _version);
outputConfigurationType(setup, project, name, "Debug|x64", _version);
project << "\t<Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.props\" />\n"
"\t<ImportGroup Label=\"ExtensionSettings\">\n"
"\t</ImportGroup>\n";
outputProperties(project, "Release|Win32", setup.projectDescription + "_Release.props");
outputProperties(project, "Analysis|Win32", setup.projectDescription + "_Analysis.props");
outputProperties(project, "Debug|Win32", setup.projectDescription + "_Debug.props");
outputProperties(project, "Release|x64", setup.projectDescription + "_Release64.props");
outputProperties(project, "Analysis|x64", setup.projectDescription + "_Analysis64.props");
outputProperties(project, "Debug|x64", setup.projectDescription + "_Debug64.props");
project << "\t<PropertyGroup Label=\"UserMacros\" />\n";
// Project-specific settings (analysis uses debug properties)
outputProjectSettings(project, name, setup, false, true, false);
outputProjectSettings(project, name, setup, false, true, true);
outputProjectSettings(project, name, setup, true, true, false);
outputProjectSettings(project, name, setup, false, false, false);
outputProjectSettings(project, name, setup, false, false, true);
outputProjectSettings(project, name, setup, true, false, false);
// Files
std::string modulePath;
if (!moduleDir.compare(0, setup.srcDir.size(), setup.srcDir)) {
modulePath = moduleDir.substr(setup.srcDir.size());
if (!modulePath.empty() && modulePath.at(0) == '/')
modulePath.erase(0, 1);
}
if (modulePath.size())
addFilesToProject(moduleDir, project, includeList, excludeList, setup.filePrefix + '/' + modulePath);
else
addFilesToProject(moduleDir, project, includeList, excludeList, setup.filePrefix);
// Output references for the main project
if (name == setup.projectName)
writeReferences(setup, project);
// Output auto-generated test runner
if (setup.tests) {
project << "\t<ItemGroup>\n";
project << "\t\t<ClCompile Include=\"test_runner.cpp\" />\n";
project << "\t</ItemGroup>\n";
}
project << "\t<Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.targets\" />\n"
"\t<ImportGroup Label=\"ExtensionTargets\">\n"
"\t</ImportGroup>\n";
if (setup.tests) {
// We override the normal target to ignore the exit code (this allows us to have a clean output and not message about the command exit code)
project << "\t\t<Target Name=\"PostBuildEvent\">\n"
<< "\t\t\t<Message Text=\"Description: Run tests\" />\n"
<< "\t\t\t<Exec Command=\"$(TargetPath)\" IgnoreExitCode=\"true\" />\n"
<< "\t\t</Target>\n";
}
project << "</Project>\n";
// Output filter file if necessary
createFiltersFile(setup, name);
}