TextRenderingPainter::TextRenderingPainter(gloperate::ResourceManager & resourceManager, const cpplocate::ModuleInfo & moduleInfo)
: PipelinePainter("TextRendering", resourceManager, moduleInfo, m_pipeline)
{
// Setup painter
auto targetFBO = addCapability(new gloperate::TargetFramebufferCapability());
auto viewport = addCapability(new gloperate::ViewportCapability());
auto time = addCapability(new gloperate::VirtualTimeCapability());
m_pipeline.targetFBO.setData(targetFBO);
m_pipeline.viewport.setData(viewport);
m_pipeline.time.setData(time);
m_pipeline.resourceManager.setData(&resourceManager);
targetFBO->changed.connect([this]() { m_pipeline.targetFBO.invalidate(); });
viewport->changed.connect([this]() { m_pipeline.viewport.invalidate(); });
time->changed.connect([this]() { m_pipeline.time.invalidate(); });
time->setLoopDuration(glm::pi<float>() * 2);
reflectionzeug::PropertyGroup * fontLoading = addGroup("Font");
fontLoading->addProperty(createProperty("Filename", m_pipeline.fontFilename));
reflectionzeug::PropertyGroup * textGeneration = addGroup("Text");
textGeneration->addProperty(createProperty("Algorithm", m_pipeline.textGenerationAlgorithm));
textGeneration->addProperty(createProperty("StaticText", m_pipeline.staticText));
textGeneration->addProperty(createProperty("Length", m_pipeline.length));
//textGeneration->addProperty(createProperty("Encoding", m_pipeline.encoding));
textGeneration->addProperty(createProperty("XRepeat", m_pipeline.xRepeat));
textGeneration->addProperty(createProperty("YRepeat", m_pipeline.yRepeat));
textGeneration->addProperty(createProperty("JiggleRadius", m_pipeline.jiggleRadius));
reflectionzeug::PropertyGroup * rendering = addGroup("Rendering");
rendering->addProperty(createProperty("FontColor", m_pipeline.fontColor));
rendering->addProperty(createProperty("DistanceThreshold", m_pipeline.distanceThreshold));
}
OpenGLExample::OpenGLExample(gloperate::ResourceManager & resourceManager, const reflectionzeug::Variant & pluginInfo)
: Painter("EmptyExample", resourceManager, pluginInfo)
, m_targetFramebufferCapability(addCapability(new gloperate::TargetFramebufferCapability()))
, m_viewportCapability(addCapability(new gloperate::ViewportCapability()))
, m_projectionCapability(addCapability(new gloperate::PerspectiveProjectionCapability(m_viewportCapability)))
, m_cameraCapability(addCapability(new gloperate::CameraCapability()))
{
}
OpenGLExample::OpenGLExample(gloperate::ResourceManager & resourceManager)
: Painter(resourceManager)
, m_targetFramebufferCapability(addCapability(new gloperate::TargetFramebufferCapability()))
, m_viewportCapability(addCapability(new gloperate::ViewportCapability()))
, m_projectionCapability(addCapability(new gloperate::PerspectiveProjectionCapability(m_viewportCapability)))
, m_cameraCapability(addCapability(new gloperate::CameraCapability()))
{
}
// Called for each instruction that resides in a block.
void Builder::postProcess(const Instruction& inst)
{
// Add capabilities based simply on the opcode.
switch (inst.getOpCode()) {
case OpExtInst:
switch (inst.getImmediateOperand(1)) {
case GLSLstd450InterpolateAtCentroid:
case GLSLstd450InterpolateAtSample:
case GLSLstd450InterpolateAtOffset:
addCapability(CapabilityInterpolationFunction);
break;
default:
break;
}
break;
case OpDPdxFine:
case OpDPdyFine:
case OpFwidthFine:
case OpDPdxCoarse:
case OpDPdyCoarse:
case OpFwidthCoarse:
addCapability(CapabilityDerivativeControl);
break;
case OpImageQueryLod:
case OpImageQuerySize:
case OpImageQuerySizeLod:
case OpImageQuerySamples:
case OpImageQueryLevels:
addCapability(CapabilityImageQuery);
break;
#ifdef NV_EXTENSIONS
case OpGroupNonUniformPartitionNV:
addExtension(E_SPV_NV_shader_subgroup_partitioned);
addCapability(CapabilityGroupNonUniformPartitionedNV);
break;
#endif
default:
break;
}
// Checks based on type
if (inst.getTypeId() != NoType)
postProcessType(inst, inst.getTypeId());
for (int op = 0; op < inst.getNumOperands(); ++op) {
if (inst.isIdOperand(op)) {
// In blocks, these are always result ids, but we are relying on
// getTypeId() to return NoType for things like OpLabel.
if (getTypeId(inst.getIdOperand(op)) != NoType)
postProcessType(inst, getTypeId(inst.getIdOperand(op)));
}
}
}
/**
* @brief
* Constructor
*/
OsgPainter::OsgPainter(ResourceManager & resourceManager, const std::string & name)
: Painter(resourceManager, name)
, m_viewer(nullptr)
, m_embedded(nullptr)
, m_scene(nullptr)
, m_viewportX(0)
, m_viewportY(0)
, m_viewportWidth(0)
, m_viewportHeight(0)
{
// Register capabilities
m_viewportCapability = addCapability(new gloperate::ViewportCapability);
m_targetFramebufferCapability = addCapability(new gloperate::TargetFramebufferCapability);
m_inputCapability = addCapability(new gloperate::InputCapability);
m_virtualTimeCapability = addCapability(new gloperate::VirtualTimeCapability);
}
int QLCChannel_Test::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: groupList(); break;
case 1: name(); break;
case 2: group(); break;
case 3: controlByte(); break;
case 4: colourList(); break;
case 5: colour(); break;
case 6: searchCapabilityByValue(); break;
case 7: searchCapabilityByName(); break;
case 8: addCapability(); break;
case 9: removeCapability(); break;
case 10: sortCapabilities(); break;
case 11: copy(); break;
case 12: load(); break;
case 13: loadWrongRoot(); break;
case 14: save(); break;
default: ;
}
_id -= 15;
}
return _id;
}
bool QLCChannel::loadXML(const QDomElement& root)
{
if (root.tagName() != KXMLQLCChannel)
{
qWarning() << "Channel node not found.";
return false;
}
/* Get channel name */
QString str = root.attribute(KXMLQLCChannelName);
if (str.isEmpty() == true)
return false;
setName(str);
/* Subtags */
QDomNode node = root.firstChild();
while (node.isNull() == false)
{
QDomElement tag = node.toElement();
if (tag.tagName() == KXMLQLCCapability)
{
/* Create a new capability and attempt to load it */
QLCCapability* cap = new QLCCapability();
if (cap->loadXML(tag) == true)
{
/* Loading succeeded */
if (addCapability(cap) == false)
{
/* Value overlaps with existing value */
delete cap;
}
}
else
{
/* Loading failed */
delete cap;
}
}
else if (tag.tagName() == KXMLQLCChannelGroup)
{
str = tag.attribute(KXMLQLCChannelGroupByte);
setControlByte(ControlByte(str.toInt()));
setGroup(stringToGroup(tag.text()));
}
else if (tag.tagName() == KXMLQLCChannelColour)
{
setColour(stringToColour(tag.text()));
}
else
{
qWarning() << Q_FUNC_INFO << "Unknown Channel tag: " << tag.tagName();
}
node = node.nextSibling();
}
return true;
}
Postprocessing::Postprocessing(gloperate::ResourceManager & resourceManager, const reflectionzeug::Variant & pluginInfo)
: PipelinePainter("Postprocessing", resourceManager, pluginInfo, m_pipeline)
, m_animation(true)
{
// Setup painter
auto targetFBO = addCapability(new gloperate::TargetFramebufferCapability());
auto viewport = addCapability(new gloperate::ViewportCapability());
auto time = addCapability(new gloperate::VirtualTimeCapability());
auto camera = addCapability(new gloperate::CameraCapability());
auto projection = addCapability(new gloperate::PerspectiveProjectionCapability(viewport));
auto renderTargets = addCapability(new gloperate::TypedRenderTargetCapability());
m_pipeline.targetFBO.setData(targetFBO);
m_pipeline.viewport.setData(viewport);
m_pipeline.time.setData(time);
m_pipeline.camera.setData(camera);
m_pipeline.projection.setData(projection);
m_pipeline.renderTargets.setData(renderTargets);
targetFBO->changed.connect([this]() { m_pipeline.targetFBO.invalidate(); });
viewport->changed.connect([this]() { m_pipeline.viewport.invalidate(); });
time->changed.connect([this]() { m_pipeline.time.invalidate(); });
projection->setZNear(0.1f);
projection->setZFar(16.f);
time->setLoopDuration(glm::pi<float>() * 2);
// Register properties
addProperty<bool>("Animation", this, &Postprocessing::animation, &Postprocessing::setAnimation);
}
bool QLCChannel::loadXML(const QDomElement* root)
{
QDomNode node;
QDomElement tag;
QString str;
Q_ASSERT(root != NULL);
/* Get channel name */
str = root->attribute(KXMLQLCChannelName);
if (str == QString::null)
return false;
else
setName(str);
/* Subtags */
node = root->firstChild();
while (node.isNull() == false)
{
tag = node.toElement();
if (tag.tagName() == KXMLQLCCapability)
{
addCapability(new QLCCapability(&tag));
}
else if (tag.tagName() == KXMLQLCChannelGroup)
{
str = tag.attribute(KXMLQLCChannelGroupByte);
setControlByte(str.toInt());
setGroup(tag.text());
}
else
{
qDebug() << "Unknown Channel tag: " << tag.tagName();
}
node = node.nextSibling();
}
return true;
}
bool QLCChannel::loadXML(const QDomElement* root)
{
QDomNode node;
QDomElement tag;
QString str;
Q_ASSERT(root != NULL);
if (root->tagName() != KXMLQLCChannel)
{
qWarning() << "Channel node not found.";
return false;
}
/* Get channel name */
str = root->attribute(KXMLQLCChannelName);
if (str == QString::null)
return false;
else
setName(str);
/* Subtags */
node = root->firstChild();
while (node.isNull() == false)
{
tag = node.toElement();
if (tag.tagName() == KXMLQLCCapability)
{
/* Create a new capability and attempt to load it */
QLCCapability* cap = new QLCCapability();
if (cap->loadXML(&tag) == true)
{
/* Loading succeeded */
if (addCapability(cap) == false)
{
/* Value overlaps with existing value */
delete cap;
}
}
else
{
/* Loading failed */
delete cap;
}
}
else if (tag.tagName() == KXMLQLCChannelGroup)
{
str = tag.attribute(KXMLQLCChannelGroupByte);
setControlByte(str.toInt());
setGroup(tag.text());
}
else
{
qDebug() << "Unknown Channel tag: " << tag.tagName();
}
node = node.nextSibling();
}
return true;
}
void ICQClient::sendCapability(const QString &away_msg)
{
Buffer cap;
capability c;
memcpy(c, capabilities[CAP_SIM], sizeof(c));
const char *ver = VERSION;
unsigned char *pack_ver = c + sizeof(capability) - 4;
*(pack_ver++) = get_ver(ver);
*(pack_ver++) = get_ver(ver);
*(pack_ver++) = get_ver(ver);
unsigned char os_ver;
#ifdef WIN32
os_ver = 0x80;
#else
#ifdef QT_MACOSX_VERSION
os_ver = 0x40;
#else
os_ver = 0;
#endif
#endif
*(pack_ver++) = os_ver;
addCapability(cap, CAP_AIM_SHORTCAPS);
addCapability(cap, CAP_AIM_SUPPORT);
// addCapability(cap, CAP_AVATAR);
if (m_bAIM){
addCapability(cap, CAP_AIM_CHAT);
addCapability(cap, CAP_AIM_BUDDYCON);
addCapability(cap, CAP_AIM_IMIMAGE);
addCapability(cap, CAP_AIM_SENDFILE);
addCapability(cap, CAP_AIM_BUDDYLIST);
}else{
addCapability(cap, CAP_DIRECT);
addCapability(cap, CAP_SRV_RELAY);
addCapability(cap, CAP_XTRAZ);
if (getSendFormat() <= 1)
addCapability(cap, CAP_UTF);
if (getSendFormat() == 0)
addCapability(cap, CAP_RTF);
}
if (!getDisableTypingNotification())
cap.pack((char*)capabilities[CAP_TYPING], sizeof(capability));
cap.pack((char*)c, sizeof(c));
snac(ICQ_SNACxFAM_LOCATION, ICQ_SNACxLOC_SETxUSERxINFO);
if (m_bAIM){
if (data.owner.ProfileFetch.bValue){
QString profile;
profile = QString("<HTML>") + data.owner.About.ptr + "</HTML>";
encodeString(profile, "text/aolrtf", 1, 2);
}
if (!away_msg.isNull())
encodeString(away_msg, "text/plain", 3, 4);
}
m_socket->writeBuffer.tlv(0x0005, cap);
if (m_bAIM)
m_socket->writeBuffer.tlv(0x0006, "\x00\x04\x00\x02\x00\x02", 6);
sendPacket(true);
}
// Hook to visit each operand type and result type of an instruction.
// Will be called multiple times for one instruction, once for each typed
// operand and the result.
void Builder::postProcessType(const Instruction& inst, Id typeId)
{
// Characterize the type being questioned
Id basicTypeOp = getMostBasicTypeClass(typeId);
int width = 0;
if (basicTypeOp == OpTypeFloat || basicTypeOp == OpTypeInt)
width = getScalarTypeWidth(typeId);
// Do opcode-specific checks
switch (inst.getOpCode()) {
case OpLoad:
case OpStore:
if (basicTypeOp == OpTypeStruct) {
if (containsType(typeId, OpTypeInt, 8))
addCapability(CapabilityInt8);
if (containsType(typeId, OpTypeInt, 16))
addCapability(CapabilityInt16);
if (containsType(typeId, OpTypeFloat, 16))
addCapability(CapabilityFloat16);
} else {
StorageClass storageClass = getStorageClass(inst.getIdOperand(0));
if (width == 8) {
switch (storageClass) {
case StorageClassUniform:
case StorageClassStorageBuffer:
case StorageClassPushConstant:
break;
default:
addCapability(CapabilityInt8);
break;
}
} else if (width == 16) {
switch (storageClass) {
case StorageClassUniform:
case StorageClassStorageBuffer:
case StorageClassPushConstant:
case StorageClassInput:
case StorageClassOutput:
break;
default:
if (basicTypeOp == OpTypeInt)
addCapability(CapabilityInt16);
if (basicTypeOp == OpTypeFloat)
addCapability(CapabilityFloat16);
break;
}
}
}
break;
case OpAccessChain:
case OpPtrAccessChain:
case OpCopyObject:
case OpFConvert:
case OpSConvert:
case OpUConvert:
break;
default:
if (basicTypeOp == OpTypeFloat && width == 16)
addCapability(CapabilityFloat16);
if (basicTypeOp == OpTypeInt && width == 16)
addCapability(CapabilityInt16);
if (basicTypeOp == OpTypeInt && width == 8)
addCapability(CapabilityInt8);
break;
}
}
