void App::init()
{
// Check if main instance already exists
if (App::main_instance_)
{
throw Error ("Cannot create multiple apps at once.");
}
// Initialize SDL
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
throw Error ("Could not initialize SDL.");
}
// Allow app to modify config
Window::Config config;
onInit(config);
// Create new window with config
window_ = std::make_unique<Window>(config);
asset_manager_ = std::make_unique<AssetManager>();
// Initialize GLEW with created window context
glewExperimental = true;
if (glewInit() != GLEW_OK)
{
throw Error ("Failed to init GLEW.");
}
// Flush errors caused by GLEW
while (glGetError());
App::main_instance_ = this;
should_quit_ = false;
}
bool ArticulatedViewer::onEvent(const GEvent& e, App* app) {
if ((e.type == GEventType::MOUSE_BUTTON_DOWN) && (e.button.button == 0) && ! app->userInput->keyDown(GKey::LCTRL)) {
// Intersect all tri lists with the ray from the camera
const Ray& ray = app->activeCamera()->worldRay(e.button.x, e.button.y,
app->renderDevice->viewport());
m_selectedPart = NULL;
m_selectedMesh = NULL;
m_selectedTriangleIndex = -1;
Model::HitInfo hitInfo;
float distance = finf();
const bool hit = m_model->intersect(ray, m_offset, ArticulatedModel::defaultPose(), distance, hitInfo);
if (hit) {
// shared_ptr<ArticulatedModel> model = dynamic_pointer_cast<ArticulatedModel>(hitInfo.model);
// alwaysAssertM(notNull(model), "Not a model!");
m_selectedMesh = m_model->mesh(hitInfo.meshID);
m_selectedTriangleIndex = hitInfo.primitiveIndex;
}
if (notNull(m_selectedMesh)) {
m_selectedPart = m_selectedMesh->logicalPart;
}
return hit;
} else if ((e.type == GEventType::KEY_DOWN) && (e.key.keysym.sym == 'r')) {
onInit(m_filename);
return true;
}
return false;
}
void Core::init(int width, int height) {
if (0 != SDL_Init(SDL_INIT_VIDEO)) {
//fprintf(stderr, "\nUnable to initialize SDL: %s\n", SDL_GetError());
Error::getInstance().fail(ErrorCodes::UNKNOWN);
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
m_camera.init(width, height);
//_entityManager->getSystemManager()->addSystem<PhysicsSystem>(Component::getComponentBitmask<PositionComponent, PhysicsComponent, CollisionComponent>())->init();
_entityManager->getSystemManager()->addSystem<RenderSystem>(Component::getComponentBitmask<TextureComponent, PositionComponent>())->init(&m_camera);
// _entityManager->getSystemManager();
onInit();
loop();
}
int AppBase::run()
{
if (!onInit()) {
return -1;
}
frame_timer.reset();
// game main loop begin .
SDL_Event evnt;
leave_main_loop = false;
while (!leave_main_loop) {
if (SDL_PollEvent(&evnt)) {
processGlobalEvent(evnt);
if (onEvent(evnt) == false) {
processUnhandleEvent(evnt);
}
}
if (!leave_main_loop) {
onUpdate();
onRender();
}
frame_timer.update();
}
onExit();
return 0;
}
void Process::initWorker()
{
log_debug("init worker");
log_debug("onInit");
onInit();
if (!tnt::TntConfig::it().group.empty())
{
log_debug("set group to \"" << tnt::TntConfig::it().group << '"');
::setGroup(tnt::TntConfig::it().group);
}
if (!tnt::TntConfig::it().user.empty())
{
log_debug("set user to \"" << tnt::TntConfig::it().user << '"');
::setUser(tnt::TntConfig::it().user);
}
if (!tnt::TntConfig::it().dir.empty())
{
log_debug("set dir to \"" << tnt::TntConfig::it().dir << '"');
::setDir(tnt::TntConfig::it().dir);
}
if (!tnt::TntConfig::it().chrootdir.empty())
{
log_debug("change root to \"" << tnt::TntConfig::it().chrootdir << '"');
::setRootdir(tnt::TntConfig::it().chrootdir);
}
signal(SIGTERM, sigEnd);
signal(SIGINT, sigEnd);
signal(SIGHUP, sigReload);
}
int CDotWars::onExecute()
{
currentTime = SDL_GetTicks();
if(onInit() == false) {
return -1;
}
a.setColor(0, 0, 0xff);
a.setPosition(50, 100);
a.velocity.x = 0;
a.velocity.y = 0;
b.color = 0x00FF00FF;
a.gravity = false;
gravityOverlord.playerDot = &a;
//da_overlord.mouseDot = &b;
SDL_Event Event;
while(running) {
while(SDL_PollEvent(&Event)) {
onEvent(&Event);
}
onLoop();
onRender();
}
onCleanup();
return 0;
}
bool
ICamDevice::
init()
{
Mutex::Autolock lock(mMtxLock);
return onInit();
}
pcl::OpenNIGrabber::OpenNIGrabber (const std::string& device_id, const Mode& depth_mode, const Mode& image_mode)
: rgb_sync_ ()
, ir_sync_ ()
, device_ ()
, rgb_frame_id_ ()
, depth_frame_id_ ()
, image_width_ ()
, image_height_ ()
, depth_width_ ()
, depth_height_ ()
, image_required_ (false)
, depth_required_ (false)
, ir_required_ (false)
, sync_required_ (false)
, image_signal_ (), depth_image_signal_ (), ir_image_signal_ (), image_depth_image_signal_ ()
, ir_depth_image_signal_ (), point_cloud_signal_ (), point_cloud_i_signal_ ()
, point_cloud_rgb_signal_ (), point_cloud_rgba_signal_ ()
, config2xn_map_ (), depth_callback_handle (), image_callback_handle (), ir_callback_handle ()
, running_ (false)
, rgb_array_size_ (0)
, depth_buffer_size_ (0)
, rgb_focal_length_x_ (std::numeric_limits<double>::quiet_NaN ())
, rgb_focal_length_y_ (std::numeric_limits<double>::quiet_NaN ())
, rgb_principal_point_x_ (std::numeric_limits<double>::quiet_NaN ())
, rgb_principal_point_y_ (std::numeric_limits<double>::quiet_NaN ())
, depth_focal_length_x_ (std::numeric_limits<double>::quiet_NaN ())
, depth_focal_length_y_ (std::numeric_limits<double>::quiet_NaN ())
, depth_principal_point_x_ (std::numeric_limits<double>::quiet_NaN ())
, depth_principal_point_y_ (std::numeric_limits<double>::quiet_NaN ())
{
// initialize driver
onInit (device_id, depth_mode, image_mode);
if (!device_->hasDepthStream ())
PCL_THROW_EXCEPTION (pcl::IOException, "Device does not provide 3D information.");
depth_image_signal_ = createSignal<sig_cb_openni_depth_image> ();
ir_image_signal_ = createSignal<sig_cb_openni_ir_image> ();
point_cloud_signal_ = createSignal<sig_cb_openni_point_cloud> ();
point_cloud_i_signal_ = createSignal<sig_cb_openni_point_cloud_i> ();
ir_depth_image_signal_ = createSignal<sig_cb_openni_ir_depth_image> ();
ir_sync_.addCallback (boost::bind (&OpenNIGrabber::irDepthImageCallback, this, _1, _2));
if (device_->hasImageStream ())
{
// create callback signals
image_signal_ = createSignal<sig_cb_openni_image> ();
image_depth_image_signal_ = createSignal<sig_cb_openni_image_depth_image> ();
point_cloud_rgb_signal_ = createSignal<sig_cb_openni_point_cloud_rgb> ();
point_cloud_rgba_signal_ = createSignal<sig_cb_openni_point_cloud_rgba> ();
rgb_sync_.addCallback (boost::bind (&OpenNIGrabber::imageDepthImageCallback, this, _1, _2));
openni_wrapper::DeviceKinect* kinect = dynamic_cast<openni_wrapper::DeviceKinect*> (device_.get ());
if (kinect)
kinect->setDebayeringMethod (openni_wrapper::ImageBayerGRBG::EdgeAware);
}
image_callback_handle = device_->registerImageCallback (&OpenNIGrabber::imageCallback, *this);
depth_callback_handle = device_->registerDepthCallback (&OpenNIGrabber::depthCallback, *this);
ir_callback_handle = device_->registerIRCallback (&OpenNIGrabber::irCallback, *this);
}
INT_PTR CALLBACK dlgRen_msgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
INT_PTR status = FALSE;
if (uMessage == WM_COMMAND) {
switch (LOWORD(wParam)) {
case IDOK:
if (onOk(hDlg)) {
::EndDialog(hDlg, 1);
status = TRUE;
}
break;
case IDCANCEL:
::EndDialog(hDlg, 0);
status = TRUE;
break;
}
}
else if (uMessage == WM_INITDIALOG) {
_dialogData = (ChildDialogData*)lParam;
onInit(hDlg);
}
return status;
}
int main(int argc, char **argv)
{
// inicializace knihovny GLUT
glutInit(&argc, argv);
// inicializaci parametru programu
onInit();
// nastaveni grafickeho modu okna programu
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE);
// nastaveni pocatecnich rozmeru okna programu
glutInitWindowSize(default_frame_w, default_frame_h);
// vytvoreni hlavniho okna pogramu
glutCreateWindow(PROGRAM_TITLE);
// registrace fukce zajistujici prekresleni obsahu okna programu
glutDisplayFunc(onDisplay);
// registrace funkce reagujici na zmenu rozmeru okna programu
glutReshapeFunc(onResize);
// registrace funkce reagujici na stisknuti klavesnice
glutKeyboardFunc(onKeyboard);
// registrace funkce reagujici na stisknuti tlacitka mysi
glutMouseFunc(onMouseClick);
// registrace funkce reagujici na pohyb mysi
glutMotionFunc(onMouseMotion);
// nekonecna smycka volajici registrovane funkce
glutMainLoop();
return 0;
}
//--------------------------------------------------------------------------
// Main global function
//--------------------------------------------------------------------------
S3E_MAIN_DECL void IwMain()
{
#ifdef EXAMPLE_DEBUG_ONLY
// Test for Debug only examples
#endif
onInit();
while (1)
{
s3eDeviceYield(0);
s3eKeyboardUpdate();
bool result = onUpdate();
if (
(result == false) ||
(s3eKeyboardGetState(s3eKeyEsc) & S3E_KEY_STATE_DOWN)
||
(s3eKeyboardGetState(s3eKeyLSK) & S3E_KEY_STATE_DOWN)
||
(s3eDeviceCheckQuitRequest())
) {
break;
}
onRender();
s3eSurfaceShow();
}
onShutDown();
}
void State::
init()
{
Command* initCommand = onInit();
if (0 != initCommand) {
initCommand->execute();
}
}
World::World(GraphicsManager *gm) : grMananger(gm) {
objects.push_back(Entity{grMananger->getBuffer(ObjectType::Cube),
grMananger->getShader(ShaderType::Standard),
grMananger,
0, 0, 0,
TextureType::Dice});
onInit();
}
void APIMod::init(CharString file){ // , CharString name, CharString language, CharString version
this->file = file;
loadProperties();
onInit();
inited=true;
}
VoiceMessages::VoiceMessages() : _current(0),
_fader(new VoiceMessagesFader(&_faderThread)), _loader(new VoiceMessagesLoader(&_loaderThread)) {
connect(this, SIGNAL(faderOnTimer()), _fader, SLOT(onTimer()));
connect(this, SIGNAL(loaderOnStart(AudioData*)), _loader, SLOT(onStart(AudioData*)));
connect(this, SIGNAL(loaderOnCancel(AudioData*)), _loader, SLOT(onCancel(AudioData*)));
connect(&_faderThread, SIGNAL(started()), _fader, SLOT(onInit()));
connect(&_loaderThread, SIGNAL(started()), _loader, SLOT(onInit()));
connect(&_faderThread, SIGNAL(finished()), _fader, SLOT(deleteLater()));
connect(&_loaderThread, SIGNAL(finished()), _loader, SLOT(deleteLater()));
connect(_loader, SIGNAL(needToCheck()), _fader, SLOT(onTimer()));
connect(_loader, SIGNAL(error(AudioData*)), this, SLOT(onError(AudioData*)));
connect(_fader, SIGNAL(needToPreload(AudioData*)), _loader, SLOT(onLoad(AudioData*)));
connect(_fader, SIGNAL(playPositionUpdated(AudioData*)), this, SIGNAL(updated(AudioData*)));
connect(_fader, SIGNAL(audioStopped(AudioData*)), this, SIGNAL(stopped(AudioData*)));
connect(_fader, SIGNAL(error(AudioData*)), this, SLOT(onError(AudioData*)));
_loaderThread.start();
_faderThread.start();
}
void Solid::onChangeParent(Kernel::Object*)
{
InternalMessage("Physic","Ode::Solid::onChangeParent entering " +
Kernel::toString(getObject()->getIdentifier())) ;
onClose() ;
onInit() ;
InternalMessage("Physic","Ode::Solid::onChangeParent leaving " +
Kernel::toString(getObject()->getIdentifier())) ;
}
bool CPPModule::init(const std::string& jsonParams) {
JSONNode n = libjson::parse(jsonParams);
std::map<std::string, std::string> tmpParams;
JSONNode::iterator i = n.begin();
for(; i!=n.end(); ++i) {
tmpParams[(*i).name()] = (*i).as_string();
}
return onInit(tmpParams);
}
void GuiComponent::init()
{
onInit();
for(unsigned int i = 0; i < mChildren.size(); i++)
{
mChildren.at(i)->init();
}
}
Font::Font(std::string path, int size)
{
//register to receive init/deinit callbacks
Renderer::registerComponent(this);
mPath = path;
mSize = size;
onInit();
}
/// Constructor.
CobFiducialsNode(ros::NodeHandle& nh)
: sub_counter_(0),
endless_counter_(0),
color_image_8U3_(0)
{
camera_matrix_initialized_ = false;
/// Void
node_handle_ = nh;
onInit();
}
/**
* Creates a new drawer, and makes the graph with all the data needed
* @param bhg BBHG to print
* @param props properties to apply to all the items of the graph
* (the Graph itself, Nodes, and Edges)
* @param driver Driver to use to create the graph. The default is graphviz_driver
*/
BBHGDrawer::BBHGDrawer(BBHG *bhg, const PropList& props, display::Driver& driver): _made(false) {
PropList general, nodes, edges;
general.addProps(props);
nodes.addProps(props);
edges.addProps(props);
onInit(general, nodes, edges);
_graph = driver.newGraph(general, nodes, edges);
_bhg = bhg;
}
void MainWindow::onStart()
{
if (!task_)
{
task_ = new DownloadTask(this);
connect(task_, SIGNAL(inited()), this, SLOT(onInit()));
connect(task_, SIGNAL(downloadProgress(qint64, qint64, qint64)), this, SLOT(onDownloadProgress(qint64, qint64, qint64)));
connect(task_, SIGNAL(finished()), this, SLOT(onFinished()));
task_->init("", "http://ermaopcassist.qiniudn.com/ErmaoPcAssist2.0.0.2.exe", &mgr_);
}
task_->start();
}
struct basic_epoll_event *http_server::onWriteDone()
{
if (!persistent)
return this->close();
else
{
// TCP_CORK is needed only when not closing the socket
int option = 0;
if (0 > setsockopt(fd, IPPROTO_TCP, TCP_CORK, &option, sizeof(option)))
LOGGER_PERROR_STR("TCP_CORK release");
return onInit();
}
}
bool NoobaPlugin::init()
{
// TODO: Need to load previous configurations from QSettings
qDebug() << _alias << " about to initialise " << Q_FUNC_INFO;
initSignalSlots();
bool ok = _api->init();
if(!ok)
qDebug() << tr("plugin: '%1' initialisation failed!").arg(_alias) << Q_FUNC_INFO;
else
qDebug() << _alias << " initialised successfully " << Q_FUNC_INFO;
emit onInit(this);
return ok;
}
void App::init()
{
/* Check if main instance already exists */
if (App::main_instance_)
{
throw Error ("Cannot create multiple apps at once.");
}
/* Initialize SDL */
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
throw Error ("Could not initialize SDL.");
}
/* Allow app to modify config */
Window::Config config;
onInit(config);
/* Create new window with config */
window_ = std::make_unique<Window>(config);
/* Initialize GLEW with created window context */
glewExperimental = true;
if (glewInit() != GLEW_OK)
{
throw Error ("Failed to init GLEW.");
}
/* Flush errors caused by GLEW */
while (glGetError());
/* Initialize controllers */
keyboard_ = std::make_unique<Keyboard>();
mouse_ = std::make_unique<Mouse>();
/* Register SDL event handlers */
addEventHandler(getWindow());
addEventHandler(getKeyboard());
addEventHandler(getMouse());
scene_ = std::make_unique<Scene>();
renderer_ = std::make_unique<Renderer>(
window_->getWidth(),
window_->getHeight());
App::main_instance_ = this;
should_quit_ = false;
onPostInit();
}
////////////////////////////////////////////////////////////////////////
/// Function: Preload
/// Description: Sets up the function pointers from the core,
/// maintains a module count and calls onInit() when called for the first time
/// Returns: An enumeration type defined in PBPlugin.h
/// Author: Paul Henderson
/// Date: May 2009
////////////////////////////////////////////////////////////////////////
BOOL PBModule::Preload(PPBSTRUCT pPBStructure, PPBCORESTRUCT pPBCoreStructure)
{
m_pCoreStructure = pPBCoreStructure;
m_pCurrentPBstruct = pPBStructure;
++m_iLoadCount;
PPBINSTSTRUCT pInstStruct = new PBInstStruct;
if(pInstStruct == NULL){
Log(PB_LOG_ERROR,L"Mem allocation",L"Preload",__LINE__);
return FALSE;
}
pInstStruct->instID = pPBStructure->iTabID;
pInstStruct->pWrappedObj = NULL;
pInstStruct->pNext = NULL;
if(m_pInstHead == NULL){
pPBCoreStructure->pLoggingFunc(PB_LOG_INFO,L"First call",L"Preload",__LINE__,m_szModName);
m_pInstHead = pInstStruct;
if(!onInit(pPBStructure)){ ///>let the derived class know about it by calling it's onInit()
pPBCoreStructure->pLoggingFunc(PB_LOG_ERROR,L"Failed to initialise in the derived object",L"Preload",__LINE__,m_szModName);///>log error
return FALSE;
}
}
else{
/**
*
* go through the linked list and look for a match
*/
PPBINSTSTRUCT pInst;
for(pInst = m_pInstHead;pInst->pNext;pInst = pInstStruct->pNext)
{
if(pInst->instID == pPBStructure->iTabID){
pPBCoreStructure->pLoggingFunc(PB_LOG_ERROR,L"Preload called twice same instance",L"Preload",__LINE__,m_szModName);
delete pInstStruct;
return FALSE;
}
}
pInst->pNext = pInstStruct;
}
if(!onAttachInstance(pPBStructure,pInstStruct)){///>let the derived object know about a new PB app instance
Log(PB_LOG_ERROR,L"Failed onAttachInstance in the derived object",L"Preload",__LINE__);///>log error
return FALSE; ///>error the derived function has failed
}
return TRUE;
}
//---------------------------------------------------------------------
// Hlavni funkce konzolove aplikace
//---------------------------------------------------------------------
int main(int argc, char **argv)
{
glutInit(&argc, argv); // inicializace knihovny GLUT
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);// nastaveni dvou barvovych bufferu a pameti hloubky
glutInitWindowPosition(30, 30); // pocatecni pozice leveho horniho rohu okna
glutInitWindowSize(600, 600); // pocatecni velikost okna
glutCreateWindow("inpg3 - semestrálka, zadání èíslo 3.");// vytvoreni okna pro kresleni
glutDisplayFunc(onDisplay); // registrace funkce volane pri prekreslovani okna
glutReshapeFunc(onResize); // registrace funkce volane pri zmene velikosti okna
glutKeyboardFunc(onKeyboard); // registrace funkce volane pri stlaceni klavesy
onInit(); // inicializace vykreslovani
glutMainLoop(); // nekonecna smycka, kde se volaji zaregistrovane funkce
return 0; // navratova hodnota vracena operacnimu systemu
}
int Core::onExecute()
{
if(onInit() == false)
return -1;
SDL_Event event;
//seed random
srand(time(0));
//For controlling framerate
int dt_frame = 0;
int dt_current = 0;
int dt_previous = 0;
while(running_)
{
//Process events
while(SDL_PollEvent(&event))
{
//Quit game event
if(event.type == SDL_QUIT)
{
running_ = false;
}
//Process game events
pGame_->onEvent(&event);
}
//Regulate framerate;
dt_previous = dt_current;
dt_current = pDelta_->getTicks();
dt_frame = dt_current - dt_previous;
if(dt_frame < (FRAME_RATE))
{
SDL_Delay(FRAME_RATE - dt_frame);
}
//Process game loop
pGame_->onLoop(pDelta_->getTicks());
//Render game world
pGame_->onRender();
//Swap buffers
SDL_GL_SwapBuffers();
}
onCleanup();
return 0;
}//End onExecute()
void BaseTraitView::_init()
{
/*!
We initialise only if the view point has been initialised.
*/
if (m_viewpoint)
{
if (! m_initialised && m_viewpoint->isInitialised())
{
onInit() ;
m_initialised = true ;
}
}
}
//------------------------------------------------------------------------------
// Main game loop inside the onExecute() method
//------------------------------------------------------------------------------
int Client::onExecute() {
if(onInit() == false) {
return -1;
}
SDL_Event event;
Uint32 fps = 60;
Uint32 frametime = 1000 / fps;
Uint32 starttime, exectime;
while(running) {
starttime = SDL_GetTicks();
// start by checking for OpenGL error
GLenum error;
while ((error = glGetError()) != GL_NO_ERROR) {
printf("Error: %s\n", gluErrorString(error));
}
// check for input events
while(SDL_PollEvent(&event)) {
onEvent(&event);
}
// act on input events
onInput();
// TODO more game state updates here,
// like applying velocity, gravity, etc
p1->onUpdate();
if (follow) {
setXView(p1->getX());
setYView(p1->getY());
}
// draw the screen
onRender();
// sleep time to make fps
exectime = SDL_GetTicks() - starttime;
if (exectime < frametime) {
//SDL_Delay(SDL_GetTicks() % frametime);
SDL_Delay(frametime - exectime);
}
}
onCleanup();
return 0;
}