Command* QueueSlave::pop()
{
static base::a_int32_t _request;
const int32_t request = ++_request;
while( true )
{
const size_t queueSize = _impl->queue.getSize();
if( queueSize <= _impl->prefetchMark )
{
QueueGetItemPacket packet;
packet.itemsRequested = _impl->prefetchAmount;
packet.instanceID = _impl->masterInstanceID;
packet.slaveInstanceID = getInstanceID();
packet.requestID = request;
send( _impl->master, packet );
}
Command* cmd = _impl->queue.pop();
if( (*cmd)->command == CMD_QUEUE_ITEM )
return cmd;
EQASSERT( (*cmd)->command == CMD_QUEUE_EMPTY );
const QueueEmptyPacket* packet = cmd->get< QueueEmptyPacket >();
if( packet->requestID == request )
{
cmd->release();
return 0;
}
// else left-over or not our empty packet, discard and retry
cmd->release();
}
}
void ExtendedDebugLogEntry::setData(const DebugLogEntry::DataFields &data, UAVObjectManager *objectManager)
{
DebugLogEntry::setData(data);
if (getType() == DebugLogEntry::TYPE_UAVOBJECT) {
UAVDataObject *object = (UAVDataObject *)objectManager->getObject(getObjectID(), getInstanceID());
Q_ASSERT(object);
m_object = object->clone(getInstanceID());
m_object->unpack(getData().Data);
}
}
bool
EGL2Framebuffer::bindRenderTexture(GraphicsTexturePtr texture, GLenum attachment, GLint level, GLint layer) noexcept
{
assert(texture);
auto gltexture = texture->downcast<EGL2Texture>();
auto handle = gltexture->getInstanceID();
auto target = gltexture->getTarget();
if (target != GL_TEXTURE_2D && target != GL_TEXTURE_2D_MULTISAMPLE && target != GL_TEXTURE_CUBE_MAP)
{
GL_PLATFORM_LOG("Invalid texture target");
return false;
}
GL_CHECK(glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, target, handle, 0));
return true;
}
void Object::serialize( co::DataOStream& os, const uint64_t dirtyBits )
{
if( dirtyBits & DIRTY_NAME )
os << _data.name;
if( dirtyBits & DIRTY_USERDATA )
os << _data.userData;
if( dirtyBits & DIRTY_TASKS )
os << _tasks;
if( dirtyBits & DIRTY_ERROR )
os << _error;
if( dirtyBits & DIRTY_REMOVED )
{
EQASSERT( !isMaster() ||
( _removedChildren.empty() && dirtyBits == DIRTY_ALL ))
os << _removedChildren;
_removedChildren.clear();
}
if( (dirtyBits & DIRTY_SERIAL) && isMaster( ))
os << getInstanceID();
}
bool
OGLCoreFramebuffer::bindRenderTexture(GraphicsTexturePtr renderTexture, GLenum attachment, GLint level, GLint layer) noexcept
{
assert(renderTexture);
auto texture = renderTexture->downcast<OGLCoreTexture>();
auto textureID = texture->getInstanceID();
auto& textureDesc = renderTexture->getGraphicsTextureDesc();
if (textureDesc.getTexDim() == GraphicsTextureDim::GraphicsTextureDim2DArray ||
textureDesc.getTexDim() == GraphicsTextureDim::GraphicsTextureDimCube ||
textureDesc.getTexDim() == GraphicsTextureDim::GraphicsTextureDimCubeArray)
{
glNamedFramebufferTextureLayer(_fbo, attachment, textureID, level, layer);
}
else
{
glNamedFramebufferTexture(_fbo, attachment, textureID, level);
}
return OGLCheck::checkError();
}
BOOL CALLBACK System::diDeviceEnumCallback( LPCDIDEVICEINSTANCEW instance,
LPVOID referer )
{
auto system = reinterpret_cast<System*>( referer );
for ( auto identifier : system->mXInputDeviceIDs )
if ( instance->guidProduct.Data1 == identifier )
return DIENUM_CONTINUE;
for ( auto device : system->mDevices )
{
if ( device->getHandler() != Device::Handler_DirectInput )
continue;
auto diDevice = static_cast<DirectInputDevice*>( device );
if ( diDevice->getInstanceID() == instance->guidInstance )
{
if ( device->getSavedStatus() == Device::Status_Disconnected )
system->deviceConnect( device );
else
device->setStatus( Device::Status_Connected );
return DIENUM_CONTINUE;
}
}
Device* device = new DirectInputDevice( system, system->getNextID(), instance );
if ( system->isInitializing() )
device->setStatus( Device::Status_Connected );
else
system->deviceConnect( device );
system->mDevices.push_back( device );
return DIENUM_CONTINUE;
}
ObjectICommand QueueSlave::pop( const uint32_t timeout )
{
static lunchbox::a_int32_t _request;
const int32_t request = ++_request;
while( true )
{
const size_t queueSize = _impl->queue.getSize();
if( queueSize <= _impl->prefetchMark )
{
send( _impl->master, CMD_QUEUE_GET_ITEM, _impl->masterInstanceID )
<< _impl->prefetchAmount << getInstanceID() << request;
}
try
{
ObjectICommand cmd( _impl->queue.pop( timeout ));
switch( cmd.getCommand( ))
{
case CMD_QUEUE_ITEM:
return ObjectICommand( cmd );
default:
LBUNIMPLEMENTED;
case CMD_QUEUE_EMPTY:
if( cmd.get< int32_t >() == request )
return ObjectICommand( 0, 0, 0, false );
// else left-over or not our empty command, discard and retry
break;
}
}
catch (co::Exception& e)
{
LBWARN << e.what() << std::endl;
return ObjectICommand( 0, 0, 0, false );
}
}
}
void QueueMaster::getInstanceData( co::DataOStream& os )
{
os << getInstanceID() << getLocalNode()->getNodeID();
}
void
EGL2DescriptorSet::apply(const EGL2Program& shaderObject) noexcept
{
for (auto& it : _activeUniformSets)
{
auto type = it->getGraphicsParam()->getType();
auto location = it->getGraphicsParam()->getBindingPoint();
switch (type)
{
case GraphicsUniformType::GraphicsUniformTypeBool:
GL_CHECK(glUniform1i(location, it->getBool()));
break;
case GraphicsUniformType::GraphicsUniformTypeInt:
GL_CHECK(glUniform1i(location, it->getInt()));
break;
case GraphicsUniformType::GraphicsUniformTypeInt2:
GL_CHECK(glUniform2iv(location, 1, (GLint*)it->getInt2().ptr()));
break;
case GraphicsUniformType::GraphicsUniformTypeInt3:
GL_CHECK(glUniform3iv(location, 1, (GLint*)it->getInt3().ptr()));
break;
case GraphicsUniformType::GraphicsUniformTypeInt4:
GL_CHECK(glUniform4iv(location, 1, (GLint*)it->getInt4().ptr()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat:
GL_CHECK(glUniform1f(location, it->getFloat()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat2:
GL_CHECK(glUniform2fv(location, 1, it->getFloat2().ptr()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat3:
GL_CHECK(glUniform3fv(location, 1, it->getFloat3().ptr()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat4:
GL_CHECK(glUniform4fv(location, 1, it->getFloat4().ptr()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat3x3:
GL_CHECK(glUniformMatrix3fv(location, 1, GL_FALSE, it->getFloat3x3().ptr()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat4x4:
GL_CHECK(glUniformMatrix4fv(location, 1, GL_FALSE, it->getFloat4x4().ptr()));
break;
case GraphicsUniformType::GraphicsUniformTypeIntArray:
GL_CHECK(glUniform1iv(location, it->getIntArray().size(), it->getIntArray().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeInt2Array:
GL_CHECK(glUniform2iv(location, it->getInt2Array().size(), (GLint*)it->getInt2Array().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeInt3Array:
GL_CHECK(glUniform3iv(location, it->getInt3Array().size(), (GLint*)it->getInt3Array().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeInt4Array:
GL_CHECK(glUniform4iv(location, it->getInt4Array().size(), (GLint*)it->getInt4Array().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloatArray:
GL_CHECK(glUniform1fv(location, it->getFloatArray().size(), (GLfloat*)it->getFloatArray().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat2Array:
GL_CHECK(glUniform2fv(location, it->getFloat2Array().size(), (GLfloat*)it->getFloat2Array().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat3Array:
GL_CHECK(glUniform3fv(location, it->getFloat3Array().size(), (GLfloat*)it->getFloat3Array().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat4Array:
GL_CHECK(glUniform4fv(location, it->getFloat4Array().size(), (GLfloat*)it->getFloat4Array().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat3x3Array:
GL_CHECK(glUniformMatrix3fv(location, it->getFloat3x3Array().size(), GL_FALSE, (GLfloat*)it->getFloat3x3Array().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeFloat4x4Array:
GL_CHECK(glUniformMatrix4fv(location, it->getFloat4x4Array().size(), GL_FALSE, (GLfloat*)it->getFloat4x4Array().data()));
break;
case GraphicsUniformType::GraphicsUniformTypeSampler:
assert(false);
break;
case GraphicsUniformType::GraphicsUniformTypeSamplerImage:
{
auto& texture = it->getTexture();
if (texture)
{
auto gltexture = texture->downcast<EGL2Texture>();
GL_CHECK(glActiveTexture(GL_TEXTURE0 + location));
GL_CHECK(glBindTexture(gltexture->getTarget(), gltexture->getInstanceID()));
}
}
break;
case GraphicsUniformType::GraphicsUniformTypeCombinedImageSampler:
{
auto& texture = it->getTexture();
if (texture)
{
auto gltexture = texture->downcast<EGL2Texture>();
GL_CHECK(glActiveTexture(GL_TEXTURE0 + location));
GL_CHECK(glBindTexture(gltexture->getTarget(), gltexture->getInstanceID()));
}
}
break;
case GraphicsUniformType::GraphicsUniformTypeStorageImage:
{
auto& texture = it->getTexture();
if (texture)
{
auto gltexture = texture->downcast<EGL2Texture>();
GL_CHECK(glActiveTexture(GL_TEXTURE0 + location));
GL_CHECK(glBindTexture(gltexture->getTarget(), gltexture->getInstanceID()));
}
}
break;
case GraphicsUniformType::GraphicsUniformTypeStorageTexelBuffer:
case GraphicsUniformType::GraphicsUniformTypeUniformTexelBuffer:
GL_PLATFORM_LOG("Can't support TBO.");
break;
case GraphicsUniformType::GraphicsUniformTypeStorageBuffer:
case GraphicsUniformType::GraphicsUniformTypeStorageBufferDynamic:
case GraphicsUniformType::GraphicsUniformTypeUniformBuffer:
case GraphicsUniformType::GraphicsUniformTypeUniformBufferDynamic:
GL_PLATFORM_LOG("Can't support UBO.");
break;
case GraphicsUniformType::GraphicsUniformTypeInputAttachment:
break;
case GraphicsUniformType::GraphicsUniformTypeUInt:
case GraphicsUniformType::GraphicsUniformTypeUInt2:
case GraphicsUniformType::GraphicsUniformTypeUInt3:
case GraphicsUniformType::GraphicsUniformTypeUInt4:
case GraphicsUniformType::GraphicsUniformTypeUIntArray:
case GraphicsUniformType::GraphicsUniformTypeUInt2Array:
case GraphicsUniformType::GraphicsUniformTypeUInt3Array:
case GraphicsUniformType::GraphicsUniformTypeUInt4Array:
GL_PLATFORM_LOG("Can't support unsigned type.");
break;
default:
break;
}
}
}
Boolean UNIX_ComputerSystem::getInstanceID(CIMProperty &p) const
{
p = CIMProperty(PROPERTY_INSTANCE_ID, getInstanceID());
return true;
}
String UNIX_ComputerSystem::getName() const
{
return getInstanceID();
}
Boolean UNIX_AllocationSchedulingElement::getInstanceID(CIMProperty &p) const
{
p = CIMProperty(PROPERTY_INSTANCE_ID, getInstanceID());
return true;
}
Boolean UNIX_ClusteringService::getInstanceID(CIMProperty &p) const
{
p = CIMProperty(PROPERTY_INSTANCE_ID, getInstanceID());
return true;
}
Boolean UNIX_BootConfigSetting::getInstanceID(CIMProperty &p) const
{
p = CIMProperty(PROPERTY_INSTANCE_ID, getInstanceID());
return true;
}
Boolean SambaService::getInstanceID(CIMProperty &p) const
{
p = CIMProperty(PROPERTY_INSTANCE_ID, getInstanceID());
return true;
}
