Esempio n. 1
0
void CDrawManager::init()
{
	initWindow();
	initDirectX();
}
Esempio n. 2
0
void op3d::Engine::run()
{
    initWindow();
    initVulkan();
    mainLoop();
}
Esempio n. 3
0
HRESULT Win::init() {
	HRESULT hr = initWindow();
	return hr;
}
Esempio n. 4
0
File: itd.c Progetto: ACCITD/ITD
int main(int argc,  char* argv[]) {
	int width = 1024, height = 768;
	if(argc == 5 && strcmp(argv[2], "-r") == 0 ){
		width = atoi(argv[3]);
		height = atoi(argv[4]);
	}
	else if(argc == 4 && strcmp(argv[1], "-r") == 0 ){
		width = atoi(argv[2]);
		height = atoi(argv[3]);	
	}
	
	/*Initialisation SDL, OpenGL etc */
	if( initWindow(width, height) == EXIT_FAILURE){
		perror("Impossible d'initialiser la fenêtre SDL, le programme va fermer.\n");
		exit(-1);
	}

	/* initialisation de SDL_TTF*/
	if(TTF_Init()== -1){
		printf("Error loading TTF: %s\n",TTF_GetError());
		exit(1);
	}
	bool askedForQuit = false;
	World world;
	world.towersList = NULL;
	world.map.name = NULL;
	world.map.tabXYConstruct = NULL;
	world.map.image = NULL;
	world.map.pathNodeList = NULL;
	Interface interface;
	interface.lstButtons = NULL;
	char* mapName= NULL;
	BUTTON_OF_MENU.lstMapName = NULL;
	BUTTON_OF_MENU.lstMapButton = NULL;
	BUTTON_OF_MENU.lstMapTextureIndex = NULL;
	bool play = false;
	
	List* lstMaps = createEmptyList();
	readDirectory(lstMaps);
	/* selection d'une carte en ligne de commande*/
	if (argc >= 2 && strcmp(argv[1], "-r") != 0){
		char* curMap = NULL;
		while( (curMap = (char*) nextData(lstMaps)) != NULL){
			if (strcmp(argv[1],curMap)==0){
				mapName = (char*) malloc(strlen(argv[1])*sizeof(char));
				if(mapName == NULL){
					fprintf(stderr, "Erreur fatale : impossible d'allouer la mémoire nécessaire.\n");
					exit(EXIT_FAILURE);
				}
				strcpy(mapName,argv[1]);
				play = true;
				break;	
			}	

		}
		if(! play) fprintf(stderr, "Erreur le nom donné en paramètre ne correspond à aucun fichier map\n");
		
	}
	freeListComplete(lstMaps);
	
/*-------------- GESTION DU MENU --------------------*/
do{

	interface.lstButtons = NULL;

	/* chargement des polices */
	int playIsPush = 0;
	int menuOpen = 0;
	int aideOpen = 0;
	initMenuGraphics();


	/* ouverture du répertoire data */

	while(!play && askedForQuit == false) {
		/* Récupération du temps au début de la boucle */
		Uint32 startTime = SDL_GetTicks();

		/* Placer ici le code de dessin du menu */		
		drawMenu(&menuOpen,&aideOpen,&playIsPush,mapName);

		/* Echange du front et du back buffer : mise à jour de la fenêtre */
		SDL_GL_SwapBuffers();

		/* Renvoie une chaine de caractère contenant le nom
		du fichier ITD choisi par l'utilisateur ou NULL si rien n'a encore été choisi */
		askedForQuit = handleMenuActions(&mapName,&playIsPush, &menuOpen,&aideOpen);

		if(playIsPush == 2) play = true;
		
		/* Calcul du temps écoulé */
		Uint32 elapsedTime = SDL_GetTicks() - startTime;
		/* Si trop peu de temps s'est écoulé, on met en pause le programme */
		if(elapsedTime < FRAMERATE_MILLISECONDS) {
			SDL_Delay(FRAMERATE_MILLISECONDS - elapsedTime);
		}

	}
	

/*-------------- GESTION DU JEU --------------------*/
	bool gameFinished = false;
	//Surtout à appeler APRES avoir initialisé la SDL
	char mapPath[50] = "data/";
	
	
	float width = .15;//10% de largeur
	float height = 1.; //Toute la hauteur
	float positionX = 0.85; //A 90% de la largeur
	float positionY = .0; //A 100% de la hauter
	
	if(!askedForQuit){
		strcat(mapPath, mapName);
		world = initWorld(mapPath);
		initGameGraphics();
		GAME_TEXTURES_ID.MAP_ID = makeTextureFromSurface(world.map.image);

		//Initialisation interface
		interface = initGameInterface(width, height, positionX, positionY);
	
		startWorld(&world);
	}
	while(!gameFinished && !askedForQuit) {
		/* Récupération du temps au début de la boucle */
		Uint32 startTime = SDL_GetTicks();
		
		/* On tente un nouveau cycle de tours de jeu si besoin. Le temps est 
		 géré par la fonction. La plupart du temps plusieurs tours de jeu sont
		 joués d'affilé. */
		worldNewStep(&world);
		

		drawWorld(&world);
		drawInterface(&interface, &world);
		/* Calcul du temps écoulé, si temps < 10 ms, on ne passe pas 
		au tour suivant.
		 */
		Uint32 elapsedTime = SDL_GetTicks() - startTime;
		/* Si trop peu de temps s'est écoulé, on ne dessine rien. */
		if(elapsedTime < FRAMERATE_MILLISECONDS) {

			 /* Echange du front et du back buffer : mise à jour de la fenêtre */
			SDL_GL_SwapBuffers();
      			SDL_Delay(FRAMERATE_MILLISECONDS - elapsedTime);
    			
		}
		
		/* Boucle traitant les evenements */
		askedForQuit = handleGameActions(&world, &interface, &gameFinished);
	}
	play = false;
	mapName = NULL;
	
	cleanWorld(&world);
	cleanInterface(&interface);
	
}while(! askedForQuit);
	/* Liberation des ressources */ 
	cleanExit(&world, &interface);

	return EXIT_SUCCESS;
}
Esempio n. 5
0
int main()
{
	/* Create GL Window */
	if (!initWindow())
		return -1;

	/* Initialise vertex buffers for cube */
	CubeMap cubeMap;
	cubeMap.loadCubeMap("../textures/cubemaps/Yokohama/");


	/* Load shaders needed */

	Entity* box = new Entity(glm::vec3(0));
	box->setShader(ShaderManager::loadShader("simpleReflect"));
	box->loadFromFile("../models/Cube.3ds");
	rigidBodies.push_back(new RigidBody(box));

	box = new Entity(glm::vec3(0,2,0));
	box->setShader(ShaderManager::loadShader("simpleReflect"));
	box->loadFromFile("../models/Cube.3ds");
	rigidBodies.push_back(new RigidBody(box));

	std::cout << "some amazing feature has been added";


	glEnable(GL_DEPTH_TEST);
	while (!glfwWindowShouldClose(window))
	{
		/* Rendering Code */

		// Calculate deltatime of current frame
       GLfloat currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

		
        // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions
        glfwPollEvents();
       do_movement();
		//do_rotation();

		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);



		glm::mat4 viewMatrix = glm::lookAt (
		cameraPos,  //where you are
		cameraPos + cameraFront, // what you are looking at, however we move, the camera keeps looking at the target direction
		cameraUp 
		);

	

		glm::mat4 projectionMatrix = glm::perspective(
		fov,
		(GLfloat)WIDTH/(GLfloat)HEIGHT,
		0.1f,
		1000.0f
		);


		for(int i =0; i < rigidBodies.size(); i++)
		{
			//for(int j = 0; j < rigidBodies.size(); j++)
			//{
			//	if (i ==j)
			//		continue;

			//	//if(rigidBodies[i]->aabb->collies(rigidBodies[j]->aabb))
			//		//do something with shaders to indicate collision in broadphase
			//}


			rigidBodies[i]->Update(deltaTime);
		
			rigidBodies[i]->entity->getShader()->setUniformMatrix4fv("projectionMat", projectionMatrix);
			//cubeMap.getShader()->setUniformMatrix4fv("projectionMat", projectionMatrix);
			rigidBodies[i]->entity->getShader()->setUniformMatrix4fv("viewMat", viewMatrix);
			//cubeMap.getShader()->setUniformMatrix4fv("viewMat", viewMatrix);
			//dragonModel.getShader()->setUniformMatrix4fv("viewMat", view_mat);
			rigidBodies[i]->entity->getShader()->setUniformVector4fv("camPos", glm::vec4(cameraPos, 1.0f));
			//glm:: vec3 cam_pos= glm::vec3 (cam_pos);
			//dragonModel.getShader()->setUniformVector4fv("camPos", glm::vec4(cam_pos, 1.0f));

			//rigidBodies[i]->entity->getShader()->setUniformVector4fv("modelMat", rigidBodies[i]->entity->getModelMat());
		
			rigidBodies[i]->entity->draw();

			//rigidBodies[i]->ApplyGravity();
		}
		
		glDisable(GL_TEXTURE_GEN_S);
		glDisable(GL_TEXTURE_GEN_T);
		glDisable(GL_TEXTURE_GEN_R);

		
		//cubeMap.drawSkyBox();

		glEnable(GL_TEXTURE_GEN_S);
		glEnable(GL_TEXTURE_GEN_T);
		glEnable(GL_TEXTURE_GEN_R);

		glfwSwapBuffers(window);
		glfwPollEvents();

		

}
	glfwTerminate();
	return 0;

}
Esempio n. 6
0
GLWindow::GLWindow(int argc, char *argv[]){
	initVars();
	initWindow(argc, argv);
}
Esempio n. 7
0
	void UiComponent::update(float seconds) {
		if (!initialized) {
			initWindow();
			initialized = true;
		}
	}
Esempio n. 8
0
	bool WGLWindow::initWindow()
	{
		DWORD dwStyle = WS_OVERLAPPEDWINDOW;
		DWORD dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;

		// Adjust window to true requested size
		RECT windowRect;
		windowRect.left = pLeft;
		windowRect.right = (long)pWidth;
		windowRect.top = pTop;
		windowRect.bottom = (long)pHeight;
		::AdjustWindowRectEx(&windowRect, dwStyle, false, dwExStyle);

		// Create the window
		if (!(pHWnd = ::CreateWindowEx(
			dwExStyle, L"OpenGL", WString{pTitle}.c_str(),
			dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
			pLeft, pTop, // Position
			windowRect.right - windowRect.left, windowRect.bottom - windowRect.top, // Dimensions
			nullptr, nullptr, pHInstance, nullptr)))
		{
			std::cerr << "Window init error : Window creation failed !" << std::endl;
			std::cerr << "Error : \"" << GetLastError() << "\"" << std::endl;
			kill();
			return false;
		}

		RegisterWindow(pHWnd, this);


		// Get the Device Context
		if (!(pHDC = ::GetDC(pHWnd)))
		{
			std::cerr << "Window init error : Can't create a Device Context !" << std::endl;
			kill();
			return false;
		}

		const ::PIXELFORMATDESCRIPTOR pfd =
			{
				// Size
				(WORD)sizeof (::PIXELFORMATDESCRIPTOR),
				// Version
				1,
				// Flags
				PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_GENERIC_ACCELERATED,
				// Pixel Type
				PFD_TYPE_RGBA,
				// Color depth
				(BYTE)pBitDepth,
				// Color bits ignored
				0, 0, 0, 0, 0, 0,
				// No alpha buffer
				0,
				// Shift bit ignored
				0,
				// No accumulation buffer
				0,
				// Accumulation bits ignored
				0, 0, 0, 0,
				// 24-bit Z-buffer (Depth Buffer)
				24,
				// 8-bit stencil buffer
				8,
				// No auxiliary buffer
				0,
				// Main drawing layer
				PFD_MAIN_PLANE,
				// Reserved
				0,
				// Layer masks ignored
				0, 0, 0
			};

		// Try MSAA init
		if (pHasMSAASupport && pMultiSampling != MultiSampling::msNone)
		{
			if (!initMultisamplePixelFormat(pfd, true))
			{
				// If MSAA init failed, set the requested multisampling to none
				pMultiSampling = MultiSampling::msNone;
				initDefaultPixelFormat(pfd); // Should work, since it worked once before
			}
		}
		else
		{
			// Dummy format to create a GL context
			if (!initDefaultPixelFormat(pfd))
			{
				std::cerr << "Window init error : Can't set pixel format !" << std::endl;
				kill();
				return false;
			}
		}

		// Create a Rendering Context if necessary
		if (!(pHRC = ::wglCreateContext(pHDC)))
		{
			std::cerr << "Window init error : Can't create a GL rendering context !" << std::endl;
			kill();
			return false;
		}

		// Activate the Rendering Context
		if (!::wglMakeCurrent(pHDC, pHRC))
		{
			std::cerr << "Window init error : Can't activate the GL rendering context !" << std::endl;
			kill();
			return false;
		}

		// Initialize our newly created GL window
		if (!GLWindow::initialize())
		{
			std::cerr << "OpenGL Initialization Failed !" << std::endl;
			kill();
			return false;
		}

		if (!pHasMSAASupport && pMultiSampling != MultiSampling::msNone &&
			initMultisamplePixelFormat(pfd, false))
		{
			pHasMSAASupport = true;
			closeWindowForReinit();
			::wglDeleteContext(pHRC);
			initWindow();
		}

		// On success, enable multisampling
		if (pHasMSAASupport && pMultiSampling != MultiSampling::msNone)
			::glEnable(GL_MULTISAMPLE);
		else
			::glDisable(GL_MULTISAMPLE);

		// Show the window
		::ShowWindow(pHWnd,SW_SHOW);
		// Slightly higher priority
		::SetForegroundWindow(pHWnd);
		// Sets keyboard focus to the window
		::SetFocus(pHWnd);

		// Set up our perspective GL screen
		internalResize(pWidth, pHeight);

		TRACKMOUSEEVENT tme;
		tme.cbSize = (DWORD)sizeof(TRACKMOUSEEVENT);
		tme.dwFlags = TME_LEAVE | TME_HOVER;
		tme.hwndTrack = pHWnd;
		tme.dwHoverTime = HOVER_DEFAULT;
		::TrackMouseEvent(&tme);

		if (pFullScreen)
		{
			if (!enableFullScreen())
				pFullScreen = false;
		}

		return true;
	}
Esempio n. 9
0
bool		graphic::handleEvent()
{
	if (_first == true)
		initWindow();
	cleaner();
	if (!_window->isOpen())
		return false;

	std::map<int, Object*>::iterator it = _entity.find(_idPlayer);
	while (_window->pollEvent(_event))
	{
		eDirection 				_oldX = _stateX;
		eDirection 				_oldY = _stateY;

		if ((_event.type == sf::Event::Closed) || ((_event.type == sf::Event::KeyPressed) &&
				(_event.key.code == sf::Keyboard::Escape)))
			_window->close();

		if (_idPlayer != -1 && it != _entity.end())
		{
			if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space))
			{
				if (!_loading)
				{
					_cli->sendToNetwork(8, "");
					_loading = true;
				}
				_charge += 1;
			}
			if (_event.type == sf::Event::KeyReleased && _event.key.code == sf::Keyboard::Space)
			{
				_cli->sendToNetwork(9, "");
				_loading = false;
				_charge = 0;
			}
			if (sf::Keyboard::isKeyPressed(sf::Keyboard::Z))
				_stateY = UP;
			else if (sf::Keyboard::isKeyPressed(sf::Keyboard::S))
				_stateY = DOWN;
			else
				_stateY = STOPY;

			if (sf::Keyboard::isKeyPressed(sf::Keyboard::Q))
				_stateX = LEFT;
			else if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
				_stateX = RIGHT;
			else
				_stateX = STOPX;

			if (_stateX != _oldX)
				_cli->sendToNetwork(7, _cli->itos(_stateX));
			if (_stateY != _oldY)
				_cli->sendToNetwork(7, _cli->itos(_stateY));
		}
	}
	if (_idPlayer != -1 && it != _entity.end())
	{
		if (_charge > 0)
			dynamic_cast<Player*>(_entity[_idPlayer])->activeShoot();
		if (_charge == 0)
			dynamic_cast<Player*>(_entity[_idPlayer])->disableShoot();
	}
	for (std::map<int, Object *>::iterator i = _entity.begin(); i != _entity.end(); i++)
		(*i).second->update();
	for (std::vector<Object *>::iterator i = _shoots.begin(); i != _shoots.end(); i++)
		(*i)->update();
	for (std::vector<Explode *>::iterator y = _explode.begin(); y != _explode.end(); y++)
		(*y)->update();
	_background->update();
	_hud->update(_score, _life, _charge);
	return true;
}
Esempio n. 10
0
int main(int argc, char **argv)
{
	int stepTime;	//两次调用之间的时间差			
	if(initWindow(1280,720,"Xiajia") == NULL)
	{//建立窗体
		printf("Window init error!\n");
		return 0;
	}
	//_XLogbook::GetInstance().initLog("Log.txt");
#if WITH_OBJECT_MANAGER
	_XObjectManager::GetInstance().init();
#endif
	//初始化字体
	_XFontUnicode FontUnicode;
	FontUnicode.init("pic/Font/FontUnicode30_T000.png",_XVector2I(30,30),_XVector2I(34,34),4);
#if WITH_OBJECT_MANAGER
	_XObjectManager::GetInstance().decreaseAObject(&FontUnicode);
#endif
	//初始化按钮
	_XButtonTexture ButtonTexture;
	ButtonTexture.init("pic/Button/B_00.png","pic/Button/B_01.png","pic/Button/B_02.png","pic/Button/B_03.png");
	Button.init(_XVector2(0.0f,30.0f),_XRect(10.0f,7.0f,119.0f,58.0f),ButtonTexture,"xiajia",FontUnicode,0.5f,_XVector2(64.0f,32.0f));
	Button.setCallbackFun(NULL,NULL,cbMouseOn,cbMouseDown,cbMouseUp,NULL);
	Button.setSize(1.0f,1.0f);
	Button.setCaptionText("你好啊");
	Button.setHotKey(SDLK_0);

	ButtonCopy.setACopy(Button);
	ButtonCopy.setPosition(0.0f,100.0f);
	ButtonCopy.setCaptionText("你好个屁");
	ButtonCopy.disable();
	_XButtonTexture ButtonTextureEx;
	ButtonTextureEx.init("pic/ButtonEx/B_00.png","pic/ButtonEx/B_01.png","pic/ButtonEx/B_02.png","pic/ButtonEx/B_03.png");
	_XVector2 ButtonExArea[6];
	ButtonExArea[0].set(38.0f,20.0f);
	ButtonExArea[1].set(13.0f,64.0f);
	ButtonExArea[2].set(38.0f,109.0f);
	ButtonExArea[3].set(91.0f,109.0f);
	ButtonExArea[4].set(116.0f,64.0f);
	ButtonExArea[5].set(91.0f,20.0f);
	ButtonEx.init(_XVector2(150.0f,30.0f),ButtonExArea,6,ButtonTextureEx,"静",1.0f,_XVector2(64.0f,64.0f),FontUnicode);
	ButtonExCopy.setACopy(ButtonEx);
	ButtonExCopy.setPosition(280.0f,30.0f);
	ButtonExCopy.setCaptionText("忍");
	//初始化复选框
	_XCheckTexture CheckTexture;
	CheckTexture.init("pic/Check/C_00.png","pic/Check/C_01.png","pic/Check/CD_00.png","pic/Check/CD_01.png");
	Check.init(_XVector2(0.0f,160.0f),_XRect(18.0f,19.0f,42.0f,43.0f),CheckTexture,"复选框",FontUnicode,1.0f,_XVector2(45.0f,32.0f));
	CheckCopy.setACopy(Check);
	CheckCopy.setPosition(150.0f,160.0f);
	CheckCopy.setText("复选个蛋");
	CheckCopy.setSize(0.5f,0.5f);
	//初始化右键菜单
	_XMouseRightButtonMenuTexture MouseRightButtonMenuTexture;
	MouseRightButtonMenuTexture.init("pic/RightButtonMenu/00.png","pic/RightButtonMenu/01.png","pic/RightButtonMenu/02.png","pic/RightButtonMenu/03.png");
	MouseRightButtonMenu.init(4,_XVector2(0.0f,0.0f),_XRect(8.0f,2.0f,252.0f,49.0f),MouseRightButtonMenuTexture,FontUnicode,1.0,_XVector2(133.0f,25.0f));
	MouseRightButtonMenu.setText("剪切(T)",0);
	MouseRightButtonMenu.setText("复制(C)",1);
	MouseRightButtonMenu.setText("粘贴(V)",2);
	MouseRightButtonMenu.setText("撤销(S)",3);
	MouseRightButtonMenu.setHotKey(SDLK_t,0);
	MouseRightButtonMenu.setHotKey(SDLK_c,1);
	MouseRightButtonMenu.setHotKey(SDLK_v,2);
	MouseRightButtonMenu.setHotKey(SDLK_s,3);
	//MouseRightButtonMenu.setCallbackFun(NULL,NULL);
	MouseRightButtonMenu.setSize(0.5f,0.5f);
	_XControlManager::GetInstance().decreaseAObject(&MouseRightButtonMenu);
#if WITH_OBJECT_MANAGER
	_XObjectManager::GetInstance().decreaseAObject(&MouseRightButtonMenu);
#endif
	//初始化输入框
	_XEditTexture EditTexture;
	EditTexture.init("pic/Edit/E_back.png","pic/Edit/E_disable.png","pic/Edit/E_Select.png","pic/Edit/E_Insert.png","pic/Edit/E_upon.png");
	FontUnicode.setAlignmentModeX(_FONT_ALIGNMENT_MODE_X_LEFT); //设置字体左对齐
	FontUnicode.setColor(0.0f,0.0f,0.0f,1.0f);
	Edit.init(_XVector2(400.0f,50.0f),_XRect(12.0f,2.0f,509.0f,38.0f),EditTexture,"Test",FontUnicode,1.0f,&MouseRightButtonMenu);
	//Edit.disable();
	//Edit.setCallbackFun(NULL,eInputOver,&Edit);
	Edit.setString("This is a test for setString().");
	EditCopy.setACopy(Edit);
	EditCopy.setPosition(400.0f,100.0f);
	EditCopy.setSize(0.5f,0.5f);
	EditCopy.setTextColor(_XFColor(1.0f,1.0f,1.0f,1.0f));
	//初始化滑动条
	_XSliderTexture SliderTexture;
	//垂直滑动条
	//SliderTexture.init("pic/Slider/BLH_00.png","pic/Slider/BLH_01.png","pic/Slider/BLH_02.png","pic/Slider/BLH_03.png",
	//"pic/Slider/BH_00.png","pic/Slider/BH_01.png","pic/Slider/BH_02.png","pic/Slider/BH_03.png");
	//Slider.init(_XVector2(50.0f,250.0f),_XRect(6.0f,11.0f,32.0f,506.0f),_XRect(5.0f,4.0f,27.0f,26.0f),SliderTexture,_XSLIDER_TYPE_VERTICAL,100.0f,0.0f);
	//水平滑动条
	SliderTexture.init("pic/Slider/BL_00.png","pic/Slider/BL_01.png","pic/Slider/BL_02.png","pic/Slider/BL_03.png",
	"pic/Slider/B_00.png","pic/Slider/B_01.png","pic/Slider/B_02.png","pic/Slider/B_03.png");
	Slider.init(_XVector2(0.0f,250.0f),_XRect(11.0f,0.0f,506.0f,26.0f),_XRect(4.0f,5.0f,27.0f,26.0f),SliderTexture,_XSLIDER_TYPE_HORIZONTAL,100.0f,0.0f);
	Slider.setCallbackFun(NULL,NULL,NULL,NULL,NULL,sliderChange,NULL,&Slider);
	Slider.setNowValue(55.0f);

	SliderCopy.setACopy(Slider);
	SliderCopy.setPosition(0.0f,300.0f);
	SliderCopy.setSize(0.5f,0.5f);
	//下面是单选框
	Radios.init(5,_XVector2(0.0f,35.0f),_XVector2(00.0f,350.0f),_XRect(18.0f,19.0f,42.0f,43.0f),&CheckTexture,FontUnicode,1.0f,_XVector2(45.0f,32.0f));
	Radios.setRadioText("我真的很蛋疼",0);
	Radios.setRadioText("我蛋疼而且要爆了",1);
	Radios.setRadioText("我要爆了",2);
	Radios.setRadioText("我已经爆了",3);
	Radios.setRadioText("I have a boom!",4);
	Radios.setChoosed(3);

	RadiosCopy.setACopy(Radios);
	RadiosCopy.setPosition(300.0f,350.0f);
	RadiosCopy.setRadioSum(8);
	RadiosCopy.setSize(0.5f,0.5f);
	RadiosCopy.setRadioText("蛋完美了",0);
	RadiosCopy.setRadioText("蛋好了",1);
	RadiosCopy.setRadioText("蛋开始好了",2);
	RadiosCopy.setRadioText("蛋没变化",3);
	RadiosCopy.setRadioText("蛋变坏了",4);
	RadiosCopy.setRadioText("蛋变胀痛",5);
	RadiosCopy.setRadioText("蛋要爆了",6);
	RadiosCopy.setRadioText("蛋已经爆了",7);
	//下面是进度条
	_XNumber Number;
	Number.init("pic/Number.png",_XVector2I(15,30),_XVector2I(8,2));
#if WITH_OBJECT_MANAGER
	_XObjectManager::GetInstance().decreaseAObject(&Number);
#endif
	_XProgressTexture ProgressTexture;
	ProgressTexture.init("pic/Progress/PB_00.png","pic/Progress/PM_00.png","pic/Progress/PU_00.png");
	Progress.init(_XVector2(0.0f,550.0f),_XRect(2.0f,0.0f,509.0f,30.0f),ProgressTexture,&Number,1.0f,_XVector2(256.0f,3.0f));
	Progress.setValue(25.0f);

	ProgressCopy.setACopy(Progress);
	ProgressCopy.setPosition(0.0f,600.0f);
	ProgressCopy.setSize(0.5f,0.5f);
	ProgressCopy.setColor(_XFColor(1.0f,1.0f,1.0f,0.5f));
	//下面是多行文本显示
	_XSliderTexture SliderTextureH;
	SliderTextureH.init("pic/MutiText/SliderH/BL_00.png","pic/MutiText/SliderH/BL_01.png","pic/MutiText/SliderH/BL_02.png","pic/MutiText/SliderH/BL_03.png",
		"pic/MutiText/SliderH/B_00.png","pic/MutiText/SliderH/B_01.png","pic/MutiText/SliderH/B_02.png","pic/MutiText/SliderH/B_03.png");
	_XSlider SliderH;
	SliderH.init(_XVector2(200.0f,200.0f),_XRect(0.0f,0.0f,512.0f - 40.0f,32.0f),_XRect(0.0f,0.0f,32.0f,32.0f),SliderTextureH,_XSLIDER_TYPE_HORIZONTAL,100.0f,0.0f);
	_XControlManager::GetInstance().decreaseAObject(&SliderH);
#if WITH_OBJECT_MANAGER
	_XObjectManager::GetInstance().decreaseAObject(&SliderH);
#endif
	_XSliderTexture SliderTextureV;
	SliderTextureV.init("pic/MutiText/SliderV/BLH_00.png","pic/MutiText/SliderV/BLH_01.png","pic/MutiText/SliderV/BLH_02.png","pic/MutiText/SliderV/BLH_03.png",
		"pic/MutiText/SliderV/BH_00.png","pic/MutiText/SliderV/BH_01.png","pic/MutiText/SliderV/BH_02.png","pic/MutiText/SliderV/BH_03.png");
	_XSlider SliderV;
	SliderV.init(_XVector2(200.0f,200.0f),_XRect(0.0f,0.0f,32.0f,512.0f - 40.0f),_XRect(0.0f,0.0f,32.0f,32.0f),SliderTextureV,_XSLIDER_TYPE_VERTICAL,100.0f,0.0f);
	_XControlManager::GetInstance().decreaseAObject(&SliderV);
#if WITH_OBJECT_MANAGER
	_XObjectManager::GetInstance().decreaseAObject(&SliderV);
#endif
	char tempTest[] = "0 :jiashenghua\n1 :123456789012345678901234567890123456789\n2 :PI = 3.141592653589793\n3 :\n\n5 :don`t use Chinese\n6 :It is not supply for Chinese at now!\n7 :\n8 :\n9 :\n10:\n11:\n12:\n13:\n14:\n15:\n16:";
	_XMultiTextTexture MutiTextTexture;
	MutiTextTexture.init("pic/MutiText/E_back.png","pic/MutiText/E_disable.png","pic/MutiText/E_Select.png","pic/MutiText/E_Insert.png","pic/MutiText/E_up.png");
	MutiText.init(_XVector2(520.0f,150.0f),_XRect(4.0f,4.0f,508.0f,508.0f),MutiTextTexture,tempTest,FontUnicode,1.0f/*,MouseRightButtonMenu*/,SliderV,SliderH);
	MutiText.setSize(0.5f,0.5f);

	MutiTextCopy.setACopy(MutiText);
	MutiTextCopy.setSize(0.5f,0.5f);
	MutiTextCopy.setPosition(790.0f,150.0f);
	MutiTextCopy.setTextColor(_XFColor(1.0f,1.0f,1.0f,1.0f));
	MutiTextCopy.disActive();
	MutiTextCopy.disVisiable();
	//多列列表框
	_XSliderTexture SliderTextureHX;
	SliderTextureHX.init("pic/MutiList/SliderH/BL_00.png","pic/MutiList/SliderH/BL_01.png","pic/MutiList/SliderH/BL_02.png","pic/MutiList/SliderH/BL_03.png",
		"pic/MutiList/SliderH/B_00.png","pic/MutiList/SliderH/B_01.png","pic/MutiList/SliderH/B_02.png","pic/MutiList/SliderH/B_03.png");
	_XSlider SliderHX;
	SliderHX.init(_XVector2(200.0f,200.0f),_XRect(0.0f,0.0f,512.0f - 40.0f,32.0f),_XRect(0.0f,0.0f,32.0f,32.0f),SliderTextureHX,_XSLIDER_TYPE_HORIZONTAL,100.0f,0.0f);
	_XControlManager::GetInstance().decreaseAObject(&SliderHX);
#if WITH_OBJECT_MANAGER
	_XObjectManager::GetInstance().decreaseAObject(&SliderHX);
#endif
	_XSliderTexture SliderTextureVX;
	SliderTextureVX.init("pic/MutiList/SliderV/BLH_00.png","pic/MutiList/SliderV/BLH_01.png","pic/MutiList/SliderV/BLH_02.png","pic/MutiList/SliderV/BLH_03.png",
		"pic/MutiList/SliderV/BH_00.png","pic/MutiList/SliderV/BH_01.png","pic/MutiList/SliderV/BH_02.png","pic/MutiList/SliderV/BH_03.png");
	_XSlider SliderVX;
	SliderVX.init(_XVector2(200.0f,200.0f),_XRect(0.0f,0.0f,32.0f,512.0f - 40.0f),_XRect(0.0f,0.0f,32.0f,32.0f),SliderTextureVX,_XSLIDER_TYPE_VERTICAL,100.0f,0.0f);
	_XControlManager::GetInstance().decreaseAObject(&SliderVX);
#if WITH_OBJECT_MANAGER
	_XObjectManager::GetInstance().decreaseAObject(&SliderVX);
#endif
	_XMultiListTexture MutiListTexture;
	MutiListTexture.init("pic/MutiList/E_back.png","pic/MutiList/E_disable.png","pic/MutiList/E_Select.png","pic/MutiList/E_move.png","pic/MutiList/E_Title.png","pic/MutiList/E_TitleEnd.png");
	MutiList.init(_XVector2(610.0f,450.0f),_XRect(4.0f,4.0f,508.0f,508.0f),MutiListTexture,FontUnicode,1.0f,3,24/*,MouseRightButtonMenu*/,SliderVX,SliderHX);
	char tempChar[] = "Boxxx"; 
	for(int i = 0;i < 24;++ i)
	{
		for(int j = 0; j < 3;++ j)
		{
			tempChar[3] = (i * 4 + j) /10 + '0';
			tempChar[4] = (i * 4 + j) %10 + '0';
			MutiList.setBoxStr(tempChar,i,j);
		}
	}
	MutiList.setTileStr("贾Title00",0);
	MutiList.setRowWidth(100,0);
	MutiList.setTileStr("Title胜",1);
	MutiList.setRowWidth(120,1);
	MutiList.setTileStr("Title02华",2);
	MutiList.setRowWidth(150,2);
	MutiList.exportData();
	//MutiList.importData();
	MutiList.setPosition(610,450);
	MutiList.setSize(0.5,0.5);
	//初始化下拉菜单
	_XComboTexture ComboTexture;
	ComboTexture.init("pic/Combo/C_back.png","pic/Combo/C_disable.png",
		"pic/Combo/RightButton/C_rightButtomEnable.png","pic/Combo/RightButton/C_rightButtomOn.png",
		"pic/Combo/RightButton/C_rightButtomDown.png","pic/Combo/RightButton/C_rightButtomDisable.png",

		"pic/Combo/MenuUpButton/C_downMenuUpEnable.png","pic/Combo/MenuUpButton/C_downMenuUpOn.png",
		"pic/Combo/MenuUpButton/C_downMenuUpDown.png","pic/Combo/MenuUpButton/C_downMenuUpDisable.png",

		"pic/Combo/MenuButton/C_downMenuEnable.png","pic/Combo/MenuButton/C_downMenuOn.png",
		"pic/Combo/MenuButton/C_downMenuDown.png","pic/Combo/MenuButton/C_downMenuDisable.png",

		"pic/Combo/MenuDownButton/C_downMenuDownEnable.png","pic/Combo/MenuDownButton/C_downMenuDownOn.png",
		"pic/Combo/MenuDownButton/C_downMenuDownDown.png","pic/Combo/MenuDownButton/C_downMenuDownDisable.png");
	Combo.init(ComboTexture,_XVector2(250.0f,190.0f),_XRect(8.0f,1.0f,217.0f,43.0f),_XRect(6.0f,1.0f,48.0f,43.0f),_XRect(8.0f,1.0f,261.0f,23.0f),
		_XRect(8.0f,1.0f,261.0f,39.0f),_XRect(8.0f,1.0f,261.0f,23.0f),10,5,FontUnicode,1.0f);
	Combo.setMenuStr("This input is long",0);
	Combo.setMenuStr("蛋疼!",1);
	Combo.setMenuStr("蛋巨疼!",2);
	Combo.setMenuStr("蛋碎了!",3);
	Combo.setMenuStr("蛋爆了!",4);

	ComboCopy.setACopy(Combo);
	ComboCopy.setPosition(250.0f,160.0f);
	ComboCopy.setSize(_XVector2(0.5,0.5));
	printf("Now ctrl sum:%d\n",_XControlManager::GetInstance().getObjSum());
#if WITH_OBJECT_MANAGER
	printf("Now obj sum:%d\n",_XObjectManager::GetInstance().getNowObjectSum());
#endif
	int frameOrder = 0;

	while(!SDL_event()) 
	{
		stepTime = getFrameTiming();
		//_XLogbook::GetInstance().addLogInfoNull("NO %d Frame Time:%d\n",frameOrder,interval);
		
		engineMove(stepTime);	//引擎的更新内容
		clearScreen();			//清除屏幕

		updateScreen();			//更新屏幕的内容
		++ frameOrder;
		SDL_Delay(1);
	}
	//_XLogbook::GetInstance().releaseLog();
	releaseSDL();
	return 0;	
}
Esempio n. 11
0
void GUI::Window::setScene(Scene *scene){

	currentScene = scene;

	initWindow();
}
 void run() {
     initWindow();
     initVulkan();
     mainLoop();
 }
Esempio n. 13
0
int main()
{
	GLsizei multiSamples = 8;

	GLFWwindow* window = initWindow();
	if (window == nullptr)
	{
		std::cout << "Unable to initialize window." << std::endl;
		return -1;
	}

	// Start the timer
	GLfloat deltaTime, lastFrame, currentFrame;
	lastFrame = 0.0f;
	currentFrame = 0.0f;

	// Setup the viewport;
	GLfloat screenWidth = 800, screenHeight = 600;
	glViewport(0, 0, screenWidth, screenHeight);

	// Setup Camera
	Camera cam = initCamera();
	glfwSetWindowUserPointer(window, &cam);

	// Load Models
	Model planet = Model("./Models/planet/planet.obj");
	Model asteroid = Model("./Models/rock/rock.obj");

	// Load and Compile Shaders
	GLuint program = compileShaders("../OpenGL3-3/shaders/advanced/instance/basic.vert.glsl", "../OpenGL3-3/shaders/advanced/instance/basic.frag.glsl");
	GLuint modelShader = compileShaders("../OpenGL3-3/shaders/newModel/model.vert.glsl", "../OpenGL3-3/shaders/newModel/model.frag.glsl");
	GLuint instancedModelShader = compileShaders("../OpenGL3-3/shaders/newModel/imodel.vert.glsl", "../OpenGL3-3/shaders/newModel/model.frag.glsl");
	GLuint frameBufferShader = compileShaders("../OpenGL3-3/shaders/advanced/fbo.vert.glsl", "../OpenGL3-3/shaders/advanced/fbo.frag.glsl");

	// Setup MVP model
	glm::mat4 model, view, proj;
	view = cam.GetViewMatrix();
	proj = glm::perspective(glm::radians(45.0f), (float)screenWidth / (float)screenHeight, 0.1f, 1000.0f);

#pragma region quad

	GLfloat quadVertices[] = {
		// Positions     // Colors
		-0.05f, 0.05f, 1.0f, 0.0f, 0.0f,
		0.05f, -0.05f, 0.0f, 1.0f, 0.0f,
		-0.05f, -0.05f, 0.0f, 0.0f, 1.0f,

		-0.05f, 0.05f, 1.0f, 0.0f, 0.0f,
		0.05f, -0.05f, 0.0f, 1.0f, 0.0f,
		0.05f, 0.05f, 0.0f, 1.0f, 1.0f
	};

	glm::vec2 translations[100];
	int index = 0;
	GLfloat offset = 0.1f;
	for (GLint y = -10; y < 10; y += 2)
	{
		for (GLint x = -10; x < 10; x += 2)
		{
			glm::vec2 translation;
			translation.x = (GLfloat)x / 10.0f + offset;
			translation.y = (GLfloat)y / 10.0f + offset;
			translations[index++] = translation;
		}
	}

	GLfloat fboQuad[] = 
	{
		-1.0f, 1.0f, 0.0f, 1.0f,
		-1.0f, -1.0f, 0.0f, 0.0f,
		1.0f, -1.0f, 1.0f, 0.0f,

		1.0f, -1.0f, 1.0f, 0.0f,
		1.0f, 1.0f, 1.0f, 1.0f,
		-1.0f, 1.0f, 0.0f, 1.0f
	};

#pragma endregion

	GLuint VBO, VAO, instanceVBO;
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	glGenBuffers(1, &instanceVBO);
	glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2) * 100, &translations[0], GL_STATIC_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, 0);

	// Create the Framebuffer
	GLuint FBO;
	glGenFramebuffers(1, &FBO);
	glBindFramebuffer(GL_FRAMEBUFFER, FBO);

	GLuint texture;
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, texture);

	glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, multiSamples, GL_RGB, screenWidth, screenHeight, GL_TRUE);// , GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, texture, 0);
	
	GLuint sampleRBO;

	glGenRenderbuffers(1, &sampleRBO);
	glBindRenderbuffer(GL_RENDERBUFFER, sampleRBO);
	glRenderbufferStorageMultisample(GL_RENDERBUFFER, multiSamples, GL_DEPTH24_STENCIL8, screenWidth, screenHeight);
	glBindRenderbuffer(GL_RENDERBUFFER, 0);

	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, sampleRBO);
	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		std::cout << "FRAMEBUFFER INCOMPLETE!" << std::endl;

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	GLuint regularFBO;
	glGenFramebuffers(1, &regularFBO);
	glBindFramebuffer(GL_FRAMEBUFFER, regularFBO);

	GLuint tex;
	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_2D, tex);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glBindTexture(GL_TEXTURE_2D, 0);

	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		std::cout << "FRAMEBUFFER 2 INCOMPLETE!" << std::endl;

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	GLuint fboVAO, fboVBO;
	glGenVertexArrays(1, &fboVAO);
	glGenBuffers(1, &fboVBO);
	glBindVertexArray(fboVAO);
	
	glBindBuffer(GL_ARRAY_BUFFER, fboVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(fboQuad), fboQuad, GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2*sizeof(GLfloat)));

	glBindVertexArray(0);

	glBindVertexArray(VAO);
	{
		glBindBuffer(GL_ARRAY_BUFFER, VBO);
		glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);
		glEnableVertexAttribArray(0);
		glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLvoid*)0);
		glEnableVertexAttribArray(1);
		glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLvoid*)(sizeof(GLfloat) * 2));
		glEnableVertexAttribArray(2);
		glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
		glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		glVertexAttribDivisor(2, 1);
	}
	glBindVertexArray(0);

	std::cout << sizeof(glm::mat4) << std::endl;

	const int amount = 100000;
	glm::mat4* modelMats;
	modelMats = new glm::mat4[amount];
	srand(glfwGetTime());
	GLfloat radius = 150.0f;
	offset = 25.0f;
	for (GLuint i = 0; i < amount; i++)
	{
		glm::mat4 model;
		GLfloat angle = (GLfloat)i / (GLfloat)amount * 360.0f;
		GLfloat displacement = (rand() % (GLint)(2 * offset)) / 100.0f - offset;
		GLfloat x = sin(angle) * radius + displacement;
		displacement = (rand() % (GLint)(2 * offset * 100)) / 100.0f - offset;
		GLfloat y = displacement * 0.4f;
		displacement = (rand() % (GLint)(2 * offset * 100)) / 100.0f - offset;
		GLfloat z = cos(angle) * radius + displacement;
		model = glm::translate(model, glm::vec3(x, y, z));
		GLfloat scale = (rand() % 20) / 100.0f + 0.05f;
		model = glm::scale(model, glm::vec3(scale));
		GLfloat rotAngle = (rand() % 360);
		model = glm::rotate(model, rotAngle, glm::vec3(0.4f, 0.6f, 0.8f));
		modelMats[i] = model;
	}


	for (GLuint i = 0; i < asteroid.meshes.size(); i++)
	{
		GLuint VAO = asteroid.meshes[i].VAO;
		GLuint buffer;
		glBindVertexArray(VAO);
		glGenBuffers(1, &buffer);
		glBindBuffer(GL_ARRAY_BUFFER, buffer);
		glBufferData(GL_ARRAY_BUFFER, amount * sizeof(glm::mat4), &modelMats[0], GL_STATIC_DRAW);
		GLsizei vec4Size = sizeof(glm::vec4);
		glEnableVertexAttribArray(3);
		glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)0);
		glEnableVertexAttribArray(4);
		glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(vec4Size));
		glEnableVertexAttribArray(5);
		glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(2 * vec4Size));
		glEnableVertexAttribArray(6);
		glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(3 * vec4Size));

		glVertexAttribDivisor(3, 1);
		glVertexAttribDivisor(4, 1);
		glVertexAttribDivisor(5, 1);
		glVertexAttribDivisor(6, 1);
		glBindVertexArray(0);
	}

	glUseProgram(modelShader);
	glUniformMatrix4fv(glGetUniformLocation(modelShader, "projection"), 1, GL_FALSE, glm::value_ptr(proj));
	glUseProgram(instancedModelShader);
	glUniformMatrix4fv(glGetUniformLocation(instancedModelShader, "projection"), 1, GL_FALSE, glm::value_ptr(proj));

	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	while (!glfwWindowShouldClose(window))
	{
		glfwPollEvents();
		currentFrame = glfwGetTime();
		deltaTime = currentFrame - lastFrame;
		lastFrame = currentFrame;
		glBindFramebuffer(GL_FRAMEBUFFER, FBO);
		glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glEnable(GL_DEPTH_TEST);
		handleMovement(window, deltaTime);

		glUseProgram(instancedModelShader);
		glUniformMatrix4fv(glGetUniformLocation(instancedModelShader, "view"), 1, GL_FALSE, glm::value_ptr(cam.GetViewMatrix()));
		glUseProgram(modelShader);
		glUniformMatrix4fv(glGetUniformLocation(modelShader, "view"), 1, GL_FALSE, glm::value_ptr(cam.GetViewMatrix()));


		glm::mat4 model;
		model = glm::translate(model, glm::vec3(0.0f, -5.0f, 0.0f));
		model = glm::scale(model, glm::vec3(4.0f));
		glUniformMatrix4fv(glGetUniformLocation(modelShader, "model"), 1, GL_FALSE, glm::value_ptr(model));
		planet.draw(modelShader);

		glUseProgram(instancedModelShader);
		glBindTexture(GL_TEXTURE_2D, asteroid.textures_loaded[0].id);
		for (GLuint i = 0; i < asteroid.meshes.size(); i++)
		{
			glBindVertexArray(asteroid.meshes[i].VAO);
			glDrawElementsInstanced(GL_TRIANGLES, asteroid.meshes[i].vertices.size(), GL_UNSIGNED_INT, 0, amount);
			glBindVertexArray(0);
		}
		glBindTexture(GL_TEXTURE_2D, 0);
		glBindFramebuffer(GL_READ_FRAMEBUFFER, FBO);
		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, regularFBO);
		glBlitFramebuffer(0, 0, screenWidth, screenHeight, 0, 0, screenWidth, screenHeight, GL_COLOR_BUFFER_BIT, GL_NEAREST);
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
		glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glDisable(GL_DEPTH_TEST);
		
		glUseProgram(frameBufferShader);
		glBindVertexArray(fboVAO);
		glBindTexture(GL_TEXTURE_2D, tex);
		//glUniform1i(glGetUniformLocation(frameBufferShader, "myTexture"), 0);
		glDrawArrays(GL_TRIANGLES, 0, 6);
		glBindVertexArray(0);
		glBindTexture(GL_TEXTURE_2D, 0);
		glfwSwapBuffers(window);

	}
	glfwTerminate();
	return 0;
}
Esempio n. 14
0
int main() {
  GLFWwindow * window = initWindow(windowWidth, windowHeight);
  if (!window) {
    glfwTerminate();
    return -1;
  }
  glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
  glfwSetKeyCallback(window, key_callback);
  glfwSetCursorPosCallback(window, cursor_callback);
  glfwSetScrollCallback(window, scroll_callback);
  glEnable(GL_DEPTH_TEST);

  // prepare an array of vertices
  GLfloat vertices[] = {
    // Positions          // normal vectors
    -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
     0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
     0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
     0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,

    -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
     0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
     0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
     0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
    -0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
    -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,

    -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
    -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
    -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
    -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
    -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
    -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,

     0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
     0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
     0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
     0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
     0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
     0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,

    -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
     0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
     0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
     0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
    -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
    -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,

    -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
     0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
     0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
     0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
    -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
    -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
};
  glm::vec3 cubePositions[] = {
    glm::vec3( 0.0f,  0.0f,  0.0f),
    glm::vec3( 2.0f,  5.0f, -15.0f),
    glm::vec3(-1.5f, -2.2f, -2.5f),
    glm::vec3(-3.8f, -2.0f, -12.3f),
    glm::vec3( 2.4f, -0.4f, -3.5f),
    glm::vec3(-1.7f,  3.0f, -7.5f),
    glm::vec3( 1.3f, -2.0f, -2.5f),
    glm::vec3( 1.5f,  2.0f, -2.5f),
    glm::vec3( 1.5f,  0.2f, -1.5f),
    glm::vec3(-1.3f,  1.0f, -1.5f)
  };

  GLuint lightVAO;
  glGenVertexArrays(1, &lightVAO);
  glBindVertexArray(lightVAO);

  GLuint lightVBO;
  glGenBuffers(1, &lightVBO);
  glBindBuffer(GL_ARRAY_BUFFER, lightVBO);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (void*)0);
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat),
                       (void*)(3 * sizeof(GLfloat)));
  glEnableVertexAttribArray(1);

  glBindVertexArray(0);

  Shader shaders("shader.vert", "shader.frag");
  Shader lightShaders("lightShader.vert", "lightShader.frag");

  double last_frame = glfwGetTime();
  while (!glfwWindowShouldClose(window)) {
    double current_frame = glfwGetTime();
    double delta_time = current_frame - last_frame;
    last_frame = current_frame;

    glfwPollEvents();

    do_movement(delta_time);

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    GLfloat light_pos_angle = glm::radians(60.0f * current_frame);
    glm::vec3 light_pos(1.2f + sin(light_pos_angle), 1.0f, 2.0f + cos(light_pos_angle));

    // draw common container
    shaders.Use();

    glm::mat4 view = camera.GetViewMatrix();
    glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom),
                                (GLfloat)windowWidth / (GLfloat)windowHeight,
                                0.01f, 1000.0f);
    shaders.SetUniform("view", view);
    shaders.SetUniform("projection", projection);
    shaders.SetUniform("objectColor", glm::vec3(1.0f, 0.5f, 0.31f));
    shaders.SetUniform("lightColor", glm::vec3(1.0f, 1.0f, 1.0f));
    shaders.SetUniform("lightPos", light_pos);

    glm::mat4 model = glm::translate(glm::mat4(), cubePositions[0]);
    model = glm::rotate(model, (GLfloat)glm::radians(60.0f * current_frame),
                        glm::vec3(1.0f, 1.0f, 1.0f));
    glm::mat3 normalMatrix = glm::mat3(view *glm::transpose(glm::inverse(model)));
    shaders.SetUniform("model", model);
    shaders.SetUniform("normalMatrix", normalMatrix);
    glBindVertexArray(lightVAO);
    glDrawArrays(GL_TRIANGLES, 0, 36);
    glBindVertexArray(0);

    // draw lamp
    lightShaders.Use();

    model = glm::scale(glm::translate(glm::mat4(), light_pos), glm::vec3(0.2f));

    lightShaders.SetUniform("view", view);
    lightShaders.SetUniform("projection", projection);
    lightShaders.SetUniform("model", model);

    glBindVertexArray(lightVAO);
    glDrawArrays(GL_TRIANGLES, 0, 36);
    glBindVertexArray(0);

    glfwSwapBuffers(window);
  }

  glfwTerminate();
  return 0;
}
Esempio n. 15
0
int APIENTRY WinMain(HINSTANCE inst, HINSTANCE junk, char *args, int junk2)
{
    char    **argv, *argp, *serviceArgs, *homeDir;
    int     argc, err, nextArg, installFlag;

    mpr = mprCreate(0, NULL, NULL);

    appInst = inst;
    serviceArgs = 0;
    err = 0;
    exiting = 0;
    installFlag = 0;
    homeDir = 0;
    heartBeatPeriod = HEART_BEAT_PERIOD;

    initService();

    mprSetAppName(mpr, BLD_PRODUCT "Angel", BLD_NAME "Angel", BLD_VERSION);
    appName = mprGetAppName(mpr);
    appTitle = mprGetAppTitle(mpr);

    mprSetLogHandler(mpr, logHandler, NULL);

    /*
     *  Create the window 
     */
    if (initWindow() < 0) {
        mprError(mpr, "Can't initialize application Window");
        return FALSE;
    }

    /*
     *  Parse command line arguments
     */
    if (mprMakeArgv(mpr, "", args, &argc, &argv) < 0) {
        return FALSE;
    }
    for (nextArg = 1; nextArg < argc; nextArg++) {
        argp = argv[nextArg];
        if (*argp != '-' || strcmp(argp, "--") == 0) {
            break;
        }

        if (strcmp(argp, "--args") == 0) {
            /*
             *  Args to pass to service when it starts
             */
            if (nextArg >= argc) {
                err++;
            } else {
                serviceArgs = argv[++nextArg];
            }

        } else if (strcmp(argp, "--console") == 0) {
            /*
             *  Allow the service to interact with the console
             */
            createConsole++;

        } else if (strcmp(argp, "--daemon") == 0) {
            /* Ignored on windows */

        } else if (strcmp(argp, "--heartBeat") == 0) {
            /*
             *  Set the heart beat period
             */
            if (nextArg >= argc) {
                err++;
            } else {
                heartBeatPeriod = atoi(argv[++nextArg]) * 1000;
            }

        } else if (strcmp(argp, "--home") == 0) {
            /*
             *  Change to this directory before starting the service
             */
            if (nextArg >= argc) {
                err++;
            } else {
                homeDir = argv[++nextArg];
            }

        } else if (strcmp(argp, "--program") == 0) {
            if (nextArg >= argc) {
                err++;
            } else {
                serviceProgram = argv[++nextArg];
            }

        } else if (strcmp(argp, "--install") == 0) {
            installFlag++;

        } else if (strcmp(argp, "--start") == 0) {
            /*
             *  Start the angel
             */
            if (startService() < 0) {
                return FALSE;
            }
            mprSleep(mpr, 2000);    /* Time for service to really start */

        } else if (strcmp(argp, "--stop") == 0) {
            /*
             *  Stop the  angel
             */
            if (removeService(0) < 0) {
                return FALSE;
            }

        } else if (strcmp(argp, "--uninstall") == 0) {
            /*
             *  Remove the  angel
             */
            if (removeService(1) < 0) {
                return FALSE;
            }

        } else if (strcmp(argp, "--verbose") == 0 || strcmp(argp, "-v") == 0) {
            verbose++;

        } else {
            err++;
        }

        if (err) {
            mprUserError(mpr, 
                "Bad command line: %s\n"
                "  Usage: %s [options] [program args]\n"
                "  Switches:\n"
                "    --args               # Args to pass to service\n"
                "    --console            # Display the service console\n"
                "    --heartBeat interval # Heart beat interval period (secs)\n"
                "    --home path          # Home directory for service\n"
                "    --install            # Install the service\n"
                "    --program            # Service program to start\n"
                "    --start              # Start the service\n"
                "    --stop               # Stop the service\n"
                "    --uninstall          # Uninstall the service",
                args, appName);
            return -1;
        }
    }

    if (installFlag) {
        /*
         *  Install the angel
         */
        if (installService(homeDir, serviceArgs) < 0) {
            return FALSE;
        }
    }

    if (argc <= 1) {
        /*
         *  This will block if we are a service and are being started by the
         *  service control manager. While blocked, the svcMain will be called
         *  which becomes the effective main program. 
         */
        startDispatcher(serviceMain);
    }
    return 0;
}
Esempio n. 16
0
int main() {
    std::string dataRoot;
#ifdef DATA_ROOT
    dataRoot = DATA_ROOT;
#else
    std::cerr << "No DATA_ROOT path found" << std::endl;
    return -1;
#endif

    GLFWwindow *window = nullptr;

    if (initWindow(window)) {
        return -1;
    }

    Shader shader(dataRoot + "/data/shaders/shader.vert", dataRoot + "/data/shaders/shader.frag");

    Texture textures(dataRoot + "/data/assets/textures.png");
    Texture normals(dataRoot + "/data/assets/normals.png");

    std::vector<GLfloat> vertices;
    std::vector<GLuint> indices;

    std::vector<Quad> quads;

    Map map(10, 10);
    for (int x = 0; x < map.getWidth(); ++x) {
        for (int y = 0; y < map.getHeight(); ++y) {
            if (map.isPassable(x, y)) {
                quads.push_back(Quad(glm::vec3(x, 0, -y), glm::vec3(0, 0, -1), glm::vec3(1, 0, 0), 0.5f, 0.0f));
                quads.push_back(Quad(glm::vec3(x, 1, -y), glm::vec3(1, 0, 0), glm::vec3(0, 0, -1), 0.0f, 0.5f));
            }
            for (int direction = 0; direction < 4; ++direction) {
                int cx = x + dx[direction];
                int cy = y + dy[direction];
                if (map.isPassable(x, y) && !map.isPassable(cx, cy)) {
                    quads.push_back(Quad(
                            glm::vec3(x, 0, -y) + WALL_SHIFT[direction],
                            glm::vec3(0, 1, 0),
                            WALL_DIRECTION[direction],
                            0.0f,
                            0.0f
                    ));
                }
            }
        }
    }

    for (int index = 0; index < quads.size(); ++index) {
        Quad quad = quads[index];
        quad.update(vertices);

        indices.push_back(GLuint(4 * index + 0));
        indices.push_back(GLuint(4 * index + 1));
        indices.push_back(GLuint(4 * index + 2));

        indices.push_back(GLuint(4 * index + 2));
        indices.push_back(GLuint(4 * index + 3));
        indices.push_back(GLuint(4 * index + 0));
    }

    GLuint VBO, VAO, EBO;
    createBuffers(VBO, VAO, EBO, vertices, indices);

    glm::mat4 projection = glm::perspective(45.0f, WIDTH / (float) HEIGHT, 0.1f, 100.0f);
    glm::vec3 lamp(map.getWidth() / 2, 0.9f, -map.getHeight() / 2);

    float time = (float) glfwGetTime();

    while (!glfwWindowShouldClose(window)) {
        glfwPollEvents();

        float cTime = (float) glfwGetTime();
        float delta = cTime - time;
        time = cTime;

        update(map, delta);

        glClearColor(117 / 255.0f, 187 / 255.0f, 253 / 255.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        shader.use();

        GLint textureLocation = glGetUniformLocation(shader.get(), "textureSampler");
        glUniform1i(textureLocation, 0);

        GLint normalLocation = glGetUniformLocation(shader.get(), "normalSampler");
        glUniform1i(normalLocation, 1);

        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, textures.get());

        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, normals.get());

        GLfloat timeValue = (GLfloat) glfwGetTime();

        GLfloat xValue = (GLfloat) (sin(timeValue) / 4) + 0.25f;
        GLint xValueLocation = glGetUniformLocation(shader.get(), "xValue");
        glUniform1f(xValueLocation, xValue);

        GLfloat yValue = (GLfloat) (cos(timeValue + 0.2) / 4) + 0.25f;
        GLint yValueLocation = glGetUniformLocation(shader.get(), "yValue");
        glUniform1f(yValueLocation, yValue);

        glm::mat4 model;
        model = glm::rotate(model, rotation, glm::vec3(0.0f, 1.0f, 0.0f));
        model = glm::translate(model, -cameraPos);

        GLint modelLocation = glGetUniformLocation(shader.get(), "model");
        glUniformMatrix4fv(modelLocation, 1, GL_FALSE, glm::value_ptr(model));

        glm::mat4 view;
        glm::vec3 eye(0.0f, 0.5f, 0.0f);
        view = glm::lookAt(eye, eye + cameraFront, cameraUp);

        GLint viewLocation = glGetUniformLocation(shader.get(), "view");
        glUniformMatrix4fv(viewLocation, 1, GL_FALSE, glm::value_ptr(view));

        GLint projectionLocation = glGetUniformLocation(shader.get(), "projection");
        glUniformMatrix4fv(projectionLocation, 1, GL_FALSE, glm::value_ptr(projection));

        GLint lightSourceLocation = glGetUniformLocation(shader.get(), "lightSource");
        if (spotlight) {
            glUniform3f(lightSourceLocation, cameraPos.x, cameraPos.y + 0.5f, cameraPos.z);
        } else {
            glUniform3f(lightSourceLocation, lamp.x, lamp.y, lamp.z);
        }

        glm::vec3 lookDirection = glm::normalize(glm::rotate(cameraFront, -rotation, cameraUp));
        GLint lookDirectionLocation = glGetUniformLocation(shader.get(), "lookDirection");
        glUniform3f(lookDirectionLocation, lookDirection.x, lookDirection.y, lookDirection.z);

        GLint spotlightLocation = glGetUniformLocation(shader.get(), "spotlight");
        glUniform1i(spotlightLocation, spotlight);

        glBindVertexArray(VAO);
        glDrawElements(GL_TRIANGLES, (GLuint) indices.size(), GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);

        glfwSwapBuffers(window);
    }

    disposeBuffers(VBO, VAO, EBO);

    glfwTerminate();
    return 0;
}
Esempio n. 17
0
int main() {
    GLFWwindow * window = initWindow();
    if (!window)
        return -1;

    Shader shader("shader.vert", "shader.frag");

    // prepare a VAO
    GLuint VAO;
    glGenVertexArrays(1, &VAO);
    glBindVertexArray(VAO);

    // prepare an array of vertices
    GLfloat vertices[] = {
        // positions          // colors
         0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,
         0.5f, -0.5f, 0.0f,   0.0f, 1.0f, 0.0f,
        -0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,
    };

    // prepare an array of indices
    GLuint indices[] = {
        0, 1, 2,
    };

    // prepare a VBO(vertex buffer object) to represent the buffer holding the vertices
    GLuint VBO;
    glGenBuffers(1, &VBO);
    // hints the type of VBO
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    // transfer the vertex data from main memory to GPU
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // prepare EBO(element buffer object)
    GLuint EBO;
    glGenBuffers(1, &EBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    // hints how opengl shoud interpret the data
    // positions
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    // colors
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
    glEnableVertexAttribArray(1);

    // unbinds the VAO
    glBindVertexArray(0);

    glfwSetKeyCallback(window, key_callback);
    while (!glfwWindowShouldClose(window)) {
        glfwPollEvents();

        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        shader.Use();

        glBindVertexArray(VAO);
        // DRAW!!!!
        //glDrawArrays(GL_TRIANGLES, 0, 3);
        // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); // eliminated because it's stored in VAO
        glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);

        glfwSwapBuffers(window);
    }

    glfwTerminate();
    return 0;
}
Esempio n. 18
0
int main(int argc, char *argv[]) {
    static SDL_Window *window;
    if(initWindow(&window, &renderer, argc, argv)) return 1;
    initVariables(WIDTH, HEIGHT);
    initTextures();
    initFonts();
    initInput();
    //initHUD();

    generateLevel(FIRSTLEVEL);

    hud = new Hud();

    /*==============*/
    /*  Test Stuff  */
    /*==============*/

    /*PhysicsEntity *goomba = new PhysicsEntity(getTexture("goomba"), 500, 50);
    goomba->patrolling = 1;

    Interactable *healthUp = new Interactable(getTexture("concrete"), 800, 500);
    healthUp->target = ply;
    healthUp->action = HEALTH_UP;

    Interactable *scrapUp = new Interactable(getTexture("sand"), 850, 500);
    scrapUp->target = ply;
    scrapUp->action = SCRAP_UP;*/

    /*=================*/
    /*End of Test Stuff*/
    /*=================*/

    int lastFrame = curtime_u() - 1;
    double dt;
    while(!quit) {
        if(DEBUG) fpsCounter();

        // Calculate dt
        int curFrame = curtime_u();
        if(lastFrame > curFrame) {
            dt = ((1000000 - lastFrame) + curFrame) / 1000000.0;
        }
        else {
            dt = (curFrame - lastFrame) / 1000000.0;
        }
        if(dt > 0.05) {
            dt = 0.05;   // Clamp dt so objects don't have collision issues
        }
        lastFrame = curFrame;

        // ===================
        // Update
        if(nextlevel != "") {
            printf("Switching to level %s\n", nextlevel.c_str());
            generateLevel(nextlevel);
            nextlevel = "";
        }
        TimerRun();
        for(int enti=0; enti<entsC; enti++) {
            if(ents[enti] == NULL) continue;
            ents[enti]->Update(dt);
            if(ents[enti]->isKilled) delete ents[enti];
        }

        // ====================
        // Drawing
        for(int rli=0; rli<RL_MAX; rli++) {
            if(rli == RL_BACKGROUND) {
                drawBackground(renderer, dt);
                continue; // Done in drawBackground
            }
            Drawable** layer = renderLayers[rli];
            for(int enti=0; enti<renderLayersC[rli]; enti++) {
                if(layer[enti] == NULL) continue;
                layer[enti]->Draw(dt);
            }
        }

        // Flip render buffer
        SDL_RenderPresent(renderer);

        // Frame limiting, not needed if we're using vsync
        //SDL_Delay((1000 / 66) - (curtime_u() - lastFrame)/1000);
    }
    printf("\nShutting down...\n");

    cleanLevel();
    // Destroy old textures
    for(std::map<std::string, TextureData>::iterator it = blockTDs.begin(); it != blockTDs.end(); ++it) {
        SDL_DestroyTexture(it->second.texture);
    }
    blockTDs.clear();

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);

    Mix_CloseAudio();
    Mix_Quit();

    IMG_Quit();
    SDL_Quit();
    return 0;
}
Esempio n. 19
0
int main(int argc, char **argv) {

    // Initialize our window
    initWindow(640, 480);

    // Create our vertex and index vectors
    std::vector<Vertex> vert_list;
    std::vector<GLushort> index_list;

    // Load up our model file
    Model cube("data/models/cube.yml");

    // Create the lights in the scene
    Light light0;
    light0.pos[0] = 1.0f; light0.pos[1] = 0.6f; light0.pos[2] = 0.6f;
    light0.color[0] = 0.9f; light0.color[1] = 1.0f; light0.color[2] = 1.0f; light0.color[3] = 1.0f;
    light0.intensity = 0.5f;


    // The main game loop
    bool running = true;
    SDL_Event event;
    while (running) {
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
                case SDL_WINDOWEVENT:
                    switch (event.window.event) {
                        case SDL_WINDOWEVENT_CLOSE:
                            running = false;
                            break;
                    }
                    break;
                case SDL_KEYDOWN:
                    switch (event.key.keysym.sym) {
                        case SDLK_ESCAPE:
                            running = false;
                            break;
                    }
                    break;
            }
        }

        // Call some generic window update functions
        updateWindow();

        // Bind the "view_matrix" variable in our C++ program to the "View" variable in the shader
        glUniformMatrix4fv(
                glGetUniformLocation(cube.shader_program, "View"),
                1,  
                false,
                glm::value_ptr(view_matrix));

        // Bind the "projection_matrix" variable in our C++ program to the "Projection" variable in the shader
        glUniformMatrix4fv(
                glGetUniformLocation(cube.shader_program, "Projection"),
                1,  
                false,
                glm::value_ptr(projection_matrix));

        // Bind the "model_matrix" variable in our C++ program to the "Model" variable in the shader
        glUniformMatrix4fv(
                glGetUniformLocation(cube.shader_program, "Model"),
                1,  
                false,
                glm::value_ptr(model_matrix));

        for (int i=0; i < cube.texture_count; i++) {
            glActiveTexture(GL_TEXTURE0+i);
            glBindTexture(GL_TEXTURE_2D, cube.texture_ids[i]);
            char buffer[20];
            sprintf(buffer, "texture_%d", i);
            glUniform1i(glGetUniformLocation(cube.shader_program, buffer), i);
        }

        glUniform3fv(glGetUniformLocation(cube.shader_program, "light0_pos"), 1, glm::value_ptr(light0.pos));
        glUniform4fv(glGetUniformLocation(cube.shader_program, "light0_col"), 1, glm::value_ptr(light0.color));
        glUniform1f(glGetUniformLocation(cube.shader_program, "light0_int"), light0.intensity);

        // Make our vertex array active
        glBindVertexArray(cube.vao);

        // Tell the renderer to use our shader program when rendering our object
        glUseProgramObjectARB(cube.shader_program);

        // Render the vao on the screen using "GL_LINE_LOOP"
        glDrawElements(GL_TRIANGLES, cube.index_list.size(), GL_UNSIGNED_SHORT, (void*)0);

        // All the previous rendering was done on a buffer that's not being displayed on the screen.
        // SDL_GL_SwapWindow displays that buffer in our window.
        SDL_GL_SwapWindow(main_window);

        // Pause the application for a few milliseconds
        SDL_Delay(10);
    }

    //Deinit SDL
    SDL_GL_DeleteContext(main_context);
    SDL_DestroyWindow(main_window);
    SDL_Quit();
}
Esempio n. 20
0
	void UiComponent::init() {
		if (!initialized) {
			initWindow();
			initialized = true;
		}
	}