void QuickItemNodeInstance::initialize(const ObjectNodeInstance::Pointer &objectNodeInstance)
{
if (instanceId() == 0) {
DesignerSupport::setRootItem(nodeInstanceServer()->quickView(), quickItem());
} else {
quickItem()->setParentItem(qobject_cast<QQuickItem*>(nodeInstanceServer()->quickView()->rootObject()));
}
if (s_createEffectItem || instanceId() == 0)
designerSupport()->refFromEffectItem(quickItem());
ObjectNodeInstance::initialize(objectNodeInstance);
quickItem()->update();
}
boost::shared_ptr<const InstanceLiveness> Cluster::getInstanceLiveness()
{
boost::shared_ptr<const InstanceLiveness> liveness(NetworkManager::getInstance()->getInstanceLiveness());
if (liveness) {
return liveness;
}
boost::shared_ptr<const InstanceMembership> membership(getInstanceMembership());
boost::shared_ptr<InstanceLiveness> newLiveness(new InstanceLiveness(membership->getViewId(), 0));
for (std::set<InstanceID>::const_iterator i = membership->getInstances().begin();
i != membership->getInstances().end(); ++i) {
InstanceID instanceId(*i);
InstanceLiveness::InstancePtr entry(new InstanceLivenessEntry(instanceId, 0, false));
newLiveness->insert(entry);
}
liveness = newLiveness;
assert(liveness->getNumLive() > 0);
return liveness;
}
/**
* Adds a cloud watch alarm to an instance based on CPU utilization. This alarm
* includes a command-line specified ARN that dictates what action to take when
* the alarm transitions into the Alarm state
*/
int main(int argc, char** argv)
{
if (argc != 4)
{
std::cout << "Usage:" << std::endl << " enable_alarm_actions" <<
" <alarm_name> <instance_id> <alarm_action_arn>" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
Aws::String alarm_name(argv[1]);
Aws::String instanceId(argv[2]);
Aws::String actionArn(argv[3]);
CreateAlarmAndEnableActions(alarm_name, instanceId, actionArn);
}
Aws::ShutdownAPI(options);
return 0;
}
bool
HdxIntersector::Query(HdxIntersector::Params const& params,
HdRprimCollection const& col,
HdEngine* engine,
HdxIntersector::Result* result)
{
TRACE_FUNCTION();
// Make sure we're in a sane GL state before attempting anything.
if (GlfHasLegacyGraphics()) {
TF_RUNTIME_ERROR("framebuffer object not supported");
return false;
}
GlfGLContextSharedPtr context = GlfGLContext::GetCurrentGLContext();
if (!TF_VERIFY(context)) {
TF_RUNTIME_ERROR("Invalid GL context");
return false;
}
if (!_drawTarget) {
// Initialize the shared draw target late to ensure there is a valid GL
// context, which may not be the case at constructon time.
_Init(GfVec2i(128,128));
}
GfVec2i size(_drawTarget->GetSize());
GfVec4i viewport(0, 0, size[0], size[1]);
if (!TF_VERIFY(_renderPass)) {
return false;
}
_renderPass->SetRprimCollection(col);
// Setup state based on incoming params.
_renderPassState->SetAlphaThreshold(params.alphaThreshold);
_renderPassState->SetClipPlanes(params.clipPlanes);
_renderPassState->SetCullStyle(params.cullStyle);
_renderPassState->SetCamera(params.viewMatrix, params.projectionMatrix, viewport);
_renderPassState->SetLightingEnabled(false);
// Use a separate drawTarget (framebuffer object) for each GL context
// that uses this renderer, but the drawTargets share attachments/textures.
GlfDrawTargetRefPtr drawTarget = GlfDrawTarget::New(size);
// Clone attachments into this context. Note that this will do a
// light-weight copy of the textures, it does not produce a full copy of the
// underlying images.
drawTarget->Bind();
drawTarget->CloneAttachments(_drawTarget);
//
// Setup GL raster state
//
GLenum drawBuffers[3] = { GL_COLOR_ATTACHMENT0,
GL_COLOR_ATTACHMENT1,
GL_COLOR_ATTACHMENT2 };
glDrawBuffers(3, drawBuffers);
glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glClearColor(0,0,0,0);
glClearStencil(0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
GLF_POST_PENDING_GL_ERRORS();
//
// Execute the picking pass
//
{
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// Setup stencil state and prevent writes to color buffer.
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 1, 1);
glStencilOp(GL_KEEP, // stencil failed
GL_KEEP, // stencil passed, depth failed
GL_REPLACE); // stencil passed, depth passed
//
// Condition the stencil buffer.
//
params.depthMaskCallback();
// we expect any GL state changes are restored.
// Disable stencil updates and setup the stencil test.
glStencilFunc(GL_LESS, 0, 1);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
// Clear depth incase the depthMaskCallback pollutes the depth buffer.
glClear(GL_DEPTH_BUFFER_BIT);
// Restore color outputs & setup state for rendering
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDisable(GL_CULL_FACE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glFrontFace(GL_CCW);
//
// Enable conservative rasterization, if available.
//
// XXX: This wont work until it's in the Glew build.
bool convRstr = glewIsSupported("GL_NV_conservative_raster");
if (convRstr) {
// XXX: this should come from Glew
#define GL_CONSERVATIVE_RASTERIZATION_NV 0x9346
glEnable(GL_CONSERVATIVE_RASTERIZATION_NV);
}
//
// Execute
//
// XXX: make intersector a Task
HdTaskSharedPtrVector tasks;
tasks.push_back(boost::make_shared<HdxIntersector_DrawTask>(_renderPass,
_renderPassState,
params.renderTags));
engine->Execute(*_index, tasks);
glDisable(GL_STENCIL_TEST);
if (convRstr) {
// XXX: this should come from Glew
#define GL_CONSERVATIVE_RASTERIZATION_NV 0x9346
glDisable(GL_CONSERVATIVE_RASTERIZATION_NV);
}
// Restore
glBindVertexArray(0);
glDeleteVertexArrays(1, &vao);
}
GLF_POST_PENDING_GL_ERRORS();
//
// Capture the result buffers to be resolved later.
//
size_t len = size[0] * size[1];
std::unique_ptr<unsigned char[]> primId(new unsigned char[len*4]);
std::unique_ptr<unsigned char[]> instanceId(new unsigned char[len*4]);
std::unique_ptr<unsigned char[]> elementId(new unsigned char[len*4]);
std::unique_ptr<float[]> depths(new float[len]);
glBindTexture(GL_TEXTURE_2D,
drawTarget->GetAttachments().at("primId")->GetGlTextureName());
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &primId[0]);
glBindTexture(GL_TEXTURE_2D,
drawTarget->GetAttachments().at("instanceId")->GetGlTextureName());
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &instanceId[0]);
glBindTexture(GL_TEXTURE_2D,
drawTarget->GetAttachments().at("elementId")->GetGlTextureName());
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &elementId[0]);
glBindTexture(GL_TEXTURE_2D,
drawTarget->GetAttachments().at("depth")->GetGlTextureName());
glGetTexImage(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, GL_FLOAT,
&depths[0]);
glBindTexture(GL_TEXTURE_2D, 0);
GLF_POST_PENDING_GL_ERRORS();
if (result) {
*result = HdxIntersector::Result(
std::move(primId), std::move(instanceId), std::move(elementId),
std::move(depths), _index, params, viewport);
}
drawTarget->Unbind();
GLF_POST_PENDING_GL_ERRORS();
return true;
}
bool NodeInstance::isValid() const
{
return instanceId() >= 0 && modelNode().isValid();
}
