// TODO: Use this whereever it should be used
void LogicSystem::setUniqueId(extentity* staticEntity, int uniqueId)
{
if (getUniqueId(staticEntity) >= 0)
{
logger::log(logger::ERROR, "Trying to set to %d a unique Id that has already been set, to %d (S)",
uniqueId,
getUniqueId(staticEntity));
assert(0);
}
staticEntity->uid = uniqueId;
}
// TODO: Use this whereever it should be used
void LogicSystem::setUniqueId(physent* dynamicEntity, int uniqueId)
{
logger::log(logger::DEBUG, "Setting a unique ID: %d (of addr: %d)", uniqueId, dynamicEntity != NULL);
if (getUniqueId(dynamicEntity) >= 0)
{
logger::log(logger::ERROR, "Trying to set to %d a unique Id that has already been set, to %d (D)",
uniqueId,
getUniqueId(dynamicEntity));
assert(0);
}
((gameent*)dynamicEntity)->uid = uniqueId;
}
void Texture::swap(Texture& right)
{
std::swap(m_size, right.m_size);
std::swap(m_actualSize, right.m_actualSize);
std::swap(m_texture, right.m_texture);
std::swap(m_isSmooth, right.m_isSmooth);
std::swap(m_sRgb, right.m_sRgb);
std::swap(m_isRepeated, right.m_isRepeated);
std::swap(m_pixelsFlipped, right.m_pixelsFlipped);
std::swap(m_fboAttachment, right.m_fboAttachment);
std::swap(m_hasMipmap, right.m_hasMipmap);
m_cacheId = getUniqueId();
right.m_cacheId = getUniqueId();
}
std::string Item::getXRayDescription() const
{
std::stringstream ret;
ret << "ID: " << getID() << std::endl;
uint16_t actionId = getActionId();
uint16_t uniqueId = getUniqueId();
if (actionId > 0)
{
ret << "Action ID: " << actionId << std::endl;
}
if (uniqueId > 0)
{
ret << "Unique ID: " << uniqueId << std::endl;
}
#ifdef __DEBUG__
if (getContainer())
{
ret << "There are " << getContainer()->getTotalAmountOfItemsInside() - 1 << " things inside of this." << std::endl;
}
#endif
ret << Thing::getXRayDescription();
return ret.str();
}
void
TileSystem::addTile(Tile *tile)
{
if (getProjectData())
{
// Id //
//
QString name = tile->getName();
QString id = getUniqueId(tile->getID(), name);
if (id != tile->getID())
{
tile->setID(id);
if (name != tile->getName())
{
tile->setName(name);
}
}
}
// Insert //
//
tile->setTileSystem(this);
tiles_.insert(tile->getID(), tile);
addTileSystemChanges(TileSystem::CTS_TileChange);
setCurrentTile(tile);
}
Texture::Texture(const Texture& copy) :
m_size (0, 0),
m_actualSize (0, 0),
m_texture (0),
m_isSmooth (copy.m_isSmooth),
m_sRgb (copy.m_sRgb),
m_isRepeated (copy.m_isRepeated),
m_pixelsFlipped(false),
m_fboAttachment(false),
m_hasMipmap (false),
m_cacheId (getUniqueId())
{
if (copy.m_texture)
{
if (create(copy.getSize().x, copy.getSize().y))
{
update(copy);
// Force an OpenGL flush, so that the texture will appear updated
// in all contexts immediately (solves problems in multi-threaded apps)
glCheck(glFlush());
}
else
{
err() << "Failed to copy texture, failed to create new texture" << std::endl;
}
}
}
void Texture::update(const Window& window, unsigned int x, unsigned int y)
{
assert(x + window.getSize().x <= m_size.x);
assert(y + window.getSize().y <= m_size.y);
if (m_texture && window.setActive(true))
{
TransientContextLock lock;
// Make sure that the current texture binding will be preserved
priv::TextureSaver save;
// Copy pixels from the back-buffer to the texture
glCheck(glBindTexture(GL_TEXTURE_2D, m_texture));
glCheck(glCopyTexSubImage2D(GL_TEXTURE_2D, 0, x, y, 0, 0, window.getSize().x, window.getSize().y));
glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_isSmooth ? GL_LINEAR : GL_NEAREST));
m_hasMipmap = false;
m_pixelsFlipped = true;
m_cacheId = getUniqueId();
// Force an OpenGL flush, so that the texture will appear updated
// in all contexts immediately (solves problems in multi-threaded apps)
glCheck(glFlush());
}
}
void Texture::update(const Uint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)
{
assert(x + width <= m_size.x);
assert(y + height <= m_size.y);
if (pixels && m_texture)
{
TransientContextLock lock;
// Make sure that the current texture binding will be preserved
priv::TextureSaver save;
// Copy pixels from the given array to the texture
glCheck(glBindTexture(GL_TEXTURE_2D, m_texture));
glCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_isSmooth ? GL_LINEAR : GL_NEAREST));
m_hasMipmap = false;
m_pixelsFlipped = false;
m_cacheId = getUniqueId();
// Force an OpenGL flush, so that the texture data will appear updated
// in all contexts immediately (solves problems in multi-threaded apps)
glCheck(glFlush());
}
}
dtn::security::SecurityKey KeyExchangeSession::getKey(const dtn::security::SecurityKey::KeyType type) const throw (SecurityKey::KeyNotFoundException)
{
unsigned int id = getUniqueId();
std::string prefix((char*)&id, sizeof id);
return SecurityKeyManager::getInstance().get(prefix, _peer, type);
}
//-----------------------------
bool RootParser15::begin__technique____technique_type ( const COLLADASaxFWL15::technique____technique_type__AttributeData& attributeData )
{
SaxVirtualFunctionTest15(begin__technique____technique_type(attributeData));
technique__AttributeData attr;
attr.profile = attributeData.profile;
return base__begin__technique ( attr, getUniqueId () );
}
Item::Item(const ItemAttributes& attr) : Renderable(ViewObject(*attr.viewId, ViewLayer::ITEM, capitalFirst(*attr.name))),
attributes(attr), fire(attr.burnTime), canEquipCache(!!attributes->equipmentSlot),
classCache(*attributes->itemClass) {
if (!attributes->prefixes.empty())
modViewObject().setModifier(ViewObject::Modifier::AURA);
modViewObject().setGenericId(getUniqueId().getGenericId());
}
int main(int argc, char** argv)
{
const char* path = "/etc/epgd/epg.dat";
if (argc > 1)
path = argv[1];
// read deictionary
dbDict.setFilterFromNameFct(toFieldFilter);
if (dbDict.in(path, ffEpgd) != success)
{
tell(0, "Invalid dictionary configuration, aborting!");
return 1;
}
dbDict.show();
return 0;
initConnection();
// demoStatement();
// joinDemo();
// insertDemo();
tell(0, "uuid: '%s'", getUniqueId());
exitConnection();
return 0;
}
bool Texture::create(unsigned int width, unsigned int height)
{
// Check if texture parameters are valid before creating it
if ((width == 0) || (height == 0))
{
err() << "Failed to create texture, invalid size (" << width << "x" << height << ")" << std::endl;
return false;
}
// Compute the internal texture dimensions depending on NPOT textures support
Vector2u actualSize(getValidSize(width), getValidSize(height));
// Check the maximum texture size
unsigned int maxSize = getMaximumSize();
if ((actualSize.x > maxSize) || (actualSize.y > maxSize))
{
err() << "Failed to create texture, its internal size is too high "
<< "(" << actualSize.x << "x" << actualSize.y << ", "
<< "maximum is " << maxSize << "x" << maxSize << ")"
<< std::endl;
return false;
}
// All the validity checks passed, we can store the new texture settings
m_size.x = width;
m_size.y = height;
m_actualSize = actualSize;
m_pixelsFlipped = false;
// Create the OpenGL texture if it doesn't exist yet
if (!m_texture)
{
GLuint texture;
glCheck(glGenTextures(1, &texture));
m_texture = static_cast<unsigned int>(texture);
}
// Make sure that the current texture binding will be preserved
priv::TextureSaver save;
// Initialize the texture
glCheck(glBindTexture(GL_TEXTURE_2D, m_texture));
glCheck(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_actualSize.x, m_actualSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL));
glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_isRepeated ? GL_REPEAT : GL_CLAMP));
glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_isRepeated ? GL_REPEAT :GL_CLAMP));
glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_isSmooth ? GL_LINEAR : GL_NEAREST));
glCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_isSmooth ? GL_LINEAR : GL_NEAREST));
m_cacheId = getUniqueId();
return true;
}
void Item::setUniqueId(uint16_t n)
{
if(getUniqueId() != 0)
return;
ItemAttributes::setUniqueId(n);
ScriptEnviroment::addUniqueThing(this);
}
/**
* Saves the craft's unique identifiers to a YAML file.
* @return YAML node.
*/
YAML::Node Craft::saveId() const
{
YAML::Node node = MovingTarget::saveId();
CraftId uniqueId = getUniqueId();
node["type"] = uniqueId.first;
node["id"] = uniqueId.second;
return node;
}
void Item::onRemoved()
{
ScriptEnvironment::removeTempItem(this);
if (getUniqueId() != 0) {
ScriptEnvironment::removeUniqueThing(this);
}
}
Item::~Item()
{
//std::cout << "Item destructor " << this << std::endl;
if(getUniqueId() != 0){
ScriptEnviroment::removeUniqueThing(this);
}
}
void Item::setUniqueId(int32_t uid)
{
if(getUniqueId())
return;
setAttribute("uid", uid);
ScriptEnviroment::addUniqueThing(this);
}
void Item::setUniqueId(uint16_t n)
{
if (getUniqueId() != 0) {
return;
}
getAttributes()->setUniqueId(n);
ScriptEnvironment::addUniqueThing(this);
}
// Query Server
int Samba_QueryServerList(long *Handle,int *num,char *domain)
{
int ret=-1;
if(domain)
{
int id;
char inFile[FILE_SIZE],outFile[FILE_SIZE],executeCmd[CMD_SIZE];
Rtk_Ini *inIniObj=new Rtk_Ini();
Rtk_Ini *outIniObj=new Rtk_Ini();
id=getUniqueId();
sprintf(inFile,"%s/%d.in",FILE_PATH,id);
sprintf(outFile,"%s/%d.out",FILE_PATH,id);
sprintf(executeCmd,"%s %s %s",SMB_EXE,inFile,outFile);
// prepare infile
char *domain_withmark;
inIniObj->setIntValue(MAIN, COMMAND,3);
if(!inIniObj->addStrMark_needfree(domain, &domain_withmark))
{
inIniObj->setStrValue(MAIN, P1,domain_withmark);
FREE(domain_withmark);
}
else
inIniObj->setStrValue(MAIN, P1,domain);
inIniObj->saveFile(inFile);
delete inIniObj;
// execute
system(executeCmd);
// get ip
*Handle=0;
if(!outIniObj->loadFile(outFile))
{
int rec_num;
if(!outIniObj->getIntValue(MAIN,NUMBER,&rec_num))
{
if(rec_num<0)
delete outIniObj;
else
{
*num=rec_num;
*Handle=(long)outIniObj;
outIniObj->removeInsideValueStrMark();
ret=0;
}
}
else
delete outIniObj;
}
else
delete outIniObj;
#ifndef DEBUG
unlink(inFile);
unlink(outFile);
#endif
}
return ret;
}
Texture::Texture() :
m_size (0, 0),
m_actualSize (0, 0),
m_texture (0),
m_isSmooth (false),
m_isRepeated (false),
m_pixelsFlipped(false),
m_cacheId (getUniqueId())
{
}
void Item::setUniqueId(const uint16_t& n)
{
if (getUniqueId() != 0)
{
return;
}
ItemAttributes::setUniqueId(n);
ScriptEnviroment::addUniqueThing(this);
}
OutputDirectory::OutputDirectory (const boost::filesystem::path& parentDirectory) {
parentDirectory_ = parentDirectory;
boost::filesystem::create_directories (parentDirectory);
cuint64_t id = getUniqueId (parentDirectory / "counter");
name_ = "output_" + boost::lexical_cast<std::string> (id);
path_ = parentDirectory / name_;
ASSERT (!boost::filesystem::exists (path_));
boost::filesystem::create_directory (path_);
}
bool Item::canDecay()
{
if(isRemoved())
return false;
if(loadedFromMap && (getUniqueId() || (getActionId() && getContainer())))
return false;
const ItemType& it = Item::items[id];
return it.decayTo >= 0 && it.decayTime;
}
Texture::Texture(const Texture& copy) :
m_size (0, 0),
m_actualSize (0, 0),
m_texture (0),
m_isSmooth (copy.m_isSmooth),
m_isRepeated (copy.m_isRepeated),
m_pixelsFlipped(false),
m_cacheId (getUniqueId())
{
if (copy.m_texture)
loadFromImage(copy.copyToImage());
}
void Item::onRemoved()
{
if(raid)
{
raid->unRef();
raid = NULL;
}
ScriptEnviroment::removeTempItem(this);
if(getUniqueId())
ScriptEnviroment::removeUniqueThing(this);
}
BufferQueueCore::BufferQueueCore() :
mMutex(),
mIsAbandoned(false),
mConsumerControlledByApp(false),
mConsumerName(getUniqueName()),
mConsumerListener(),
mConsumerUsageBits(0),
mConsumerIsProtected(false),
mConnectedApi(NO_CONNECTED_API),
mLinkedToDeath(),
mConnectedProducerListener(),
mSlots(),
mQueue(),
mFreeSlots(),
mFreeBuffers(),
mUnusedSlots(),
mActiveBuffers(),
mDequeueCondition(),
mDequeueBufferCannotBlock(false),
mDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888),
mDefaultWidth(1),
mDefaultHeight(1),
mDefaultBufferDataSpace(HAL_DATASPACE_UNKNOWN),
mMaxBufferCount(BufferQueueDefs::NUM_BUFFER_SLOTS),
mMaxAcquiredBufferCount(1),
mMaxDequeuedBufferCount(1),
mBufferHasBeenQueued(false),
mFrameCounter(0),
mTransformHint(0),
mIsAllocating(false),
mIsAllocatingCondition(),
mAllowAllocation(true),
mBufferAge(0),
mGenerationNumber(0),
mAsyncMode(false),
mSharedBufferMode(false),
mAutoRefresh(false),
mSharedBufferSlot(INVALID_BUFFER_SLOT),
mSharedBufferCache(Rect::INVALID_RECT, 0, NATIVE_WINDOW_SCALING_MODE_FREEZE,
HAL_DATASPACE_UNKNOWN),
mLastQueuedSlot(INVALID_BUFFER_SLOT),
mUniqueId(getUniqueId())
{
int numStartingBuffers = getMaxBufferCountLocked();
for (int s = 0; s < numStartingBuffers; s++) {
mFreeSlots.insert(s);
}
for (int s = numStartingBuffers; s < BufferQueueDefs::NUM_BUFFER_SLOTS;
s++) {
mUnusedSlots.push_front(s);
}
}
void zmfTests::testInstance() {
auto moduleA = std::make_shared<DummyModule>(zmf::data::ModuleUniqueId(13, 37));
auto moduleB = std::make_shared<DummyModule>(zmf::data::ModuleUniqueId(44, 20));
auto coreA = zmf::instance::ZmfInstance::startInstance(moduleA, {});
auto coreB = zmf::instance::ZmfInstance::startInstance(moduleB, {});
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
moduleA->doPublish();
moduleB->doPublish();
moduleA->doRequest(moduleA->getUniqueId());
moduleA->doRequest(moduleB->getUniqueId());
moduleB->doRequest(moduleB->getUniqueId());
moduleB->doRequest(moduleA->getUniqueId());
std::this_thread::sleep_for(std::chrono::milliseconds(5000));
}
Texture::Texture() :
m_size (0, 0),
m_actualSize (0, 0),
m_texture (0),
m_isSmooth (false),
m_sRgb (false),
m_isRepeated (false),
m_pixelsFlipped(false),
m_fboAttachment(false),
m_hasMipmap (false),
m_cacheId (getUniqueId())
{
}
Texture& Texture::operator =(const Texture& right)
{
Texture temp(right);
std::swap(m_size, temp.m_size);
std::swap(m_actualSize, temp.m_actualSize);
std::swap(m_texture, temp.m_texture);
std::swap(m_isSmooth, temp.m_isSmooth);
std::swap(m_isRepeated, temp.m_isRepeated);
std::swap(m_pixelsFlipped, temp.m_pixelsFlipped);
m_cacheId = getUniqueId();
return *this;
}
