Status SessionImpl::addRestraint(std::shared_ptr<gmxapi::MDModule> module)
{
GMX_ASSERT(runner_, "SessionImpl invariant implies valid Mdrunner handle.");
Status status {
false
};
if (module != nullptr)
{
const auto &name = module->name();
if (restraints_.find(name) == restraints_.end())
{
auto restraint = module->getRestraint();
if (restraint != nullptr)
{
restraints_.emplace(std::make_pair(name, restraint));
auto sessionResources = createResources(module);
if (!sessionResources)
{
status = false;
}
else
{
runner_->addPotential(restraint, module->name());
status = true;
}
}
}
}
return status;
}
int main(int argc, char **argv)
{
if (argc != 3)
systemError("Wrong number of parameters");
if (signal(SIGINT, exitServer) == SIG_ERR)
systemError("signal");
int K = atoi(argv[1]);
int N = atoi(argv[2]);
mainThread = pthread_self();
pthread_attr_t attr;
createResources(K, N);
createIPC();
initiateThreads(&attr);
fprintf(stderr,"Server prepared to work\n");
for (;;) {
pid_t newClient = getNewClientPid();
createClientThread(newClient, &attr);
}
endSafe();
return 0;
}
D3DRendererImpl::D3DRendererImpl(IUnknown *w, const detail::RendererFunctions& fns)
{
setFunctions(fns);
_featureLevel = D3D_FEATURE_LEVEL_9_1;
xAssertIsAligned(&_clearColour);
_clearColour = Colour::Zero();
_window = w;
_handle = 0;
createResources();
}
void DeferredShadingSystem::initialize()
{
for(int i=0; i<DSM_COUNT; ++i)
mInstance[i]=0;
createResources();
mActive = false;
mCurrentMode = DSM_SHOWLIT;
}
result_t Render2D::beginDraw()
{
createResources();
ap_renderTarget->BeginDraw();
const D2D1_MATRIX_3X2_F identityMatrix = D2D1::Matrix3x2F::Identity();
ap_renderTarget->SetTransform(identityMatrix);
const D2D1_COLOR_F whiteColor = D2D1::ColorF(D2D1::ColorF::White);
ap_renderTarget->Clear(whiteColor);
return RET_SUCCESS;
}
Welcome::Welcome(QWidget *parent) :
QWidget(parent)
{
qDebug() << "welcome constructed";
createResources();
createWidgets();
createLayout();
createConnections();
}
void QtResourceViewPrivate::slotCurrentPathChanged(QTreeWidgetItem *item)
{
if (m_ignoreGuiSignals)
return;
m_listWidget->clear();
m_resourceToItem.clear();
m_itemToResource.clear();
if (!item)
return;
const QString currentPath = m_itemToPath.value(item);
createResources(currentPath);
}
///Reimplemented
virtual bool importResourceFile(const QString& filename, bool fileCreation = true) {
QFileInfo fi(filename);
if (fi.exists() == false)
return false;
if (fi.size() == 0) return false;
if (fi.suffix().toLower() == "abr") {
if (fileCreation) {
QFile::copy(filename, saveLocation() + fi.fileName());
}
QList<KisBrushSP> collectionResources = createResources(filename);
foreach(KisBrushSP brush, collectionResources) {
addResource(brush);
}
}
//-----------------------------------------------------------------------
void CompositorInstance::setEnabled(bool value)
{
if (mEnabled != value)
{
mEnabled = value;
// Create of free resource.
if (value)
{
createResources();
}
else
{
freeResources();
}
/// Notify chain state needs recompile.
mChain->_markDirty();
}
}
bool AddAcl(EntityManager *entityManager) {
createResources(entityManager);
addPermissionsToResource(entityManager);
return checkPermissions(entityManager);
}
AbstractCylinderRenderer<3>::AbstractCylinderRenderer(): AbstractShapeRenderer<3>("cylinder3d", "cylinder3d-vertices", "cylinder3d-indices") {
if(!wireframeMesh) createResources(Primitives::Cylinder::wireframe(1, 40, 1.0f));
}
AbstractCylinderRenderer<2>::AbstractCylinderRenderer(): AbstractShapeRenderer<2>("cylinder2d", "cylinder2d-vertices", {}) {
if(!wireframeMesh) createResources(Primitives::Square::wireframe());
}
AbstractSphereRenderer<3>::AbstractSphereRenderer(): AbstractShapeRenderer<3>("sphere3d", "sphere3d-vertices", "sphere3d-indices") {
if(!wireframeMesh) createResources(Primitives::UVSphere::wireframe(20, 40));
}
AbstractSphereRenderer<2>::AbstractSphereRenderer(): AbstractShapeRenderer<2>("sphere2d", "sphere2d-vertices", {}) {
if(!wireframeMesh) createResources(Primitives::Circle::wireframe(40));
}
TGen::Engine::DeferredRenderer::DeferredRenderer(TGen::Renderer & renderer,
TGen::Engine::StandardLogs & logs,
TGen::Engine::VariableRegister & variables,
TGen::Engine::ResourceManager & resources)
: TGen::Engine::WorldRenderer(renderer)
, logs(logs)
, variables(variables)
, resources(resources)
, vars(variables)
, mainCamera(NULL)
, lastNumLights(0)
, lightBatchSize(8)
, lightMaterials(NULL)
//, world(NULL)
, metaLines(renderer, 1000000, TGen::PrimitiveLines, TGen::UsageStream)
{
logs.info["dfr+"] << "deferred renderer initializing..." << TGen::endl;
rhwNoTransformShader = resources.getShaderProgram("rhwNoTransform");
rhwOnlyColorMaterial = resources.getMaterial("deferred/rhwOnlyColor");
screenFillMesh = resources.getMesh("gen:fillquad");
lightAmbientMaterial = resources.getMaterial("deferred/lightAmbient");
lightDirectionalMaterial = resources.getMaterial("deferred/lightDirectional");
lightPositionalMaterial = resources.getMaterial("deferred/lightPositional");
postLuminanceMaterial = resources.getMaterial("post/luminance");
postGaussianHorizMaterial = resources.getMaterial("post/gaussianHoriz");
postGaussianVertMaterial = resources.getMaterial("post/gaussianVert");
postFinalBloom = resources.getMaterial("post/finalBloom");
metaNormalMaterial = resources.getMaterial("meta/normal");
TGen::Rectangle mapSize(int(this->variables["env_width"]), int(this->variables["env_height"]));
if (vars.forceBinaryMRT)
mapSize = TGen::Rectangle(ceilPowerOfTwo(mapSize.width), ceilPowerOfTwo(mapSize.height));
try {
colorMap = depthMap = normalMap = miscMap = postMap1 = postMap2 = postMap3 = NULL;
mapTargets = postTargets1 = postTargets2 = postTargets3 = NULL;
createResources(mapSize);
} // TODO: clean up, auto_ptr
catch (const TGen::RuntimeException & e) { // trying power-of-two texture size
delete colorMap; delete depthMap; delete normalMap; delete miscMap; delete mapTargets; delete postMap1; delete postMap2; delete postTargets1; delete postTargets2; delete postMap3; delete postTargets3;
colorMap = depthMap = normalMap = miscMap = postMap1 = postMap2 = postMap3 = NULL;
mapTargets = postTargets1 = postTargets2 = postTargets3 = NULL;
mapSize = TGen::Rectangle(ceilPowerOfTwo(mapSize.width), ceilPowerOfTwo(mapSize.height));
logs.warning["dfr+"] << e << TGen::endl;
logs.warning["dfr+"] << "trying " << std::string(mapSize) << "..." << TGen::endl;
createResources(mapSize);
}
logs.info["dfr+"] << "mrts size: " << std::string(mapSize) << TGen::endl;
lightMaterials = new TGen::Material*[lightBatchSize * 3];
//loadLightMaterial("deferred/lightDirectional", 0);
logs.info["dfr+"] << "light batch size: " << lightBatchSize << TGen::endl;
TGen::Rectangle viewport = renderer.getViewport();
renderer.setRenderTarget(postTargets2);
renderer.setViewport(downsampleSize);
renderer.clearBuffers(TGen::ColorBuffer);
renderer.setRenderTarget(NULL);
renderer.setViewport(viewport);
logs.info["dfr+"] << "bloom downsampling: " << std::string(downsampleSize) << TGen::endl;
logs.info["dfr+"] << "initialized" << TGen::endl;
}
int main(int argc, char* argv[])
{
uint8_t addr[20] = {0};
uint8_t* paddr = NULL;
uint16_t port = 0;
uint8_t ifname[] = "eth0";
pthread_t threadId;
int opt;
while ((opt = getopt(argc, argv, "t:")) != -1)
{
switch(opt)
{
case 't':
TEST = atoi(optarg);
break;
default:
PrintUsage();
return -1;
}
}
if(TEST <= TEST_INVALID || TEST >= MAX_TESTS){
PrintUsage();
return -1;
}
OC_LOG(DEBUG, TAG, "OCServer is starting...");
/*Get Ip address on defined interface and initialize coap on it with random port number
* this port number will be used as a source port in all coap communications*/
if (OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr,
sizeof(addr)) == ERR_SUCCESS)
{
OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
paddr = addr;
}
if (OCInit((char *) paddr, port, OC_SERVER) != OC_STACK_OK) {
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
/*
* Declare and create the example resource: light
*/
createResources();
/*
* Create a thread for changing the representation of the light
*/
pthread_create (&threadId, NULL, ChangeLightRepresentation, (void *)NULL);
// Break from loop with Ctrl-C
OC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
while (!gQuitFlag)
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
return 0;
}
sleep(2);
}
/*
* Cancel the light thread and wait for it to terminate
*/
pthread_cancel(threadId);
pthread_join(threadId, NULL);
OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
}
return 0;
}
