int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
Application game;
MSG msg;
long prevTick, curTick = GetTickCount();
game.Initialize();
while(true)
{
if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if(msg.message==WM_QUIT)break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
prevTick = curTick;
curTick = GetTickCount();
game.Update((curTick - prevTick)/1000.f);
game.Render();
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
Application app;
app.Initialize();
app.Run();
return 0;
}
int main(int argc, char** argv) {
Application app;
app.Initialize();
app.Run();
app.Terminate();
return 0;
}
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE prevInstance, LPWSTR cmdLine, int cmdShow)
{
UNREFERENCED_PARAMETER(prevInstance);
UNREFERENCED_PARAMETER(cmdLine);
Application application = Application();
application.Initialize(hInstance, cmdShow);
return application.Run();
}
int main()
{
Application application;
if (!application.Initialize(L"resources/scene6.test"))
return -1;
application.Render();
application.Shutdown();
return 0;
}
INT WINAPI wWinMain(HINSTANCE,HINSTANCE,LPWSTR,INT)
{
(void)HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
Application application; // Manages the application logic.
if (application.Initialize())
{
application.MessageLoop();
}
return 0;
}
// Application runtime ----------------------------------------------------------------
Int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pScmdline, Int iCmdshow)
{
Application* Instance;
// Create the application instance
Instance = new Application();
if(!Instance) { return 0; }
// Initialize and run the application instance
if(Instance->Initialize()) { Instance->Run(); }
// Shutdown and release the application instance
Instance->Shutdown(); delete Instance;
Instance = nullptr;
_CrtDumpMemoryLeaks();
return 0;
}
int main(int argc, char* args[])
{
//Create the only instance of the App
Application* mainApp = Application::GetApp();
if (mainApp == nullptr)
{
//Print to output
Log::GetLog().LogCriticalMsg("Failed to create mainApp");
}
if (!mainApp->Initialize())
{
Log::GetLog().LogCriticalMsg("Failed to Init mainApp");
}
mainApp->Run();
return 0;
}
int main(int argc, char **argv)
#endif
{
// Create application object
Application app;
try {
app.Initialize();
}
catch (Ogre::Exception& e) {
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
MessageBox(nullptr, (wchar_t*)e.getFullDescription().c_str(), L"An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
fprintf(stderr, "An exception has occured: %s\n",
e.getFullDescription().c_str());
#endif
}
return 0;
}
int main(int argc, char *argv[])
{
Application app;
app.Initialize();
while (!app.quit) {
app.GameInput();
if (app.GameManager->MainGame) {
app.Loop();
}
else if (app.GameManager->EndMenu) {
app.DeathScreen();
}
else if (app.GameManager->MainMenu) {
app.MainMenu();
}
}
SDL_Quit();
return 0;
}
int WINAPI
WinMain(HINSTANCE hInst, HINSTANCE /* hPrevInstance */, LPSTR /* lpCmdLine */, int nCmdShow)
{
if (SUCCEEDED(CoInitialize(0))) {
Application* app = new Application();
if (SUCCEEDED(app->Initialize(hInst, nCmdShow))) {
int num;
LPWSTR* args = CommandLineToArgvW(GetCommandLine(), &num);
if (args) {
if (num > 1) {
app->SetImageFile(args[1]);
}
}
app->RunMessageLoop();
LocalFree(args);
}
delete app;
CoUninitialize();
}
return 0;
}
int WINAPI WinMain( HINSTANCE hInst, HINSTANCE prevInst, PSTR cmdLine, int cmdShow)
{
#if defined(DEBUG) || defined(_DEBUG)
FIND_MEMORY_LEAKS;
#endif
#ifdef TEST
SmartPtrArr<int> myarr;
myarr = new int[10];
for (int i = 0; i < 10; i++)
{
myarr[i] = i;
}
char tex[10];
for (int i = 0; i < 10; i++)
{
char t[1];
itoa(i, t, 10);
tex[i] = t[0];
}
#else
Application app;
if(!app.Initialize(hInst))
return cmdShow;
app.Run();
app.Shutdown();
return cmdShow;
#endif
}
int WINAPI WinMain(
HINSTANCE /* hInstance */,
HINSTANCE /* hPrevInstance */,
LPSTR /* lpCmdLine */,
int /* nCmdShow */
)
{
//_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
EasyServer::GetInstance();
//DevConsoleCreate();
//ShellExecute(NULL, L"open", L"C:\\Users\\Administrator\\Documents\\TangoMike\\Src\\TangoMike\\Release\\TangoMike.exe", NULL, NULL, SW_SHOWNORMAL);
std::srand(unsigned(std::time(0)));
// Ignoring the return value because we want to continue running even in the
// unlikely event that HeapSetInformation fails.
//HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
if (SUCCEEDED(CoInitialize(NULL)))
{
{
XMLBackup::GetInstance()->LoadData();
Application app;
Relationship::GetInstance()->LoadDataFromXMLBackup();
if (SUCCEEDED(app.Initialize()))
{
app.RunMessageLoop();
}
}
CoUninitialize();
}
Relationship::FreeInstance();
XMLBackup::FreeInstance();
EasyServer::FreeInstance();
return 0;
}
int main()
{
// Our application initialization params
Application::InitializationParams initParams = {};
initParams.sApplicationName = "Chronicles of a Fallen Soul";
initParams.sEngineName = "Wonderland";
initParams.sApplicationVersion = VK_MAKE_VERSION(0, 0, 1);
initParams.sEngineVersion = VK_MAKE_VERSION(0, 0, 1);
initParams.sTotalNumberPeonThreads = 4;
initParams.sThreadRingBufferSize = 65000;
// Create and initialize the main application
Application mainApplication = {};
if (!mainApplication.Initialize(initParams))
{
return false;
}
// Run the main loop
mainApplication.MainLoop();
//
bool result;
//
// Get all creator a register instances we need
Flux::ClassCreator* classCreatorInstance = Flux::ClassCreator::GetInstance();
Flux::ClassRegister* classRegisterInstance = Flux::ClassRegister::GetInstance();
Flux::TypeCreator* typeCreatorInstance = Flux::TypeCreator::GetInstance();
Flux::TypeRegister* typeRegisterInstance = Flux::TypeRegister::GetInstance();
Flux::DynamicMemberFunctionCreator* memberFunctionCreatorInstance = Flux::DynamicMemberFunctionCreator::GetInstance();
// Basic type registration //
Flux::Type* intType = typeCreatorInstance->CreateType("int");
Flux::Type* floatType = typeCreatorInstance->CreateType("float");
Flux::Type* charType = typeCreatorInstance->CreateType("char");
Flux::Type* stringType = typeCreatorInstance->CreateType("string");
Flux::Type* booleanType = typeCreatorInstance->CreateType("bool");
Flux::Type* vectorType = typeCreatorInstance->CreateType("vector");
// Class creation //
// Create a new class
Flux::Class* newClass = classCreatorInstance->CreateClass("Car");
if (newClass == nullptr)
{
return false;
}
// Create a variable from the created class
Flux::MemberVariable speedVariable;
result = speedVariable.Build(floatType, "m_Speed");
if (!result)
{
return false;
}
// Add the member variable
result = newClass->AddMemberVariable(speedVariable);
if(!result)
{
return false;
}
// Create a variable from the created class
Flux::MemberVariable distanceVariable;
result = distanceVariable.Build(intType, "m_CurrentDistance");
if (!result)
{
return false;
}
// Add the member variable
result = newClass->AddMemberVariable(speedVariable);
if (!result)
{
return false;
}
// Create a variable from the created class
Flux::MemberVariable costVariable;
result = costVariable.Build(floatType, "m_CostPerDistance");
if (!result)
{
return false;
}
// Add the member variable
result = newClass->AddMemberVariable(speedVariable);
if (!result)
{
return false;
}
// Function creation //
// Create the nem member function
Flux::DynamicMemberFunction* newFunction = memberFunctionCreatorInstance->CreateDynamicMemberFunction("CalculateTime", *newClass);
if (newFunction == nullptr)
{
return false;
}
/*
- Handle precisa ter um id de versão
*/
/*
=> Dynamic Function:
- Head -> Definições de uma função (qual o nome, se pertence à uma classe, quais entradas... etc)
- Body -> Como esta definido o seu corpo, quais funções (boxes) são utilizados, quais foram as ligações efetuadas, variáveis utilizadas... etc
- Linker -> Realização da compilação da DynamicFunction em realtime.
*/
/*
- Vamos ter uma nova classe que vai ser tipo um box, ele vai contar o ponto inicial, final e vai possuir blocos que vão se ligar entre si, esses blocos fazem referência
à um box conectado.
- Começando no bloco inicial, vamos ir para o proximo, aqui podemos ter por exemplo uma função membro, nosso objetivo será pegar os dados da função membro, fazer a chamada
com ela utilizando as variáveis linkadas (nota que não foi incluido a geração dos nomes das variáveis).
- Após isso vamos para a proxima função, que pode ser um loop por exemplo, o loop deve criar uma variável que vai ser o contador e usar os parâmetros de entrada para realizar
as chamadas seguintes.
- Da pra perceber que o ideal é fechar cada bloco, por exemplo no primeiro, podemos passar as variáveis linkadas aos sockets de entrada para o "fechador" da função membro
utilizada e ela fica responsável por usar essas entradas e gerar a chamada, podendo até mesmo retornar e assim seguimos para a proxima box ou continuar por conta propria.
- No segundo exemplo nos iriamos para um loop, ele vai ter os valores de entrada (index inicial, final, etc) e provavelmente deveriamos continuar a execução por conta
propria.
- Temos que pensar em como vamos fazer os ifs, os sequences, sets, gets, for eachs, prints, etc... São todas funções standard, intrinsic.
- Talvez devemos separar tipo, funções membro, funções normais, loop for, if, set, get e assim vai... Só que as funções (tanto membro quando normais) existiriam de várias
formas precisando serem registradas enquanto os outros seriam classes especializadas que não precisariam serem registradas, afinal já teriamos uma de cada tipo.
- O ideal seria que tivermos uma forma de criar essas funções intrinsics, talvez seja possível faze-las na parte de funções normais ou quem sabe fazer um criador para elas.
*/
/*
- Uma box pode ter inputs e outputs, não importa qual o tipo de box.
- Uma input/output pode ser de vários tipos.
- Uma box pode ser uma função, uma caixa de debug, um start ou end dentro de uma função, etc.
- Uma input/output pode ser uma variável, um valor absoluto, uma constante, etc.
- Uma input/output pode ter um valor temporário para teste na engine.
- Uma input/output pode ser uma array, nesse caso ele não pode possuir um valor absoluto e sim deve ser uma variável.
- Uma box SEMPRE deve ter (se tiver) apenas UMA entrada.
- Uma box pode ter várias saídas desde que mantenha em mente que as saídas serão executadas em sequência (depende da interpretação da box)
*/
////////////////
// INITIALIZE //
////////////////
MainViewController viewController;
viewController.Initialize();
////////////////////////
////////////////////////
////////////////////////
return 0;
}
int wmain(int argc, wchar_t* argv[])
{
CommandLineArgs args;
Application application;
try
{
#if _DEBUG
MessageBoxW(0, argv[1], 0, 0);
#endif
application.Initialize();
if (!args.ProcessCommandLine(argc, argv))
{
args.WriteOutput();
return 0;
}
int result = 0;
OpcUa_StatusCode uStatus = OpcUa_Good;
if (args.StorePath.length() > 0)
{
OpcUa_Char* wszFilePath = 0;
uStatus = OpcUa_StringToUnicode((OpcUa_StringA)args.StorePath.c_str(), &wszFilePath);
if (OpcUa_IsBad(uStatus))
{
args.OutputParameters["-error"] = "Could not access certificate store.";
args.OutputParameters["-storePath"] = args.StorePath;
args.WriteOutput();
return 0;
}
// create the store.
result = _wmkdir((wchar_t*)wszFilePath);
if (result != 0)
{
result = errno;
}
OpcUa_Free(wszFilePath);
wszFilePath = 0;
}
if (result != 0 && result != EEXIST)
{
if (_strnicmp(args.StorePath.c_str(), "LocalMachine", strlen("LocalMachine")) != 0 && _strnicmp(args.StorePath.c_str(), "CurrentUser", strlen("CurrentUser")) != 0)
{
args.OutputParameters["-error"] = "Could not access certificate store.";
args.OutputParameters["-storePath"] = args.StorePath;
args.WriteOutput();
return 0;
}
}
// create a new certificate.
if (args.Command.empty() || args.Command == "issue")
{
application.Issue(args);
args.WriteOutput();
return 0;
}
// revoke a certificate
if (args.Command == "revoke" || args.Command == "unrevoke")
{
application.Revoke(args);
args.WriteOutput();
return 0;
}
// convert a certificate
if (args.Command == "convert" || args.Command == "install")
{
application.Convert(args);
args.WriteOutput();
return 0;
}
// convert a replace
if (args.Command == "replace")
{
application.Replace(args);
args.WriteOutput();
return 0;
}
// create a certificate request.
if (args.Command == "request")
{
application.CreateRequest(args);
args.WriteOutput();
return 0;
}
// process a certificate request.
if (args.Command == "process")
{
application.ProcessRequest(args);
args.WriteOutput();
return 0;
}
args.OutputParameters["-error"] = "Unsupported command.";
args.OutputParameters["-command"] = args.Command;
args.WriteOutput();
}
catch (StatusCodeException e)
{
args.OutputParameters["-error"] = e.GetMessage();
try
{
args.WriteOutput();
}
catch (...)
{
// ignore.
}
}
catch (...)
{
args.OutputParameters["-error"] = "Unhandled exception.";
try
{
args.WriteOutput();
}
catch (...)
{
// ignore.
}
}
application.Uninitialize();
return 0;
}
