OpenCLModuleQt::OpenCLModuleQt(const std::string& modulePath)
: VoreenModuleQt(modulePath)
{
setID("OpenCL (Qt)");
setGuiName("OpenCL (Qt)");
registerPropertyWidgetFactory(new OpenCLPropertyWidgetFactory());
registerProcessorWidgetFactory(new OpenCLProcessorWidgetFactory());
}
CPlayerList::CPlayerList(CJogador *Jogador)
{
setID(-1);
_first = new SPlayerElemento();
_first->valor = Jogador;
_first->next = NULL;
_first->prev = NULL;
_size = 1;
}
void EQPlayer::setPlayerID(uint16_t playerID)
{
if (m_playerID != playerID)
{
printf("Your player's id is %i\n", playerID);
m_playerID = playerID;
emit setID(m_playerID);
}
}
Session::Session(unsigned int id, std::string tulpa_name, int session_type_id, std::string description, int duration, std::string date)
{
setID(id);
setTypeID(session_type_id);
setTulpaName(tulpa_name);
setDescription(description);
setDuration(duration);
setDate(date);
}
CocosTile::CocosTile(std::string name, std::string tileID, std::string extension)
:Tile(name, tileID, extension)
{
_sprite = NULL;
_tileName = name;
_tileExt = extension;
setID(tileID);
}
CBuffList::CBuffList(CBuff *Buff)
{
setID(-1);
_first = new SBuffElemento();
_first->valor = Buff;
_first->next = NULL;
_first->prev = NULL;
_size = 1;
}
void WIcon::setIcon(const hacc::TDBID &iconID)
{
setID(iconID);
if (!m_connected)
{
m_connected = connect(HACC_DB_ICONS, SIGNAL(updated(hacc::TDBID)), this, SLOT(updated(hacc::TDBID)));
}
refreshIdIcon();
}
AntiAirUnit::AntiAirUnit(DefenseUnit *inUnit, AI *ai) : DefenseUnit(inUnit, ai) {
setID(inUnit->getID());
setPos(inUnit->getPosX(), inUnit->getPosY());
setDistanceTo(inUnit->getDistanceTo());
setState(inUnit->getState());
setRadius(inUnit->getRadius());
setArmor(inUnit->getArmor());
}
CCenarioList::CCenarioList(CCenario *Cenario)
{
setID(-1);
_first = new SCenarioElemento();
_first->valor = Cenario;
_first->next = NULL;
_first->prev = NULL;
_size = 1;
}
/******************************************************************************
* Student()
* This default constructor will create a Student object
*****************************************************************************/
Student::Student()
{
setName("");
setID(0);
setPhoneNumber(0);
setAge(0);
setClassStanding("");
setGPA(0.0);
}
/* ==========================================================================
DESC
@param null nothing
@return null nothing
========================================================================== */
void Page::init() {
setID(DEFAULT_PAGE_NAME);
PageSubstrate = NULL;
MarginTop = 0.0;
MarginBottom = 0.0;
MarginLeft = 0.0;
MarginRight = 0.0;
setUnits(in);
}
StereoscopyModuleQt::StereoscopyModuleQt(const std::string& modulePath)
: VoreenModuleQt(modulePath)
{
setID("Stereoscopy (Qt)");
setGuiName("Stereoscopy (Qt)");
addShaderPath(getModulePath("glsl/qt"));
registerProcessorWidgetFactory(new StereoscopyProcessorWidgetFactory());
}
Vic2::State::State(std::set<std::pair<int, Vic2::Province*>> theProvinces)
{
for (auto province: theProvinces)
{
provinceNums.insert(province.first);
provinces.insert(province.second);
}
setID();
determineIfPartialState();
}
void Session::loadFromJSON()
{
setID(root["id"].asInt());
setTypeID(root["id_action"].asInt());
setTulpaName(root["tulpa_name"].asString());
setDescription(root["description"].asString());
setDuration(root["duration"].asInt());
setDate(root["date"].asString());
setWritingLog(root["writing_log"].asString());
}
void
daeIDRef::resolveID()
{
if (state == id_empty) {
if (element != NULL)
setID(element->getID());
else
state = id_failed_invalid_reference;
}
}
/******************************************************************************
* Student()
* This constructor will receive the student's name and id and create a
* student object with that info
*****************************************************************************/
Student::Student(string studentName, //The Student's Name
int studentId) //The Student's ID
{
setName(studentName);
setID(studentId);
setPhoneNumber(0);
setAge(0);
setClassStanding("");
setGPA(0.0);
}
/**
* enterInformation function
* Sets ID and password and invokes checkMatchIDPassword function. If the function returns false, "Wrong Username or Password" message appears on the screen
*/
void Login::enterInformation()
{
setPassword();
if(checkMatchIDPassword() == true){
setID();
}
else {
eyegui::setContentOfTextBlock(pLayout, "textblock", "Wrong Username or Password");
}
}
void CompoundTransliterator::adoptTransliterators(Transliterator* adoptedTransliterators[],
int32_t transCount) {
// First free trans[] and set count to zero. Once this is done,
// orphan the filter. Set up the new trans[].
freeTransliterators();
trans = adoptedTransliterators;
count = transCount;
computeMaximumContextLength();
setID(joinIDs(trans, count));
}
bool LLTextureEntry::fromLLSD(LLSD& sd)
{
const char *w, *x;
w = "imageid";
if (sd.has(w))
{
setID( sd[w] );
} else goto fail;
w = "colors";
if (sd.has(w))
{
setColor( ll_color4_from_sd(sd["colors"]) );
} else goto fail;
w = "scales";
x = "scalet";
if (sd.has(w) && sd.has(x))
{
setScale( (F32)sd[w].asReal(), (F32)sd[x].asReal() );
} else goto fail;
w = "offsets";
x = "offsett";
if (sd.has(w) && sd.has(x))
{
setOffset( (F32)sd[w].asReal(), (F32)sd[x].asReal() );
} else goto fail;
w = "imagerot";
if (sd.has(w))
{
setRotation( (F32)sd[w].asReal() );
} else goto fail;
w = "bump";
if (sd.has(w))
{
setBumpShiny( sd[w].asInteger() );
} else goto fail;
w = "fullbright";
if (sd.has(w))
{
setFullbright( sd[w].asInteger() );
} else goto fail;
w = "media_flags";
if (sd.has(w))
{
setMediaTexGen( sd[w].asInteger() );
} else goto fail;
w = "glow";
if (sd.has(w))
{
setGlow((F32)sd[w].asReal() );
}
return true;
fail:
return false;
}
/* Attach a disk image to the true drive emulation. */
int drive_image_attach(disk_image_t *image, unsigned int unit)
{
unsigned int dnr;
drive_t *drive;
if (unit < 8 || unit >= 8 + DRIVE_NUM)
return -1;
dnr = unit - 8;
drive = drive_context[dnr]->drive;
if (drive_check_image_format(image->type, dnr) < 0)
return -1;
drive->read_only = image->read_only;
drive->attach_clk = drive_clk[dnr];
if (drive->detach_clk > (CLOCK)0)
drive->attach_detach_clk = drive_clk[dnr];
drive->ask_extend_disk_image = 1;
switch(image->type)
{
case DISK_IMAGE_TYPE_D64:
case DISK_IMAGE_TYPE_D67:
case DISK_IMAGE_TYPE_D71:
case DISK_IMAGE_TYPE_G64:
case DISK_IMAGE_TYPE_X64:
disk_image_attach_log(image, 0, unit);
break;
default:
return -1;
}
drive->image = image;
drive->image->gcr = drive->gcr;
if (drive->image->type == DISK_IMAGE_TYPE_G64) {
if (disk_image_read_gcr_image(drive->image) < 0) {
drive->image = NULL;
return -1;
}
} else {
if (setID(dnr) >= 0) {
drive_image_read_d64_d71(drive);
drive->GCR_image_loaded = 1;
return 0;
} else {
return -1;
}
}
drive->GCR_image_loaded = 1;
return 0;
}
/** Additional constructor.
*/
CEdge( CNodePtr n1,
CNodePtr n2,
CEdgeTypePtr type,
Eigen::VectorXd &features ) : m_features( features ),
m_type(type)
{
m_id = setID();
setNodeTypes( n1, n2, type );
}
//Constructor for solid objects.
MagicEffectItem::MagicEffectItem(const TransformMap& transformMap)
{
this->transformMap = transformMap;
unsigned short type = 0;
TransformMap::const_iterator dm = transformMap.begin();
if(dm != transformMap.end()) {
type = dm->first;
}
setID(type);
buildCondition();
}
void VisualCorner::changeToT(boost::shared_ptr<VisualLine> stem) {
cornerType = T;
tStem = stem;
if (line1 == stem) {
tBar = line2;
} else {
tBar = line1;
}
setID(T_CORNER);
setTOrientation();
}
void
RODFRouteCont::addRouteDesc(RODFRouteDesc& desc) {
// routes may be duplicate as in-between routes may have different starting points
if (find_if(myRoutes.begin(), myRoutes.end(), route_finder(desc)) == myRoutes.end()) {
// compute route id
setID(desc);
myRoutes.push_back(desc);
} else {
RODFRouteDesc& prev = *find_if(myRoutes.begin(), myRoutes.end(), route_finder(desc));
prev.overallProb += desc.overallProb;
}
}
CWeapon::CWeapon()
{
setID(-1);
setDurability(0);
_raca = ALLRACE;
_modificador = 0;
_danoMin = 0;
_danoMax = 0;
_velocidade = 0;
_alcance = 0;
_nivelMagico = 0;
}
VolumeLabelingModule::VolumeLabelingModule(const std::string& modulePath)
: VoreenModule(modulePath)
{
setID("VolumeLabeling");
setGuiName("VolumeLabeling");
addShaderPath(getModulePath("glsl"));
registerSerializableType(new IDRaycaster());
registerSerializableType(new VolumeLabeling());
}
cell::cell(double ID, double X, double Y, double Z, std::string North, std::string South,std::string East, std::string West)
{
setID(ID);
setX(X);
setY(Y);
setZ(Z);
setNorth(North);
setSouth(South);
setEast(East);
setWest(West);
}
RenderTarget2D::RenderTarget2D(GraphicsDevice* device, const uint32 width, const uint32 height, const uint32 samples) : Texture(device, width, height),
framebuffer(0),
r(0.0f),
g(0.0f),
b(0.0f),
a(0.0f) {
uint32 txid = 0;
device->createRendertarget(txid, framebuffer, width, height, samples);
setID(txid);
}
void Core::deserialize(std::stringstream & file)
{
int graphic = 0;
int id = 0;
file >> graphic
>> isDead_
>> id
>> owner_;
pos_.deserialize(file);
health_.deserialize(file);
graphic_ = graphic;
setID(id);
}
/** Additional constructor.
*/
CEdge( CNodePtr &n1,
CNodePtr &n2,
CEdgeTypePtr type,
Eigen::VectorXd &features,
Eigen::MatrixXd &potentials) : m_features( features ),
m_potentials(potentials),
m_type(type)
{
m_id = setID();
setNodeTypes( n1, n2, type );
}