void KeyEventProcessing(unsigned char key, int x, int y) {
switch(key) {
case '1':
shadingModel = 0;
break;
case '2':
shadingModel = 1;
break;
case 'x':
if(particleLifetime <= 10000) {
particleLifetime = particleLifetime+100;
initParticleSystem();
}
std::cout<<"ParticleLifetime changed to: "<<particleLifetime<<std::endl;
break;
case 'y':
if(particleLifetime >= 100) {
particleLifetime = particleLifetime-100;
initParticleSystem();
}
std::cout<<"ParticleLifetime changed to: "<<particleLifetime<<std::endl;
break;
case 'c':
if(particleCol.a > 0)
particleCol.a = particleCol.a-0.1;
std::cout<<"ParticleAlpha changed to: "<<particleCol.a<<std::endl;
break;
case 'v':
if(particleCol.a < 1)
particleCol.a = particleCol.a+0.1;
std::cout<<"ParticleAlpha changed to: "<<particleCol.a<<std::endl;
break;
case 'b':
if(particleCount > 100) {
particleCount = particleCount - 100;
initParticleSystem();
}
std::cout<<"ParticleCount changed to: "<<particleCount<<std::endl;
break;
case 'n':
if(particleCount < maxParticleCount) {
particleCount = particleCount + 100;
initParticleSystem();
}
std::cout<<"ParticleCount changed to: "<<particleCount<<std::endl;
break;
case 'o':
if(cometSpeedMul < 10)
cometSpeedMul = cometSpeedMul + 0.1;
std::cout<<"CometSpeed Multiplier changed to: "<<cometSpeedMul<<std::endl;
break;
case 'l':
if(cometSpeedMul > 0)
cometSpeedMul = cometSpeedMul - 0.1;
std::cout<<"CometSpeed Multiplier changed to: "<<cometSpeedMul<<std::endl;
break;
}
}
/**
* \fn int updateVision(sInterface *p_interface, sMap *p_map)
* \brief Fonction de mise à jour de la position du joueur
*
* \param *p_interface pointeur vers une structure de type sInterface
* \param *p_map pointeur vers une structure de type sMap
* \return int représentant le déroulement de la fonction
*/
int updateVision(sInterface *p_interface, sMap *p_map) {
if (!(p_interface->player.isSliding)) {
SDL_RenderCopy(p_interface->renderer, p_interface->player.playerSprite[p_interface->player.direction], NULL, &(p_interface->player.realPosition));
return 0;
}
if (comparePositionRect(p_interface->player.realPosition, p_interface->player.realDestination)) {
SDL_RenderCopy(p_interface->renderer, p_interface->player.playerSprite[p_interface->player.direction], NULL, &(p_interface->player.realPosition));
p_interface->solution = dijkstra(p_map, getMapPosition(p_interface->player.realPosition));
p_interface->player.isSliding = FALSE;
}else {
if(!(p_interface->effect.particle))
initParticleSystem(&(p_interface->effect.particle), PATRICLE_SYSTEM_LIFETIME, PARTICLE_AMOUNT, p_interface->player.realPosition, p_interface->player.direction);
SDL_RenderCopy(p_interface->renderer, p_interface->player.playerSprite[p_interface->player.direction], NULL, &(p_interface->player.realPosition));
if(p_interface->player.direction == DUP)
p_interface->player.realPosition.y -= ((WINDOW_HEIGHT / CASE_LINE_AMOUNT) / SDL_ANIMATION_SLIDE_FRAMEAMOUNT);
if (p_interface->player.direction == DRIGHT)
p_interface->player.realPosition.x += ((WINDOW_WIDTH / CASE_COLUMN_AMOUNT) / SDL_ANIMATION_SLIDE_FRAMEAMOUNT);
if (p_interface->player.direction == DDOWN)
p_interface->player.realPosition.y += ((WINDOW_HEIGHT / CASE_LINE_AMOUNT) / SDL_ANIMATION_SLIDE_FRAMEAMOUNT);
if (p_interface->player.direction == DLEFT)
p_interface->player.realPosition.x -= ((WINDOW_WIDTH / CASE_COLUMN_AMOUNT) / SDL_ANIMATION_SLIDE_FRAMEAMOUNT);
}
return 0;
}
Flag::Flag(irr::IrrlichtDevice* a_Device, ETeamIdentifier a_TeamIdentifier) : m_TeamIdentifier(new ETeamIdentifier(a_TeamIdentifier)),
m_FlagStatus(new EFlagEnum(EFlagEnum::FlagBase)) {
//Get drivers to load model
auto sceneManager = a_Device->getSceneManager();
auto videoDriver = a_Device->getVideoDriver();
//Flags
m_StartPosition = new irr::core::vector3df();
m_StartRotation = new irr::core::vector3df();
//Load model
IrrAssimp irrAssimp(sceneManager);
irr::scene::IAnimatedMesh* mesh = sceneManager->getMesh("Media/Meshes/Flag.3ds");
m_FlagNode = sceneManager->addMeshSceneNode(mesh, 0, 2);
m_FlagNode->setMaterialFlag(irr::video::E_MATERIAL_FLAG::EMF_LIGHTING, false);
m_FlagNode->setScale({ 1.5f, 1.5f, 1.5f });
m_FlagNode->setDebugDataVisible(irr::scene::EDS_BBOX_ALL);
m_FlagOldParent = m_FlagNode->getParent();
//Set Color
setColor(videoDriver);
//Add colission box and particle system
initParticleSystem(sceneManager);
}
//Initialisierungsfunktion
void Initialize(int argc, char* argv[])
{
GLenum GlewInitResult;//neue Variable vom Typ GLenum (um GLEW initialisation zu prüfen)
//initialisiert das anzeige-Window
InitWindow(argc, argv);
glewExperimental = GL_TRUE;//GLEW erhät Informationen zu den Erweiterungen des Grafiktreibers
GlewInitResult = glewInit();//initialisieren von GLEW
//Überprüfen, ob GLEW Initialisierung erfolgreich, wenn nicht wird ein Error geworfen und Programm beendet
if (GLEW_OK != GlewInitResult)
{
fprintf(
stderr,
"ERROR: %s\n",
glewGetErrorString(GlewInitResult)
);
glutExit();
}
//Ausgabe der OpenGL Version
fprintf(
stdout,
"INFO: OpenGL Version: %s\n",
glGetString(GL_VERSION)
);
glGetError();//gibt Fehlerinformationen aus
glClearColor(0.20f, 0.2f, 0.2f, 0.0f); //setzt die Farbe, mit der die Buffer gecleart werden (Parameter bezüglich GLUT_RGBA)
glEnable(GL_DEPTH_TEST);//aktiviert: Tiefenvergleiche und update des Tiefenbuffers (Wenn nicht aktiviert: kein tiefenvergleich, selbst mit aktiviertem Tiefenbuffer)
glDepthFunc(GL_LESS);//Spezifiziert die Variable, die für den Tiefenbuffer genutzt wird (in diesem Fall: wenn Übergebene Tiefenvariable kleiner(Less) als die gespeicherte ist)
ModelViewMatrixStack.loadIdentity();//setzt die aktuelle Matrix als Identitätsmatrix
ProjectionMatrix.setIdentity();//setzt die Projektionsmatrix als Identitätsmatrix
SetupShader();//Lädt und linked die shader
LoadModel();//Lädt modelle
loadTextures();//texturen laden
initParticleSystem();//initialize particle system
std::cout<<"\nChange Shader:\n"<<
"1 - simple Shader\n"<<
"2 - phong Shader\n"<<
"\n"<<
"Particle System:\n"<<
"y - decrease maximum Lifetime of the particles\n"<<
"x - increase maximum Lifetime of the particles\n"<<
"\n"<<
"c - decrease color alpha\n"<<
"v - increase color alpha\n"<<
"\n"<<
"b - decrease particle count\n"<<
"n - increase particle count\n"<<
"\n"<<
"o - increase comet speed\n"<<
"l - decrease comet speed\n";
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
// Write the xyz file
char outfile[256];
sprintf(outfile, "outfile.xyz");
if ((fpout = fopen(outfile, "w")) == NULL) {
printf("Cannot Open File\n");
exit(1);
}
printf("%s Starting...\n\n", sSDKsample);
numParticles = NUM_PARTICLES;
uint gridDim = GRID_SIZE;
numIterations = 0;
gridSize.x = gridSize.y = gridSize.z = gridDim;
printf("grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
printf("particles: %d\n", numParticles);
cudaInit(argc, argv);
initParticleSystem(numParticles, gridSize);
printf("%e\n", timestep);
//psystem->dumpParticles(0, numParticles-1, 0);
if (numIterations <= 0)
{
numIterations = (int)(2.0/timestep);
}
std::cout << "1. I am here \n";
runBenchmark(numIterations, argv[0]);
std::cout << "2. I am here \n";
if (psystem) {
delete psystem;
cleanup();
}
cudaDeviceReset();
exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
numParticles = NUM_PARTICLES;
uint gridDim = GRID_SIZE;
numIterations = 0;
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **) argv, "n"))
{
numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n");
}
if (checkCmdLineFlag(argc, (const char **) argv, "grid"))
{
gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid");
}
}
gridSize.x = gridSize.y = gridSize.z = gridDim;
printf("grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
printf("particles: %d\n", numParticles);
if (checkCmdLineFlag(argc, (const char **) argv, "i"))
{
numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i");
}
cudaInit(argc, argv);
initParticleSystem(numParticles, gridSize);
initParams();
if (numIterations <= 0) numIterations = 300;
runBenchmark(numIterations, argv[0]);
if (psystem)
{
delete psystem;
}
exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
glutInitContextVersion(3, 2);
glutInitWindowSize(W, H);
glutCreateWindow ("Project");
glutDisplayFunc(display);
//Startar tidsfunktionen
glutTimerFunc(5, &onTimer, 0);
//Startar knappfunktionen
glutSpecialFunc(key);
//Initialiserar partikelsystemet
initParticleSystem();
//Initialiserar ritandet av partiklar
initDrawParticles();
zprInit(&viewMatrix, cam, point);
glutMainLoop();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
glutInitContextVersion(3, 2);
glutInitWindowSize(W, H);
glutCreateWindow ("Project");
glutDisplayFunc(display);
glutTimerFunc(5, &onTimer, 0);
glutReshapeFunc(reshape);
glutSpecialFunc(key);
initParticleSystem();
initDrawParticles();
zprInit(&viewMatrix, cam, point);
glutMainLoop();
return 0;
}
// Main program
//*****************************************************************************
int main(int argc, char** argv)
{
numParticles = NUM_PARTICLES;
uint gridDim = GRID_SIZE;
pArgc = &argc;
pArgv = argv;
shrQAStart(argc, argv);
// Start logs and timers
cExecutableName = argv[0];
shrSetLogFileName ("oclParticles.txt");
shrLog("%s Starting...\n\n", argv[0]);
// check command line flags and parameters
if (argc > 1)
{
shrGetCmdLineArgumenti(argc, (const char**)argv, "n", (int*)&numParticles);
shrGetCmdLineArgumenti(argc, (const char**)argv, "grid", (int*)&gridDim);
bQATest = shrCheckCmdLineFlag(argc, (const char**)argv, "qatest");
bNoPrompt = shrCheckCmdLineFlag(argc, (const char**)argv, "noprompt");
}
// Set and log grid size and particle count, after checking optional command-line inputs
gridSize.x = gridSize.y = gridSize.z = gridDim;
shrLog(" grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x * gridSize.y * gridSize.z);
shrLog(" particles: %d\n\n", numParticles);
// initialize GLUT and GLEW
if(!bQATest)
{
InitGL(&argc, argv);
}
// initialize OpenCL
startupOpenCL(argc,(const char**)argv);
// init simulation parameters and objects
initParticleSystem(numParticles, gridSize);
initParams();
// Init timers
shrDeltaT(0); // timer 0 is for processing time measurements
shrDeltaT(1); // timer 1 is for fps measurement
// Start main GLUT rendering loop for processing and rendering,
// or otherwise run No-GL Q/A test sequence
if(!bQATest)
{
glutMainLoop();
}
else
{
TestNoGL();
}
// Normally unused return path
shrQAFinish(argc, (const char **)argv, QA_PASSED);
Cleanup(EXIT_SUCCESS);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
printf("%s Starting...\n\n", sSDKsample);
numParticles = NUM_PARTICLES;
maxNumParticles = MAX_NUM_PARTICLES;
uint gridDim = GRID_SIZE;
numIterations = 0;
printf("Surely I can get this far\n");
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **) argv, "n"))
{
numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n");
}
if (checkCmdLineFlag(argc, (const char **) argv, "grid"))
{
gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid");
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", &g_refFile);
fpsLimit = frameCheckNumber;
numIterations = 1;
}
}
//*******************************************************
// RMK Hard code for cylindrical coords (y=theta=1)
// DomainSize
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big-refine/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big-refine/RVert.txt";
char Zfile[] = "/home/rkeedy/CFD/BuoyantStrumJet85-big-refine-lighter/ZVert.txt";
char Rfile[] = "/home/rkeedy/CFD/BuoyantStrumJet85-big-refine-lighter/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet62-big-refine-lighter/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet62-big-refine-lighter/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big-refine/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big-refine/RVert.txt";
//char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet63-big-refine/ZVert.txt";
//char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet63-big-refine/RVert.txt";
numVelNodes.x = filecount(Rfile); //-1;
numVelNodes.z = filecount(Zfile); //-1;
numVelNodes.y = 1;
numCells.x = 80; //47; //24; //29;
numCells.y = 1;
numCells.z = 160; //188; //95; //88;
numParticles = numCells.x*numCells.z*20; //avgnumparticles = 40
srand( time( NULL ) );
//numParticles = numCells.x*numCells.z*40;
printf("vel grid: %d x %d x %d = %d cells\n", numVelNodes.x, numVelNodes.y, numVelNodes.z, numVelNodes.x*numVelNodes.y*numVelNodes.z);
printf(" grid: %d x %d x %d = %d cells\n", numCells.x, numCells.y, numCells.z, numCells.x*numCells.y*numCells.z);
//printf("vel grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
bool benchmark = checkCmdLineFlag(argc, (const char **) argv, "benchmark") != 0;
if (checkCmdLineFlag(argc, (const char **) argv, "i"))
{
numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i");
}
if (g_refFile)
{
cudaInit(argc, argv);
}
else
{
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
{
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -file=<*.bin>\n", argv[0]);
printf("exiting...\n");
exit(EXIT_SUCCESS);
}
initGL(&argc, argv);
cudaGLInit(argc, argv);
}
// Moved code snippet to CellSystem
//initCellSystem(gridSize);
// now moved to particlesystem
printf("Begin initialization\n");
//initParticleSystem(numParticles, gridSize, g_refFile==NULL);
initParticleSystem(maxNumParticles, numParticles, numVelNodes, numCells, g_refFile==NULL);
//printf("Finished with initParticleSystem, %d\n",g_refFile==NULL);
//cin.ignore();
initParams();
printf("Finished with initialization\n");
if (!g_refFile)
{
initMenus();
}
if (benchmark || g_refFile)
{
if (numIterations <= 0)
{
numIterations = 300;
}
runBenchmark(numIterations, argv[0]);
}
else
{
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutIdleFunc(idle);
atexit(cleanup);
glutMainLoop();
}
if (psystem)
{
delete psystem;
}
cudaDeviceReset();
exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
#if defined(__linux__)
setenv ("DISPLAY", ":0", 0);
#endif
printf("%s Starting...\n\n", sSDKsample);
printf("NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.\n\n");
numParticles = NUM_PARTICLES;
uint gridDim = GRID_SIZE;
numIterations = 0;
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **) argv, "n"))
{
numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n");
}
if (checkCmdLineFlag(argc, (const char **) argv, "grid"))
{
gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid");
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", &g_refFile);
fpsLimit = frameCheckNumber;
numIterations = 1;
}
}
gridSize.x = gridSize.y = gridSize.z = gridDim;
printf("grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
printf("particles: %d\n", numParticles);
bool benchmark = checkCmdLineFlag(argc, (const char **) argv, "benchmark") != 0;
if (checkCmdLineFlag(argc, (const char **) argv, "i"))
{
numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i");
}
if (g_refFile)
{
cudaInit(argc, argv);
}
else
{
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
{
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -file=<*.bin>\n", argv[0]);
printf("exiting...\n");
exit(EXIT_SUCCESS);
}
initGL(&argc, argv);
cudaGLInit(argc, argv);
}
initParticleSystem(numParticles, gridSize, g_refFile==NULL);
initParams();
if (!g_refFile)
{
initMenus();
}
if (benchmark || g_refFile)
{
if (numIterations <= 0)
{
numIterations = 300;
}
runBenchmark(numIterations, argv[0]);
}
else
{
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutIdleFunc(idle);
glutCloseFunc(cleanup);
glutMainLoop();
}
if (psystem)
{
delete psystem;
}
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS);
}
