FlowVRCegRenderer::FlowVRCegRenderer( flowvr::OutputPort *port,
unsigned int nIdPrefix )
: Renderer()
, m_port(port)
, m_writer( new flowvr::render::ChunkRenderWriter )
, m_nId(0)
, m_nIdPrefix(nIdPrefix)
, m_nIdVs(0)
, m_nIdPs(0)
, m_identifierString( "FlowVRCegRenderer" )
, m_defaultRenderTarget( NULL )
, m_renderingRoot( NULL )
, m_dispSize(640,480)
, m_dispDPI(96,96)
, m_nFBOId(0)
, m_currentTarget(NULL)
{
m_defaultRenderTarget = new FlowVRCegTextureTarget(m_nFBOId++, *this, "defaultRenderTarget" );
m_renderingRoot = new RenderingRoot( *m_defaultRenderTarget );
m_nIdVs = generateID();
m_nIdPs = generateID();
if( !m_writer->loadVertexShader( m_nIdVs, "shaders/texture_menu_v.cg" ) )
m_nIdVs = 0;
if( !m_writer->loadPixelShader ( m_nIdPs, "shaders/texture_menu_p.cg" ) )
m_nIdPs = 0;
}
void MainWindow::on_btnAdd_clicked(){
QString id ;
QString item;
QDate date;
int money;
if (ui->leItem->text() != ""){
item = ui->leItem->text();
money = ui->spMoney->value();
date = ui->date->date();
id = generateID();
if (addMoneyDB(item,money,date,id)){
QDateTime curnentDateTime = QDateTime::currentDateTime();
addItemMoneyTree(item,money,date,id);
addEventDB(curnentDateTime,"Added: " + item
+ " $ "+ QString::number(money)
+ " $ " + date.toString("dd/MM/yyyy"));
ui->leItem->setText("");
ui->spMoney->setValue(0);
log->addEvent(curnentDateTime.toString("yyyy-MM-dd hh:mm:ss")
+ " | Added: " + item
+ " $ " + QString::number(money)
+ " $ " + date.toString("dd/MM/yyyy"));
}
else {
QMessageBox::critical(this,"ERROR","An Error occur, cannot add new item");
qDebug() << "ERROR: Cannot add new item";
}
}
else {
QMessageBox::critical(this,"ERROR","Item field cannot be empty");
qDebug() << "ERROR: Item field cannot be empty";
}
}
Timer *TimerManager::createIndefiniteFreq(TimerObserver *pObs, float frequency)
{
Timer *pTimer = new Timer(generateID(), 0, 0.0f, 1.0f / frequency);
pTimer->registerObserver(pObs);
addTimer(pTimer);
return pTimer;
}
Timer *TimerManager::createIndefinite(TimerObserver *pObs, float interval)
{
Timer *pTimer = new Timer(generateID(), 0, 0.0f, interval);
pTimer->registerObserver(pObs);
addTimer(pTimer);
return pTimer;
}
Timer *TimerManager::createShotLimitedFreq(TimerObserver *pObs, float frequency, float shots)
{
Timer *pTimer = new Timer(generateID(), shots, 0.0f, 1.0f / frequency);
pTimer->registerObserver(pObs);
addTimer(pTimer);
return pTimer;
}
Timer *TimerManager::createShotLimited(TimerObserver *pObs, float interval, float shots)
{
Timer *pTimer = new Timer(generateID(), shots, 0.0f, interval);
pTimer->registerObserver(pObs);
addTimer(pTimer);
return pTimer;
}
Timer *TimerManager::createTimeLimited(TimerObserver *pObs, int shotCount, float time)
{
Timer *pTimer = new Timer(generateID(), 0, time, time / (float)shotCount);
pTimer->registerObserver(pObs);
addTimer(pTimer);
return pTimer;
}
Timer *TimerManager::createOneShot(TimerObserver *pObs, float time)
{
Timer *pTimer = new Timer(generateID(), 1, 0.0f, time);
pTimer->registerObserver(pObs);
addTimer(pTimer);
return pTimer;
}
void GFF4Struct::loadStructs(GFF4File &parent, Field &field) {
if (field.offset == 0xFFFFFFFF)
return;
const GFF4File::StructTemplate &tmplt = parent.getStructTemplate(field.structIndex);
Common::SeekableReadStream &data = parent.getStream(field.offset);
const uint32 structCount = getListCount(data, field);
const uint32 structSize = field.isReference ? 4 : tmplt.size;
const uint32 structStart = data.pos();
field.structs.resize(structCount, 0);
for (uint32 i = 0; i < structCount; i++) {
const uint32 offset = getDataOffset(field.isReference, structStart + i * structSize);
if (offset == 0xFFFFFFFF)
continue;
GFF4Struct *strct = parent.findStruct(generateID(offset, &tmplt));
if (!strct)
strct = new GFF4Struct(parent, offset, tmplt);
strct->_refCount++;
field.structs[i] = strct;
}
}
TilePoint Tile::pat_xBond(Point3 p, TileParam& t) {
TilePattern* pat = t.pattern;
if (!pat) return TilePoint();
float edges[4];
int id = 0;
int id2 = 0;
// Tile top and bottom
float rand = 3.14f;
int row = rowcol(edges[3], edges[1], id, p.y, pat->totalHeight, pat->heights, t.tileHeight, t.tileHeightVar, rand);
if (row == -1) return TilePoint();
// Tile sides
rand = edges[3] * 1.325f + 31.41213f;
float offset = pat->rows[row].offset * t.tileWidth;
if (offset < 0) offset *= -id;
row = rowcol(edges[0], edges[2], id2, p.x + offset, pat->rows[row].totalWidth, pat->rows[row].tiles, t.tileWidth, t.tileWidthVar, rand);
if (row == -1) return TilePoint();
edges[0] -= offset;
edges[2] -= offset;
id = generateID(id2, id);
// Draw it
return drawTile(p, edges, t, id);
}
virtual co::Object* createObject( const uint32_t type )
{
co::Object *object = 0;
switch( type )
{
case SMI_FRAME_SETTINGS:
object = new FrameSettings();
break;
case SMI_RENDER_SETTINGS:
object = new RenderSettings();
break;
case SMI_CAMERA_SETTINGS:
object = new CameraSettings();
break;
case SMI_VOLUME_SETTINGS:
object = new VolumeSettings();
break;
case SMI_VR_PARAMETERS:
object = new VolumeRendererParameters();
break;
}
if( object )
{
object->setID( generateID( type ) );
}
return object;
}
bool button(int x, int y, int w, int h, std::string text,
std::string textureFile, Vector4 color) {
float height = h;
float width = w;
int ID = generateID();
bool showHintText = false;
checkUIRegion(ID, x, y, w, h);
if (state.hotItem == ID) {
if (state.activeItem == ID) {
} else {
showHintText = true;
height = h * (0.96f + 0.04f * cos(timeAnimationAcc / 90.0f));
width = w * (0.96f + 0.04f * cos(timeAnimationAcc / 90.0f));
}
}
float offset_x = (w - width) / 2.0f;
float offset_y = (h - height) / 2.0f;
RenderItem item = generateRenderItem(
RENDER_ITEM_BUTTON, textureFile, text, x, y, width, height,
offset_x, offset_y, color, showHintText);
addToRenderQueue(item);
return checkUIHit(ID);
}
TilePoint Tile::pat_herring(Point3 p, TileParam& t) {
float s = t.tileWidth * 2.f;
float h = t.tileWidth * .5f;
float x = p.x / s;
float y = p.y / s;
int xi = FASTFLOOR(x);
int yi = FASTFLOOR(y);
x = xi * s;
y = yi * s;
int x_id = (int)((p.x - x) / h) % 4;
int y_id = (int)((p.y - y) / h) % 4;
int id = x_id + 4 * y_id;
//Point3 center = Point3(pat_herring_x[id]*h+x, pat_herring_y[id]*h+y, p.z);
float edges[4];
if (!pat_herring_dir[id]) {
edges[0] = (pat_herring_x[id]-1.f) * h + x;
edges[2] = edges[0] + t.tileWidth;
edges[3] = (pat_herring_y[id]-.5f) * h + y;
edges[1] = edges[3] + h;
} else {
edges[0] = (pat_herring_x[id]-.5f) * h + x;
edges[2] = edges[0] + h;
edges[3] = (pat_herring_y[id]-1.f) * h + y;
edges[1] = edges[3] + t.tileWidth;
}
int tid = generateID(xi*4 + (pat_herring_dir[id] ? 0 : pat_herring_id[id]),
yi*4 + (pat_herring_dir[id] ? pat_herring_id[id] : 0));
return drawTile(p, edges, t, tid, pat_herring_dir[id]);
}
bool checkbox(int x, int y, int w, int h, std::string text, bool& checked,
std::string textureFile, Vector4 color) {
float height = h;
float width = w;
int ID = generateID();
bool showHintText = false;
checkUIRegion(ID, x, y, w, h);
if (state.hotItem == ID) {
if (state.activeItem == ID) {
} else {
showHintText = true;
height = h * (0.96f + 0.04f * cos(timeAnimationAcc / 90.0f));
width = w * (0.96f + 0.04f * cos(timeAnimationAcc / 90.0f));
}
}
float offset_x = (w - width) / 2.0f;
float offset_y = (h - height) / 2.0f;
if (!checked) {
float oldAplha = color.a;
color *= 0.5f;
color.a = oldAplha;
}
RenderItem item = generateRenderItem(
RENDER_ITEM_CHECKBOX, textureFile, text, x, y, width, height,
offset_x, offset_y, color, showHintText);
addToRenderQueue(item);
if (checkUIHit(ID)) {
checked = !checked;
return true;
}
return false;
}
BookItem::BookItem(BookItem* parent, const QString& boxLabel)
{
box = true;
parent_item = parent;
MY_ASSERT(parent);
label = boxLabel;
id = generateID();
}
//=======================
// PRIVATE SLOTS
//=======================
//GENERIC SERVER SIGNALS
// New Connection Signals
void WebServer::NewSocketConnection(){
WebSocket *sock = 0;
if(WSServer!=0){
if(WSServer->hasPendingConnections()){
QWebSocket *ws = WSServer->nextPendingConnection();
if( !allowConnection(ws->peerAddress()) ){ ws->close(); }
else{ sock = new WebSocket( ws, generateID(), AUTH); }
}
}else if(TCPServer!=0){
if(TCPServer->hasPendingConnections()){
QSslSocket *ss = TCPServer->nextPendingConnection();
if( !allowConnection(ss->peerAddress()) ){ ss->close(); }
else{ sock = new WebSocket( ss, generateID(), AUTH); }
}
}
if(sock==0){ return; } //no new connection
//qDebug() << "New Socket Connection";
connect(sock, SIGNAL(SocketClosed(QString)), this, SLOT(SocketClosed(QString)) );
connect(EVENTS, SIGNAL(NewEvent(EventWatcher::EVENT_TYPE, QJsonValue)), sock, SLOT(EventUpdate(EventWatcher::EVENT_TYPE, QJsonValue)) );
OpenSockets << sock;
}
Texture& FlowVRCegRenderer::createTexture(const Size& size)
{
FlowVRCegTexture *t = new FlowVRCegTexture( *this, generateID(), "" );
if( t )
{
m_textures.push_back( t );
return *t;
}
// should not reach this point
throw std::exception();
}
int TextureResourcer::createTextureFromWIC(ID3D11Device* device, ID3D11DeviceContext* deviceContext, const char* filename, TextureHandle* texHandle)
{
ID3D11Resource* texture = nullptr;
ID3D11ShaderResourceView* textureView = nullptr;
WCHAR* wfilename = convertMultiByteToWCHAR(filename);
HRESULT hr = CreateWICTextureFromFile(device, deviceContext, wfilename, &texture, &textureView);
delete[] wfilename;
//HRESULT hr = DirectX::CreateDDSTextureFromFile( device, , nullptr, &textureView );
if(!textureView)
{
assert(false);
DebugAssert(textureView, "Failed to load texture: ", filename);
}
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
textureView->GetDesc(&desc);
if(hr)
return hr;
//generate id (which is really an array index)
int index = generateID();
//get size
unsigned int width;
unsigned int height;
GetTextureSizeD3D(texture, &width, &height);
//ensure sizing in textures storage
if(textures.size() <= (unsigned int)index)
textures.resize(index+1);
//add to storage
TextureData& data = textures[index];
data.ID = index;
data.name = filename;
data.width = width;
data.height = height;
data.textureResource = texture;
data.textureView = textureView;
//reference by name
textureNameToId[filename] = index;
TextureHandle hTex = {index};
*texHandle = hTex;
return hr;
}
GFF4Struct::GFF4Struct(GFF4File &parent, const Field &genericParent) :
_parent(&parent), _label(0), _refCount(0), _fieldCount(0) {
_id = generateID(genericParent.offset);
parent.registerStruct(_id, this);
try {
load(parent, genericParent);
} catch (...) {
parent.unregisterStruct(_id);
throw;
}
}
GFF4Struct::GFF4Struct(GFF4File &parent, uint32 offset, const GFF4File::StructTemplate &tmplt) :
_parent(&parent), _label(tmplt.label), _refCount(0), _fieldCount(0) {
_id = generateID(offset, &tmplt);
parent.registerStruct(_id, this);
try {
load(parent, offset, tmplt);
} catch (...) {
parent.unregisterStruct(_id);
throw;
}
}
void GFF4Struct::loadGeneric(GFF4File &parent, Field &field) {
field.offset = getDataOffset(field.isList, field.offset);
if (field.offset == 0xFFFFFFFF)
return;
GFF4Struct *strct = parent.findStruct(generateID(field.offset));
if (!strct)
strct = new GFF4Struct(parent, field);
strct->_refCount++;
field.structs.push_back(strct);
}
BookItem::BookItem(BookItem* parent, const BookDescription& bd, const QString& uid)
{
box = false;
parent_item = parent;
MY_ASSERT(parent);
label = bd.toTextString();
if(uid.isEmpty()) {
id = generateID();
} else {
id = uid;
}
book_descr = bd;
}
GeneratedGrid GridGenerator::randomGrid() {
Grid::idarray_t id = generateID();
double angle_z = _YawAngle_dis(_re);
double angle_y = _PitchAngle_dis(_re);
double angle_x = sampleRollAngle();
double radius = 0;
do {
radius = _Radius_dis(_re);
} while (radius < 24 && radius > 26);
auto center_cords = [&]() { return int(round(_Center_dis(_re))); };
cv::Point2i center{center_cords(), center_cords()};
return GeneratedGrid(id, center, radius, angle_x, angle_y, angle_z);
}
Texture& FlowVRCegRenderer::createTexture(const String& filename,
const String& resourceGroup)
{
FlowVRCegTexture *t = new FlowVRCegTexture( *this, generateID(), std::string(filename.c_str()) );
if( t )
{
t->loadFromFile(filename, resourceGroup);
m_textures.push_back(t);
return *t;
}
// should not reach this point
throw std::exception();
}
//creates an instance of the property populated with the node data
Property::Property(Property* prop, node* v){
id = generateID();
cout << "Property created " << id << endl;
if (prop->argumentType == PTypeAnalog){
cout << " ***** FOR DEBUGGING PURPOSE ONLY ***** " << endl;
AnalogProperty* ap = (AnalogProperty*)prop;
Property* arg = prop->argument;
AnalogProperty* ap2 = (AnalogProperty*)(prop->argument);
argument = new AnalogProperty((AnalogProperty*)(prop->argument), v);
}else if(argumentType == PTypeBoolean){
//todo
}
argumentType = prop->argumentType;
}
metadata()
{
// Create root directory info
stat *rootdir = new stat();
rootdir->st_uid = geteuid();
rootdir->st_gid = getegid();
rootdir->st_mode = 0755 | S_IFDIR;
rootdir->st_nlink = 2;
rootdir->st_blksize = 4096;
rootdir->st_blocks = 1;
rootdir->st_size = 512;
rootdir->fid = generateID();
time_t now = time(NULL);
rootdir->st_mtime = now;
rootdir->st_ctime = now;
rootdir->type = FILETYPE_DIRTY;
dirs[rootdir->fid] = new dir();
};
int TextureResourcer::createTextureFromWIC(ID3D11Device* device, ID3D11DeviceContext* deviceContext, const uint8_t * binaryData, int binaryLength, TextureHandle* texHandle)
{
ID3D11Resource* texture = nullptr;
ID3D11ShaderResourceView* textureView = nullptr;
HRESULT hr = CreateWICTextureFromMemory(device, deviceContext, binaryData ,binaryLength, &texture, &textureView);
//HRESULT hr = DirectX::CreateDDSTextureFromFile( device, , nullptr, &textureView );
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
textureView->GetDesc(&desc);
if(hr)
return hr;
//generate id (which is really an array index)
int index = generateID();
//get size
unsigned int width;
unsigned int height;
GetTextureSizeD3D(texture, &width, &height);
//ensure sizing in textures storage
if(textures.size() <= (unsigned int)index)
textures.resize(index+1);
//add to storage
TextureData& data = textures[index];
data.ID = index;
data.name = "";
data.width = width;
data.height = height;
data.textureResource = texture;
data.textureView = textureView;
TextureHandle hTex = {index};
*texHandle = hTex;
return hr;
}
void FileStore::scan(const string & a_path) {
if (!fs::exists(a_path))
return;
if (fs::is_directory(a_path)) {
fs::directory_iterator end; // default construction yields past-the-end
for (fs::directory_iterator curr(a_path); curr != end; ++curr) {
fs::path p = curr->path();
string s = p.string();
scan(s);
}
} else if (fs::is_regular_file(a_path)) {
if (pathExists(a_path))
return;
TagLib::FileRef file_ref(a_path.c_str(), false);
if (!file_ref.isNull() && file_ref.tag()) {
cerr << "indexing " << a_path << endl;
TagLib::Tag *t = file_ref.tag();
string artist = t->artist().to8Bit(true);
string album = t->album().to8Bit(true);
string title = t->title().to8Bit(true);
string genre = t->genre().to8Bit(true);
string year = t->year() > 0 ? lexical_cast<string>(t->year()) : "";
string track = t->track() > 0 ? lexical_cast<string>(t->track()) : "";
string uri = "file://" + a_path;
shared_ptr<UUID> fileID(generateID());
addField(*fileID, ARTIST, artist);
addField(*fileID, ARTIST, artist);
addField(*fileID, ALBUM, album);
addField(*fileID, YEAR, year);
addField(*fileID, TITLE, title);
addField(*fileID, GENRE, genre);
addField(*fileID, TRACK, track);
addField(*fileID, URI, uri);
}
}
}
bool CContentDownloader::Startup( const bool _bPreview, bool _bReadOnlyInstance )
{
g_Log->Info( "Attempting to start contentdownloader...", _bPreview );
Shepherd::initializeShepherd();
Shepherd::setRedirectServerName( g_Settings()->Get( "settings.content.redirectserver", std::string(REDIRECT_SERVER) ).c_str() );
std::string root = g_Settings()->Get( "settings.content.sheepdir", g_Settings()->Root() + "content" );
if (root.empty())
{
root = g_Settings()->Root() + "content";
g_Settings()->Set( "settings.content.sheepdir", root );
}
Shepherd::setRootPath( root.c_str() );
Shepherd::setCacheSize( g_Settings()->Get( "settings.content.cache_size", 2000 ), 0 );
Shepherd::setCacheSize( g_Settings()->Get( "settings.content.cache_size_gold", 2000 ), 1 );
if (g_Settings()->Get( "settings.content.unlimited_cache", true) == true)
Shepherd::setCacheSize( 0, 0 );
if (g_Settings()->Get( "settings.content.unlimited_cache_gold", true) == true)
Shepherd::setCacheSize( 0, 1 );
Shepherd::setPassword( g_Settings()->Get( "settings.content.password_md5", std::string("") ).c_str() );
Shepherd::setUniqueID( g_Settings()->Get( "settings.content.unique_id", generateID() ).c_str() );
Shepherd::setUseProxy( g_Settings()->Get( "settings.content.use_proxy", false ) );
Shepherd::setRegistered( g_Settings()->Get( "settings.content.registered", false ) );
Shepherd::setProxy( g_Settings()->Get( "settings.content.proxy", std::string("") ).c_str() );
Shepherd::setProxyUserName( g_Settings()->Get( "settings.content.proxy_username", std::string("") ).c_str() );
Shepherd::setProxyPassword( g_Settings()->Get( "settings.content.proxy_password", std::string("") ).c_str() );
Shepherd::setSaveFrames( g_Settings()->Get( "settings.generator.save_frames", false ) );
SheepGenerator::setNickName( g_Settings()->Get( "settings.generator.nickname", std::string("") ).c_str() );
SheepGenerator::setURL( g_Settings()->Get( "settings.generator.user_url", std::string("") ).c_str() );
m_gDownloader = NULL;
if( g_Settings()->Get( "settings.content.download_mode", true ) && _bReadOnlyInstance == false)
{
m_gDownloader = new SheepDownloader();
g_Log->Info( "Starting download thread..." );
m_gDownloadThread = new boost::thread( boost::bind( &SheepDownloader::shepherdCallback, m_gDownloader ) );
#ifdef WIN32
SetThreadPriority( (HANDLE)m_gDownloadThread->native_handle(), THREAD_PRIORITY_BELOW_NORMAL );
SetThreadPriorityBoost( (HANDLE)m_gDownloadThread->native_handle(), TRUE );
#else
struct sched_param sp;
sp.sched_priority = 6; //Background NORMAL_PRIORITY_CLASS - THREAD_PRIORITY_BELOW_NORMAL
pthread_setschedparam( (pthread_t)m_gDownloadThread->native_handle(), SCHED_RR, &sp );
#endif
}
else
g_Log->Warning( "Downloading disabled." );
if( g_Settings()->Get( "settings.generator.enabled", true ) && _bReadOnlyInstance == false)
{
// Create the generators based on the number of processors.
uint32 ncpus = 1;
if( g_Settings()->Get( "settings.generator.all_cores", false ) )
{
#ifdef WIN32
SYSTEM_INFO sysInfo;
GetSystemInfo( &sysInfo );
ncpus = (uint32)sysInfo.dwNumberOfProcessors;
#else
#ifdef MAC
ncpus = static_cast<uint32>(MPProcessors());
#else
#ifdef LINUX_GNU
ncpus = sysconf( _SC_NPROCESSORS_ONLN );
#endif
#endif
#endif
}
if (ncpus > 1)
--ncpus;
uint32 i;
for( i=0; i<ncpus; i++ )
{
g_Log->Info( "Starting generator for core %d...", i );
gGenerators.push_back( new SheepGenerator() );
gGenerators[i]->setGeneratorId( i );
}
g_Log->Info( "Starting generator threads..." );
for( i=0; i<gGenerators.size(); i++ )
{
gGeneratorThreads.push_back( new boost::thread( boost::bind( &SheepGenerator::shepherdCallback, gGenerators[i] ) ) );
#ifdef WIN32
SetThreadPriority( (HANDLE)gGeneratorThreads[i]->native_handle(), THREAD_PRIORITY_IDLE );
SetThreadPriorityBoost( (HANDLE)gGeneratorThreads[i]->native_handle(), FALSE );
#else
struct sched_param sp;
sp.sched_priority = 1; //THREAD_PRIORITY_IDLE - THREAD_PRIORITY_IDLE
pthread_setschedparam( (pthread_t)gGeneratorThreads[i]->native_handle(), SCHED_RR, &sp );
#endif
}
}
else
g_Log->Warning( "Generators disabled..." );
g_Log->Info( "...success" );
return true;
}
int EntryController::add(tm date, std::string category, std::string description, float amount)
{
int id = generateID();
addData(new Entry(id, mktime(&date), category, description, amount));
return id;
}
