Renderer::Renderer() : m_pos(0), m_numParticles(0), m_pointSize(1.0f), m_particleRadius(0.125f * 0.5f), //m_program(0), m_vbo(0), m_colorVBO(0), mWindowW(1024), mWindowH(768), mFov(60.0f), m_downSample(1), m_imageTex(0), m_postprocessingTex(0), m_depthTex(0), m_imageFbo(0), m_postprocessingFbo(0) //m_indexBuffer(0) { txParticle = LoadTexture("data/water.bmp"); m_displayTexProg = new GLSLProgram(passThruVS, texture2DPS); m_postprocessing = new GLSLProgram(passThruVS, postprocessingPS); _initGL(); }
bool ParticleSystemClass::Initialize(ID3D11Device* device, WCHAR* textureFilename) { bool result; result = LoadTexture(device, textureFilename); //load the texture that is used for the particles if(!result) { return false; } result = InitializeParticleSystem(); if(!result) { return false; } result = InitializeBuffers(device); if(!result) { return false; } return true; }
bool StaticMeshComponent::Initialise(ID3D11Device* device, char* modelFilename, WCHAR* textureFilename) { bool result; result = LoadModel(modelFilename); if (!result) { return false; } result = InitialiseBuffers(device); if (!result) { return false; } result = LoadTexture(device, textureFilename); if (!result) { return false; } return true; }
bool CWall::create(IDirect3DDevice9* pDevice, float iwidth, float iheight, float idepth, Type type){ m_width = iwidth; m_depth = idepth; m_height = iheight; if (FAILED(D3DXCreateBox(pDevice, iwidth, iheight, idepth, &m_pMesh, 0))) return false; LPD3DXMESH newMesh = convertMesh(pDevice, m_pMesh); if (newMesh == nullptr){ m_pMesh->Release(); return false; } switch (type){ case Plane: textureFile = PLANE_TEXTURE; effectFile = PLANE_EFFECT; break; case Edge: effectFile = EDGE_EFFECT; textureFile = EDGE_TEXTURE; break; } m_texture = LoadTexture(pDevice, textureFile); m_effect = LoadShader(pDevice, effectFile); if (m_texture == nullptr || m_effect == nullptr) return false; m_pMesh->Release(); m_pMesh = newMesh; return true; }
//////////////////////////////////////// // PUBLIC UTILITY FUNCTIONS //////////////////////////////////////// unsigned int TextureManager::GetTexture(string fileName) { Texture* texture = nullptr; map<string,Texture*>::iterator iter = m_textureMap.find(fileName); if(iter == m_textureMap.end()) { if(LoadTexture(fileName)) { texture = m_textureMap[fileName]; } else { LOG("Couldn't load texture: " << fileName); texture = m_textureMap[TextureManager::DEFAULT_TEXTURE_FILENAME]; } } else { texture = m_textureMap[fileName]; } return reinterpret_cast<unsigned int>(texture); }
// Create the plane, including its geometry, texture mapping, normal, and colour void CCubemap::Create(string sPositiveX, string sNegativeX, string sPositiveY, string sNegativeY, string sPositiveZ, string sNegativeZ) { int iWidth, iHeight; // Generate an OpenGL texture ID for this texture glGenTextures(1, &m_uiTexture); glBindTexture(GL_TEXTURE_CUBE_MAP, m_uiTexture); // Load the six sides BYTE *pbImagePosX, *pbImageNegX, *pbImagePosY, *pbImageNegY, *pbImagePosZ, *pbImageNegZ; LoadTexture(sPositiveX, &pbImagePosX, iWidth, iHeight); LoadTexture(sNegativeX, &pbImageNegX, iWidth, iHeight); LoadTexture(sPositiveY, &pbImagePosY, iWidth, iHeight); LoadTexture(sNegativeY, &pbImageNegY, iWidth, iHeight); LoadTexture(sPositiveZ, &pbImagePosZ, iWidth, iHeight); LoadTexture(sNegativeZ, &pbImageNegZ, iWidth, iHeight); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, iWidth, iHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, pbImagePosX); glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB, iWidth, iHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, pbImageNegX); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB, iWidth, iHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, pbImagePosY); glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB, iWidth, iHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, pbImageNegY); glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB, iWidth, iHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, pbImagePosZ); glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB, iWidth, iHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, pbImageNegZ); delete[] pbImagePosX; delete[] pbImageNegX; delete[] pbImagePosY; delete[] pbImageNegY; delete[] pbImagePosZ; delete[] pbImageNegZ; glGenSamplers(1, &m_uiSampler); glSamplerParameteri(m_uiSampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glSamplerParameteri(m_uiSampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glSamplerParameteri(m_uiSampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glSamplerParameteri(m_uiSampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glSamplerParameteri(m_uiSampler, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glGenerateMipmap(GL_TEXTURE_CUBE_MAP); }
void ClassDemoApp::Setup() { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("SoundInvaders", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); #ifdef _WINDOWS glewInit(); #endif done = false; program = new ShaderProgram(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl"); // program = new ShaderProgram(RESOURCE_FOLDER"vertex.glsl", RESOURCE_FOLDER"fragment.glsl"); spritetexture = LoadTexture("p1_front.png"); font = LoadTexture("Capword.png"); hitSound = Mix_LoadWAV("Get_Rupee.wav"); shootSound = Mix_LoadWAV("Trident.wav"); death1Sound = Mix_LoadWAV("Boss_Hit.wav"); death2Sound = Mix_LoadWAV("Boss_Death.wav"); music = Mix_LoadMUS("Dark_World.ogg"); projectionMatrix.setOrthoProjection(-3.55f, 3.55f, -2.0f, 2.0f, -1.0f, 1.0f); lives = 10; spaceship = new Spaceship(program, 0.21f, 0.21f, LoadTexture("Zelda.png")); invaders = new Invaders(program, 0.21f, 0.21f, LoadTexture("Links.png"), LoadTexture("Arrow.png")); tank = new Tank(program, 0.19f, 0.19f, LoadTexture("Ganon.png"), LoadTexture("Trident.png")); highscore = 0; state = STATE_MAIN_MENU; musicTicks = 16; Mix_PlayMusic(music, -1); }
void Setup() { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("Rob Chiarelli's Pong V", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); glViewport(0, 0, 800, 600); glMatrixMode(GL_PROJECTION); glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0); ball.textureID = LoadTexture("green_panel.png"); paddle1.textureID = LoadTexture("green_panel.png"); paddle2.textureID = LoadTexture("green_panel.png"); top.textureID = LoadTexture("green_panel.png"); bottom.textureID = LoadTexture("green_panel.png"); space.textureID = LoadTexture("grey_button02.png"); srand(time(NULL)); ball.setSize(0.1, 0.1); ball.setPosition(0.0, 0.0, 0.0); ball.setMovement(2.0, rand() % 50 - 25); //The ball is set to move right at a random angle between //-25 and 25 degrees for maximum playability paddle1.setSize(0.1, 0.5); paddle1.setPosition(-1.2, 0.0, 0.0); paddle1.setMovement(2.0, 0); paddle2.setSize(0.1, 0.5); paddle2.setPosition(1.2, 0.0, 0.0); paddle2.setMovement(2.0, 0); top.setSize(2.66, 0.1); top.setPosition(0.0, 1.0, 0.0); bottom.setSize(2.66, 0.1); bottom.setPosition(0.0, -1.0, 0.0); space.setSize(1.0, 0.3); space.setPosition(0.0, 0.8, 0.0); }
// Gameplay Screen Initialization logic void InitGameplayScreen(void) { // TODO: Initialize GAMEPLAY screen variables here! framesCounter = 0; finishScreen = 0; // MAP LAODING // TODO: Read .bmp file propierly in order to get image width & height Color *mapPixels = malloc(GRID_WIDTH*GRID_HEIGHT * sizeof(Color)); mapPixels = GetImageData(LoadImage("assets/gameplay_screen/maps/map.bmp")); maxTriangles = 0; maxPlatforms = 0; for (int i=0; i<GRID_WIDTH*GRID_HEIGHT; i++) { /* printf("r: %i\n", mapPixels[i].r); printf("g: %i\n", mapPixels[i].g); printf("b: %i\n\n", mapPixels[i].b); */ if (mapPixels[i].r == 255 && mapPixels[i].g == 0 && mapPixels[i].b == 0) maxTriangles++; else if (mapPixels[i].r == 0 && mapPixels[i].g == 255 && mapPixels[i].b == 0) maxPlatforms++; } triangles = malloc(maxTriangles * sizeof(TriangleObject)); platforms = malloc(maxPlatforms * sizeof(SquareObject)); int trianglesCounter=0; int platformsCounter=0; for (int y=0; y<GRID_HEIGHT; y++) { for (int x=0; x<GRID_WIDTH; x++) { if (mapPixels[y*GRID_WIDTH+x].r == 255 && mapPixels[y*GRID_WIDTH+x].g == 0 && mapPixels[y*GRID_WIDTH+x].b == 0) { InitializeTriangle(&triangles[trianglesCounter], (Vector2){x, y}); trianglesCounter++; } else if (mapPixels[y*GRID_WIDTH+x].r == 0 && mapPixels[y*GRID_WIDTH+x].g == 255 && mapPixels[y*GRID_WIDTH+x].b == 0) { InitializePlatform(&platforms[platformsCounter], (Vector2){x, y}); platformsCounter++; } } } free(mapPixels); //DEBUGGING && TESTING variables pause = FALSE; srand(time(NULL)); // Textures loading player.texture = LoadTexture("assets/gameplay_screen/cube_main.png"); triangleTexture = LoadTexture("assets/gameplay_screen/triangle_main.png"); platformTexture = LoadTexture("assets/gameplay_screen/platform_main.png"); player.pEmitter.texture = LoadTexture("assets/gameplay_screen/particle_main.png"); bg = LoadTexture("assets/gameplay_screen/bg_main.png"); // Sound loading InitAudioDevice(); PlayMusicStream("assets/gameplay_screen/music/Flash_Funk_MarshmelloRemix.ogg"); PauseMusicStream(); SetMusicVolume(0.5f); // Did player win? startGame = FALSE; /* player.texture = LoadTexture("assets/gameplay_screen/debug.png"); triangleTexture = LoadTexture("assets/gameplay_screen/debug.png"); platformTexture = LoadTexture("assets/gameplay_screen/debug.png"); player.pEmitter.texture = LoadTexture("assets/gameplay_screen/particle_main.png"); */ // Camera initialization mainCamera = (Camera2D){Vector2Right(), (Vector2){6.5f, 6.5f}, Vector2Zero(), TRUE}; // Gravity initialization gravity = (GravityForce){Vector2Up(), 1.5f}; // Ground position and coordinate groundCoordinadeY = GetScreenHeight()/CELL_SIZE-1; groundPositionY = GetOnGridPosition((Vector2){0, groundCoordinadeY}).y; // Player initialization InitializePlayer(&player, (Vector2){4, groundCoordinadeY-1}, (Vector2){0, 15}, 0.35f*GAME_SPEED); /* // Triangles initialization InitializeTriangle(&triangles[0], (Vector2){40, groundCoordinadeY-1}); InitializeTriangle(&triangles[1], (Vector2){50, groundCoordinadeY-1}); InitializeTriangle(&triangles[2], (Vector2){85, groundCoordinadeY-1}); // Platforms initialization InitializePlatform(&platforms[0], (Vector2){20, groundCoordinadeY-1}); InitializePlatform(&platforms[1], (Vector2){21, groundCoordinadeY-1}); InitializePlatform(&platforms[2], (Vector2){22, groundCoordinadeY-1}); InitializePlatform(&platforms[3], (Vector2){23, groundCoordinadeY-2}); InitializePlatform(&platforms[4], (Vector2){24, groundCoordinadeY-2}); */ }
//---------------------------------------------------------------------------------- // Main entry point //---------------------------------------------------------------------------------- int main(void) { // Initialization (Note windowTitle is unused on Android) //--------------------------------------------------------- InitWindow(screenWidth, screenHeight, "KOALA SEASONS"); // Load global data here (assets that must be available in all screens, i.e. fonts) font = LoadFont("resources/graphics/mainfont.png"); atlas01 = LoadTexture("resources/graphics/atlas01.png"); atlas02 = LoadTexture("resources/graphics/atlas02.png"); #if defined(PLATFORM_WEB) || defined(PLATFORM_RPI) || defined(PLATFORM_ANDROID) colorBlend = LoadShader("resources/shaders/glsl100/base.vs", "resources/shaders/glsl100/blend_color.fs"); #else colorBlend = LoadShader("resources/shaders/glsl330/base.vs", "resources/shaders/glsl330/blend_color.fs"); #endif InitAudioDevice(); // Load sounds data fxJump = LoadSound("resources/audio/jump.ogg"); fxDash = LoadSound("resources/audio/dash.ogg"); fxEatLeaves = LoadSound("resources/audio/eat_leaves.ogg"); fxHitResin = LoadSound("resources/audio/resin_hit.ogg"); fxWind = LoadSound("resources/audio/wind_sound.ogg"); fxDieSnake = LoadSound("resources/audio/snake_die.ogg"); fxDieDingo = LoadSound("resources/audio/dingo_die.ogg"); fxDieOwl = LoadSound("resources/audio/owl_die.ogg"); music = LoadMusicStream("resources/audio/jngl.xm"); PlayMusicStream(music); SetMusicVolume(music, 1.0f); // Define and init first screen // NOTE: currentScreen is defined in screens.h as a global variable currentScreen = TITLE; InitLogoScreen(); //InitOptionsScreen(); InitTitleScreen(); InitGameplayScreen(); InitEndingScreen(); #if defined(PLATFORM_WEB) emscripten_set_main_loop(UpdateDrawFrame, 0, 1); #else SetTargetFPS(60); // Set our game to run at 60 frames-per-second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) UpdateDrawFrame(); #endif // De-Initialization //-------------------------------------------------------------------------------------- UnloadEndingScreen(); UnloadTitleScreen(); UnloadGameplayScreen(); UnloadLogoScreen(); UnloadTexture(atlas01); UnloadTexture(atlas02); UnloadFont(font); UnloadShader(colorBlend); // Unload color overlay blending shader UnloadSound(fxJump); UnloadSound(fxDash); UnloadSound(fxEatLeaves); UnloadSound(fxHitResin); UnloadSound(fxWind); UnloadSound(fxDieSnake); UnloadSound(fxDieDingo); UnloadSound(fxDieOwl); UnloadMusicStream(music); CloseAudioDevice(); // Close audio device CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
// Gameplay Screen Initialization logic void InitLivingroomScreen(void) { ResetPlayer(); // Reset Screen variables monsterHover = false; monsterCheck = -1; msgState = 0; msgCounter = 0; lettersCounter = 0; for (int i = 0; i < 256; i++) msgBuffer[i] = '\0'; framesCounter = 0; finishScreen = 0; background = LoadTexture("resources/textures/background_livingroom.png"); // Initialize doors doorLeft.position = (Vector2) { -45, 140}; doorLeft.facing = 0; doorLeft.locked = true; doorLeft.frameRec =(Rectangle) {((doors.width/3)*doorLeft.facing), doors.height/2, doors.width/3, doors.height/2}; doorLeft.bound = (Rectangle) { doorLeft.position.x, doorLeft.position.y, doors.width/3, doors.height/2}; doorLeft.selected = false; doorCenter.position = (Vector2) { 830, 108 }; doorCenter.facing = 1; doorCenter.locked = true; doorCenter.frameRec =(Rectangle) {((doors.width/3)*doorCenter.facing), doors.height/2, doors.width/3, doors.height/2}; doorCenter.bound = (Rectangle) { doorCenter.position.x, doorCenter.position.y, doors.width/3, doors.height/2}; doorCenter.selected = false; // Monster init: lamp candle.position = (Vector2){ 154, 256 }; candle.texture = LoadTexture("resources/textures/monster_candle.png"); candle.currentFrame = 0; candle.framesCounter = 0; candle.numFrames = 4; candle.bounds = (Rectangle){ candle.position.x + 90, candle.position.y + 30, 185, 340 }; candle.frameRec = (Rectangle) { 0, 0, candle.texture.width/candle.numFrames, candle.texture.height }; candle.selected = false; candle.active = false; candle.spooky = false; // Monster init: arc picture.position = (Vector2){ 504, 164 }; picture.texture = LoadTexture("resources/textures/monster_picture.png"); picture.currentFrame = 0; picture.framesCounter = 0; picture.numFrames = 4; picture.bounds = (Rectangle){ picture.position.x + 44, picture.position.y, 174, 264 }; picture.frameRec = (Rectangle) { 0, 0, picture.texture.width/picture.numFrames, picture.texture.height }; picture.selected = false; picture.active = false; picture.spooky = true; // Monster init: phone phone.position = (Vector2){ 1054, 404 }; phone.texture = LoadTexture("resources/textures/monster_phone.png"); phone.currentFrame = 0; phone.framesCounter = 0; phone.numFrames = 4; phone.bounds = (Rectangle){ phone.position.x + 64, phone.position.y +120, 100, 160 }; phone.frameRec = (Rectangle) { 0, 0, phone.texture.width/phone.numFrames, phone.texture.height }; phone.selected = false; phone.active = false; phone.spooky = true; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "Floppy Bird"); InitAudioDevice(); // Initialize audio device Sound coin = LoadSound("resources/coin.wav"); Sound jump = LoadSound("resources/jump.wav"); Texture2D background = LoadTexture("resources/background.png"); Texture2D tubes = LoadTexture("resources/tubes.png"); Texture2D floppy = LoadTexture("resources/floppy.png"); Vector2 floppyPos = { 80, screenHeight/2 - floppy.height/2 }; Vector2 tubesPos[MAX_TUBES]; int tubesSpeedX = 2; for (int i = 0; i < MAX_TUBES; i++) { tubesPos[i].x = 400 + 280*i; tubesPos[i].y = -GetRandomValue(0, 120); } Rectangle tubesRecs[MAX_TUBES*2]; bool tubesActive[MAX_TUBES]; for (int i = 0; i < MAX_TUBES*2; i += 2) { tubesRecs[i].x = tubesPos[i/2].x; tubesRecs[i].y = tubesPos[i/2].y; tubesRecs[i].width = tubes.width; tubesRecs[i].height = 255; tubesRecs[i+1].x = tubesPos[i/2].x; tubesRecs[i+1].y = 600 + tubesPos[i/2].y - 255; tubesRecs[i+1].width = tubes.width; tubesRecs[i+1].height = 255; tubesActive[i/2] = true; } int backScroll = 0; int score = 0; int hiscore = 0; bool gameover = false; bool superfx = false; SetTargetFPS(60); //--------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- backScroll--; if (backScroll <= -800) backScroll = 0; for (int i = 0; i < MAX_TUBES; i++) tubesPos[i].x -= tubesSpeedX; for (int i = 0; i < MAX_TUBES*2; i += 2) { tubesRecs[i].x = tubesPos[i/2].x; tubesRecs[i+1].x = tubesPos[i/2].x; } if (IsKeyDown(KEY_SPACE) && !gameover) floppyPos.y -= 3; else floppyPos.y += 1; if (IsKeyPressed(KEY_SPACE) && !gameover) PlaySound(jump); // Check Collisions for (int i = 0; i < MAX_TUBES*2; i++) { if (CheckCollisionCircleRec((Vector2){ floppyPos.x + floppy.width/2, floppyPos.y + floppy.height/2 }, floppy.width/2, tubesRecs[i])) { gameover = true; } else if ((tubesPos[i/2].x < floppyPos.x) && tubesActive[i/2] && !gameover) { score += 100; tubesActive[i/2] = false; PlaySound(coin); superfx = true; if (score > hiscore) hiscore = score; } } if (gameover && IsKeyPressed(KEY_ENTER)) { for (int i = 0; i < MAX_TUBES; i++) { tubesPos[i].x = 400 + 280*i; tubesPos[i].y = -GetRandomValue(0, 120); } for (int i = 0; i < MAX_TUBES*2; i += 2) { tubesRecs[i].x = tubesPos[i/2].x; tubesRecs[i].y = tubesPos[i/2].y; tubesRecs[i+1].x = tubesPos[i/2].x; tubesRecs[i+1].y = 600 + tubesPos[i/2].y - 255; tubesActive[i/2] = true; } floppyPos.x = 80; floppyPos.y = screenHeight/2 - floppy.height/2; gameover = false; score = 0; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawTexture(background, backScroll, 0, WHITE); DrawTexture(background, screenWidth + backScroll, 0, WHITE); if (!gameover) { DrawTextureEx(floppy, floppyPos, 0, 1.0, WHITE); //DrawCircleLines(floppyPos.x + floppy.width/2, floppyPos.y + floppy.height/2, floppy.width/2, RED); } for (int i = 0; i < MAX_TUBES; i++) { if (tubesPos[i].x <= 800) DrawTextureEx(tubes, tubesPos[i], 0, 1.0, WHITE); //DrawRectangleLines(tubesRecs[i*2].x, tubesRecs[i*2].y, tubesRecs[i*2].width, tubesRecs[i*2].height, RED); //DrawRectangleLines(tubesRecs[i*2 + 1].x, tubesRecs[i*2 + 1].y, tubesRecs[i*2 + 1].width, tubesRecs[i*2 + 1].height, RED); } DrawText(FormatText("%04i", score), 20, 20, 40, PINK); DrawText(FormatText("HI-SCORE: %04i", hiscore), 20, 70, 20, VIOLET); if (gameover) { DrawText("GAME OVER", 100, 180, 100, MAROON); DrawText("PRESS ENTER to RETRY!", 280, 280, 20, RED); } if (superfx) { DrawRectangle(0, 0, screenWidth, screenHeight, GOLD); superfx = false; } EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadTexture(background); // Texture unloading UnloadTexture(tubes); // Texture unloading UnloadTexture(floppy); // Texture unloading UnloadSound(coin); // Unload sound data UnloadSound(jump); // Unload sound data CloseAudioDevice(); // Close audio device CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
void CBspMapResourceProvider::LoadTextures(const CBspFile& bspFile, CPakFile& pakFile) { const Bsp::TextureArray& textures(bspFile.GetTextures()); m_materials.resize(textures.size()); for(uint32 i = 0; i < textures.size(); i++) { const Bsp::TEXTURE& texture(textures[i]); auto resultMaterial = BspMapMaterialPtr(new CBspMapMaterial()); m_materials[i] = resultMaterial; ShaderMap::const_iterator shaderIterator = m_shaders.find(texture.name); if(shaderIterator == m_shaders.end()) { //Create a basic material with this texture std::string fullName; if(!pakFile.TryCompleteFileName(texture.name, fullName)) { continue; } LoadTexture(fullName.c_str(), pakFile); { auto pass = BspMapPassPtr(new CBspMapPass()); pass->SetTexture(GetTexture(fullName.c_str())); pass->SetTextureSource(CBspMapPass::TEXTURE_SOURCE_DIFFUSE); pass->SetBlendingFunction(Palleon::TEXTURE_COMBINE_MODULATE); resultMaterial->AddPass(pass); } { auto pass = BspMapPassPtr(new CBspMapPass()); pass->SetTextureSource(CBspMapPass::TEXTURE_SOURCE_LIGHTMAP); pass->SetBlendingFunction(Palleon::TEXTURE_COMBINE_MODULATE); resultMaterial->AddPass(pass); } } else { const QUAKE_SHADER& shader = shaderIterator->second; resultMaterial->SetIsSky(shader.isSky); for(QuakeShaderPassArray::const_iterator passIterator(shader.passes.begin()); passIterator != shader.passes.end(); passIterator++) { const QUAKE_SHADER_PASS& passData(*passIterator); if(passData.mapName.length() < 4) continue; auto pass = BspMapPassPtr(new CBspMapPass()); { Palleon::TEXTURE_COMBINE_MODE blendingFunction = Palleon::TEXTURE_COMBINE_MODULATE; switch(passData.blendFunc) { case QUAKE_SHADER_BLEND_BLEND: blendingFunction = Palleon::TEXTURE_COMBINE_LERP; break; case QUAKE_SHADER_BLEND_ADD: blendingFunction = Palleon::TEXTURE_COMBINE_ADD; break; case QUAKE_SHADER_BLEND_FILTER: blendingFunction = Palleon::TEXTURE_COMBINE_MODULATE; break; } pass->SetBlendingFunction(blendingFunction); } if(passData.mapName == "$lightmap") { pass->SetTextureSource(CBspMapPass::TEXTURE_SOURCE_LIGHTMAP); } else { std::string fileName(passData.mapName.begin(), passData.mapName.begin() + passData.mapName.length() - 4); std::string fullName; if(!pakFile.TryCompleteFileName(fileName.c_str(), fullName)) { continue; } LoadTexture(fullName.c_str(), pakFile); pass->SetTexture(GetTexture(fullName.c_str())); pass->SetTextureSource(CBspMapPass::TEXTURE_SOURCE_DIFFUSE); } for(unsigned int i = 0; i < passData.tcMods.size(); i++) { const QUAKE_SHADER_TCMOD& tcMod(passData.tcMods[i]); BspMapTcModPtr result; switch(tcMod.type) { case QUAKE_SHADER_TCMOD_SCROLL: result = BspMapTcModPtr(new CBspMapTcMod_Scroll( tcMod.params[0], tcMod.params[1])); break; case QUAKE_SHADER_TCMOD_SCALE: result = BspMapTcModPtr(new CBspMapTcMod_Scale( tcMod.params[0], tcMod.params[1])); break; case QUAKE_SHADER_TCMOD_ROTATE: result = BspMapTcModPtr(new CBspMapTcMod_Rotate( tcMod.params[0])); break; case QUAKE_SHADER_TCMOD_TURB: result = BspMapTcModPtr(new CBspMapTcMod_Turb( tcMod.params[1], tcMod.params[3])); break; case QUAKE_SHADER_TCMOD_STRETCH: { BSPMAPWAVEPARAMS wave; wave.type = BSPMAPWAVEPARAMS::WAVE_SIN; wave.base = tcMod.params[0]; wave.amplitude = tcMod.params[1]; wave.phase = tcMod.params[2]; wave.freq = tcMod.params[3]; result = BspMapTcModPtr(new CBspMapTcMod_Stretch(wave)); } break; default: continue; break; } pass->AddTcMod(result); } resultMaterial->AddPass(pass); if(resultMaterial->GetPassCount() == CBspMapMaterial::MAX_PASS) { break; } } } } }
int main(int argc, char *argv[]) { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); SDL_Event event; bool done = false; #ifdef _WINDOWS glewInit(); #endif Matrix projectionMatrix; Matrix modelMatrix; Matrix viewMatrix; ShaderProgram program(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl"); GLuint dogTexture = LoadTexture("dog.png"); GLuint ballTexture = LoadTexture("ball.png"); GLuint boneTexture = LoadTexture("bone.png"); projectionMatrix.setOrthoProjection(-3.55, 3.55, -2.0f, 2.0f, -1.0f, 1.0f); glUseProgram(program.programID); float lastFrameTicks = 0.0f; double movement = 0.0; double ballBounce = 0.0; bool bounceHigh = false; bool firstHit = false; const Uint8 *keys = SDL_GetKeyboardState(NULL); while (!done) { while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) { done = true; } } glClear(GL_COLOR_BUFFER_BIT); program.setModelMatrix(modelMatrix); program.setProjectionMatrix(projectionMatrix); program.setViewMatrix(viewMatrix); glBindTexture(GL_TEXTURE_2D, ballTexture); float ticks = (float)SDL_GetTicks() / 1000.0f; float elapsed = ticks - lastFrameTicks; lastFrameTicks = ticks; if (firstHit == false){ movement = movement + elapsed; } //makes the ball bounce if ((ballBounce * 0.75) >= 1){ bounceHigh = true; } if ((ballBounce * 0.75) <= -1){ bounceHigh = false; } if (bounceHigh == false){ ballBounce = ballBounce + elapsed; } else if (bounceHigh == true){ ballBounce = ballBounce - elapsed; } float vertices[] = { -1.4 + (movement * 0.25), -0.4 + (ballBounce * 0.25), -0.4 + (movement * 0.25), -0.4 + (ballBounce * 0.25), -0.4 + (movement * 0.25), 0.4 + (ballBounce * 0.25), -1.4 + (movement * 0.25), -0.4 + (ballBounce * 0.25), -0.4 + (movement * 0.25), 0.4 + (ballBounce * 0.25), -1.4 + (movement * 0.25), 0.4 + (ballBounce * 0.25) }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, vertices); glEnableVertexAttribArray(program.positionAttribute); float texCoords[] = { 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0 }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoords); glEnableVertexAttribArray(program.texCoordAttribute); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); if (keys[SDL_SCANCODE_A]) { --p1X; } else if (keys[SDL_SCANCODE_D]) { ++p1X; } if (keys[SDL_SCANCODE_W]) { ++p1Y; } else if (keys[SDL_SCANCODE_S]) { --p1Y; } glBindTexture(GL_TEXTURE_2D, dogTexture); float vertices2[] = { -2.5 + (p1X * 0.001), -0.5 + (p1Y * 0.001), -1.5 + (p1X * 0.001), -0.5 + (p1Y * 0.001), -1.5 + (p1X * 0.001), 0.5 + (p1Y * 0.001), -2.5 + (p1X * 0.001), -0.5 + (p1Y * 0.001), -1.5 + (p1X * 0.001), 0.5 + (p1Y * 0.001), -2.5 + (p1X * 0.001), 0.5 + (p1Y * 0.001) }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, vertices2); glEnableVertexAttribArray(program.positionAttribute); float texCoords2[] = { 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0 }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoords2); glEnableVertexAttribArray(program.texCoordAttribute); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); if (keys[SDL_SCANCODE_J]) { --p2X; } else if (keys[SDL_SCANCODE_L]) { ++p2X; } if (keys[SDL_SCANCODE_I]) { ++p2Y; } else if (keys[SDL_SCANCODE_K]) { --p2Y; } glBindTexture(GL_TEXTURE_2D, dogTexture); float vertices3[] = { 1.5 + (p2X * 0.001), -0.5 + (p2Y * 0.001), 2.5 + (p2X * 0.001), -0.5 + (p2Y * 0.001), 2.5 + (p2X * 0.001), 0.5 + (p2Y * 0.001), 1.5 + (p2X * 0.001), -0.5 + (p2Y * 0.001), 2.5 + (p2X * 0.001), 0.5 + (p2Y * 0.001), 1.5 + (p2X * 0.001), 0.5 + (p2Y * 0.001) }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, vertices3); glEnableVertexAttribArray(program.positionAttribute); float texCoords3[] = { 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0 }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoords3); glEnableVertexAttribArray(program.texCoordAttribute); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); SDL_GL_SwapWindow(displayWindow); //collision if ((vertices[11] <= vertices2[5] && vertices[11] >= vertices2[3]) || (vertices[1] <= vertices2[5] && vertices[1] >= vertices2[3]) && vertices[10] == vertices2[4]) { firstHit = true; movement = movement + elapsed; } else if ((vertices[5] <= vertices3[11] && vertices[5] >= vertices3[1]) || (vertices[3] <= vertices3[11] && vertices[3] >= vertices3[1]) && vertices[4] == vertices3[10]) { firstHit = true; movement = movement - elapsed; } if (vertices[10] <= vertices2[4]) { std::cout << "Player 2 Wins" << std::endl; } else if (vertices[4] >= vertices3[10]) { std::cout << "Player 1 Wins" << std::endl; } } SDL_Quit(); return 0; }
static SDL_bool WatchJoystick(SDL_Joystick * joystick) { SDL_Window *window = NULL; SDL_Renderer *screen = NULL; SDL_Texture *background, *button, *axis, *marker; const char *name = NULL; SDL_bool retval = SDL_FALSE; SDL_bool done = SDL_FALSE, next=SDL_FALSE; SDL_Event event; SDL_Rect dst; int s, _s; Uint8 alpha=200, alpha_step = -1; Uint32 alpha_ticks; char mapping[4096], temp[4096]; MappingStep *step; MappingStep steps[] = { {342, 132, 0.0, MARKER_BUTTON, "x", -1, -1, -1, -1, ""}, {387, 167, 0.0, MARKER_BUTTON, "a", -1, -1, -1, -1, ""}, {431, 132, 0.0, MARKER_BUTTON, "b", -1, -1, -1, -1, ""}, {389, 101, 0.0, MARKER_BUTTON, "y", -1, -1, -1, -1, ""}, {174, 132, 0.0, MARKER_BUTTON, "back", -1, -1, -1, -1, ""}, {233, 132, 0.0, MARKER_BUTTON, "guide", -1, -1, -1, -1, ""}, {289, 132, 0.0, MARKER_BUTTON, "start", -1, -1, -1, -1, ""}, {116, 217, 0.0, MARKER_BUTTON, "dpleft", -1, -1, -1, -1, ""}, {154, 249, 0.0, MARKER_BUTTON, "dpdown", -1, -1, -1, -1, ""}, {186, 217, 0.0, MARKER_BUTTON, "dpright", -1, -1, -1, -1, ""}, {154, 188, 0.0, MARKER_BUTTON, "dpup", -1, -1, -1, -1, ""}, {77, 40, 0.0, MARKER_BUTTON, "leftshoulder", -1, -1, -1, -1, ""}, {91, 0, 0.0, MARKER_BUTTON, "lefttrigger", -1, -1, -1, -1, ""}, {396, 36, 0.0, MARKER_BUTTON, "rightshoulder", -1, -1, -1, -1, ""}, {375, 0, 0.0, MARKER_BUTTON, "righttrigger", -1, -1, -1, -1, ""}, {75, 154, 0.0, MARKER_BUTTON, "leftstick", -1, -1, -1, -1, ""}, {305, 230, 0.0, MARKER_BUTTON, "rightstick", -1, -1, -1, -1, ""}, {75, 154, 0.0, MARKER_AXIS, "leftx", -1, -1, -1, -1, ""}, {75, 154, 90.0, MARKER_AXIS, "lefty", -1, -1, -1, -1, ""}, {305, 230, 0.0, MARKER_AXIS, "rightx", -1, -1, -1, -1, ""}, {305, 230, 90.0, MARKER_AXIS, "righty", -1, -1, -1, -1, ""}, }; /* Create a window to display joystick axis position */ window = SDL_CreateWindow("Game Controller Map", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, 0); if (window == NULL) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError()); return SDL_FALSE; } screen = SDL_CreateRenderer(window, -1, 0); if (screen == NULL) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError()); SDL_DestroyWindow(window); return SDL_FALSE; } background = LoadTexture(screen, "controllermap.bmp", SDL_FALSE); button = LoadTexture(screen, "button.bmp", SDL_TRUE); axis = LoadTexture(screen, "axis.bmp", SDL_TRUE); SDL_RaiseWindow(window); /* scale for platforms that don't give you the window size you asked for. */ SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT); /* Print info about the joystick we are watching */ name = SDL_JoystickName(joystick); SDL_Log("Watching joystick %d: (%s)\n", SDL_JoystickInstanceID(joystick), name ? name : "Unknown Joystick"); SDL_Log("Joystick has %d axes, %d hats, %d balls, and %d buttons\n", SDL_JoystickNumAxes(joystick), SDL_JoystickNumHats(joystick), SDL_JoystickNumBalls(joystick), SDL_JoystickNumButtons(joystick)); SDL_Log("\n\n\ ====================================================================================\n\ Press the buttons on your controller when indicated\n\ (Your controller may look different than the picture)\n\ If you want to correct a mistake, press backspace or the back button on your device\n\ To skip a button, press SPACE or click/touch the screen\n\ To exit, press ESC\n\ ====================================================================================\n"); /* Initialize mapping with GUID and name */ SDL_JoystickGetGUIDString(SDL_JoystickGetGUID(joystick), temp, SDL_arraysize(temp)); SDL_snprintf(mapping, SDL_arraysize(mapping), "%s,%s,platform:%s,", temp, name ? name : "Unknown Joystick", SDL_GetPlatform()); /* Loop, getting joystick events! */ for(s=0; s<SDL_arraysize(steps) && !done;) { /* blank screen, set up for drawing this frame. */ step = &steps[s]; SDL_strlcpy(step->mapping, mapping, SDL_arraysize(step->mapping)); step->axis = -1; step->button = -1; step->hat = -1; step->hat_value = -1; SDL_SetClipboardText("TESTING TESTING 123"); switch(step->marker) { case MARKER_AXIS: marker = axis; break; case MARKER_BUTTON: marker = button; break; default: break; } dst.x = step->x; dst.y = step->y; SDL_QueryTexture(marker, NULL, NULL, &dst.w, &dst.h); next=SDL_FALSE; SDL_SetRenderDrawColor(screen, 0xFF, 0xFF, 0xFF, SDL_ALPHA_OPAQUE); while (!done && !next) { if (SDL_GetTicks() - alpha_ticks > 5) { alpha_ticks = SDL_GetTicks(); alpha += alpha_step; if (alpha == 255) { alpha_step = -1; } if (alpha < 128) { alpha_step = 1; } } SDL_RenderClear(screen); SDL_RenderCopy(screen, background, NULL, NULL); SDL_SetTextureAlphaMod(marker, alpha); SDL_SetTextureColorMod(marker, 10, 255, 21); SDL_RenderCopyEx(screen, marker, NULL, &dst, step->angle, NULL, 0); SDL_RenderPresent(screen); if (SDL_PollEvent(&event)) { switch (event.type) { case SDL_JOYAXISMOTION: if (event.jaxis.value > 20000 || event.jaxis.value < -20000) { for (_s = 0; _s < s; _s++) { if (steps[_s].axis == event.jaxis.axis) { break; } } if (_s == s) { step->axis = event.jaxis.axis; SDL_strlcat(mapping, step->field, SDL_arraysize(mapping)); SDL_snprintf(temp, SDL_arraysize(temp), ":a%u,", event.jaxis.axis); SDL_strlcat(mapping, temp, SDL_arraysize(mapping)); s++; next=SDL_TRUE; } } break; case SDL_JOYHATMOTION: if (event.jhat.value == SDL_HAT_CENTERED) { break; /* ignore centering, we're probably just coming back to the center from the previous item we set. */ } for (_s = 0; _s < s; _s++) { if (steps[_s].hat == event.jhat.hat && steps[_s].hat_value == event.jhat.value) { break; } } if (_s == s) { step->hat = event.jhat.hat; step->hat_value = event.jhat.value; SDL_strlcat(mapping, step->field, SDL_arraysize(mapping)); SDL_snprintf(temp, SDL_arraysize(temp), ":h%u.%u,", event.jhat.hat, event.jhat.value ); SDL_strlcat(mapping, temp, SDL_arraysize(mapping)); s++; next=SDL_TRUE; } break; case SDL_JOYBALLMOTION: break; case SDL_JOYBUTTONUP: for (_s = 0; _s < s; _s++) { if (steps[_s].button == event.jbutton.button) { break; } } if (_s == s) { step->button = event.jbutton.button; SDL_strlcat(mapping, step->field, SDL_arraysize(mapping)); SDL_snprintf(temp, SDL_arraysize(temp), ":b%u,", event.jbutton.button); SDL_strlcat(mapping, temp, SDL_arraysize(mapping)); s++; next=SDL_TRUE; } break; case SDL_FINGERDOWN: case SDL_MOUSEBUTTONDOWN: /* Skip this step */ s++; next=SDL_TRUE; break; case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_BACKSPACE || event.key.keysym.sym == SDLK_AC_BACK) { /* Undo! */ if (s > 0) { SDL_strlcpy(mapping, step->mapping, SDL_arraysize(step->mapping)); s--; next = SDL_TRUE; } break; } if (event.key.keysym.sym == SDLK_SPACE) { /* Skip this step */ s++; next=SDL_TRUE; break; } if ((event.key.keysym.sym != SDLK_ESCAPE)) { break; } /* Fall through to signal quit */ case SDL_QUIT: done = SDL_TRUE; break; default: break; } } } } if (s == SDL_arraysize(steps) ) { SDL_Log("Mapping:\n\n%s\n\n", mapping); /* Print to stdout as well so the user can cat the output somewhere */ printf("%s\n", mapping); } while(SDL_PollEvent(&event)) {}; SDL_DestroyRenderer(screen); SDL_DestroyWindow(window); return retval; }
//------------------------------------------------------------------------------- int CMaterialManager::CreateMaterial( AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource) { #if 1//??? ai_assert(0 != pcMesh); ai_assert(0 != pcSource); // ID3DXFROMWINEBuffer* piBuffer; // extract all properties from the ASSIMP material structure const aiMaterial* pcMat = mr->GetAsset()->pcScene->mMaterials[pcSource->mMaterialIndex]; // // DIFFUSE COLOR -------------------------------------------------- // if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_DIFFUSE, (aiColor4D*)&pcMesh->vDiffuseColor)) { pcMesh->vDiffuseColor.x = 1.0f; pcMesh->vDiffuseColor.y = 1.0f; pcMesh->vDiffuseColor.z = 1.0f; pcMesh->vDiffuseColor.w = 1.0f; } // // SPECULAR COLOR -------------------------------------------------- // if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_SPECULAR, (aiColor4D*)&pcMesh->vSpecularColor)) { pcMesh->vSpecularColor.x = 1.0f; pcMesh->vSpecularColor.y = 1.0f; pcMesh->vSpecularColor.z = 1.0f; pcMesh->vSpecularColor.w = 1.0f; } // // AMBIENT COLOR -------------------------------------------------- // if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_AMBIENT, (aiColor4D*)&pcMesh->vAmbientColor)) { pcMesh->vAmbientColor.x = 0.0f; pcMesh->vAmbientColor.y = 0.0f; pcMesh->vAmbientColor.z = 0.0f; pcMesh->vAmbientColor.w = 1.0f; } // // EMISSIVE COLOR ------------------------------------------------- // if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_EMISSIVE, (aiColor4D*)&pcMesh->vEmissiveColor)) { pcMesh->vEmissiveColor.x = 0.0f; pcMesh->vEmissiveColor.y = 0.0f; pcMesh->vEmissiveColor.z = 0.0f; pcMesh->vEmissiveColor.w = 1.0f; } // // Opacity -------------------------------------------------------- // if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_OPACITY,&pcMesh->fOpacity)) { pcMesh->fOpacity = 1.0f; } // // Shading Model -------------------------------------------------- // bool bDefault = false; if(AI_SUCCESS != aiGetMaterialInteger(pcMat,AI_MATKEY_SHADING_MODEL,(int*)&pcMesh->eShadingMode )) { bDefault = true; pcMesh->eShadingMode = aiShadingMode_Gouraud; } // // Shininess ------------------------------------------------------ // if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_SHININESS,&pcMesh->fShininess)) { // assume 15 as default shininess pcMesh->fShininess = 15.0f; } else if (bDefault)pcMesh->eShadingMode = aiShadingMode_Phong; // // Shininess strength ------------------------------------------------------ // if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_SHININESS_STRENGTH,&pcMesh->fSpecularStrength)) { // assume 1.0 as default shininess strength pcMesh->fSpecularStrength = 1.0f; } aiString szPath; aiTextureMapMode mapU(aiTextureMapMode_Wrap),mapV(aiTextureMapMode_Wrap); bool bib =false; if (pcSource->mTextureCoords[0]) { // // DIFFUSE TEXTURE ------------------------------------------------ // if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_DIFFUSE(0),&szPath)) { LoadTexture(&pcMesh->piDiffuseTexture,&szPath); aiGetMaterialInteger(pcMat,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0),(int*)&mapU); aiGetMaterialInteger(pcMat,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0),(int*)&mapV); } // // SPECULAR TEXTURE ------------------------------------------------ // if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_SPECULAR(0),&szPath)) { LoadTexture(&pcMesh->piSpecularTexture,&szPath); } // // OPACITY TEXTURE ------------------------------------------------ // if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_OPACITY(0),&szPath)) { LoadTexture(&pcMesh->piOpacityTexture,&szPath); } else { int flags = aiTextureFlags_IgnoreAlpha;//???0; aiGetMaterialInteger(pcMat,AI_MATKEY_TEXFLAGS_DIFFUSE(0),&flags); // try to find out whether the diffuse texture has any // non-opaque pixels. If we find a few, use it as opacity texture if ((pcMesh->piDiffuseTexture!=-1) && !(flags & aiTextureFlags_IgnoreAlpha) && HasAlphaPixels(pcMesh->piDiffuseTexture)) { int iVal; // NOTE: This special value is set by the tree view if the user // manually removes the alpha texture from the view ... if (AI_SUCCESS != aiGetMaterialInteger(pcMat,"no_a_from_d",0,0,&iVal)) { pcMesh->piOpacityTexture = pcMesh->piDiffuseTexture; // pcMesh->piOpacityTexture->AddRef(); } } } // // AMBIENT TEXTURE ------------------------------------------------ // if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_AMBIENT(0),&szPath)) { LoadTexture(&pcMesh->piAmbientTexture,&szPath); } // // EMISSIVE TEXTURE ------------------------------------------------ // if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_EMISSIVE(0),&szPath)) { LoadTexture(&pcMesh->piEmissiveTexture,&szPath); } // // Shininess TEXTURE ------------------------------------------------ // if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_SHININESS(0),&szPath)) { LoadTexture(&pcMesh->piShininessTexture,&szPath); } // // Lightmap TEXTURE ------------------------------------------------ // if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_LIGHTMAP(0),&szPath)) { LoadTexture(&pcMesh->piLightmapTexture,&szPath); } // // NORMAL/HEIGHT MAP ------------------------------------------------ // bool bHM = false; if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_NORMALS(0),&szPath)) { LoadTexture(&pcMesh->piNormalTexture,&szPath); } else { if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_HEIGHT(0),&szPath)) { LoadTexture(&pcMesh->piNormalTexture,&szPath); } else bib = true; bHM = true; } // normal/height maps are sometimes mixed up. Try to detect the type // of the texture automatically if (pcMesh->piNormalTexture!=-1) { HMtoNMIfNecessary(pcMesh->piNormalTexture, &pcMesh->piNormalTexture,bHM); } } // check whether a global background texture is contained // in this material. Some loaders set this value ... if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_GLOBAL_BACKGROUND_IMAGE,&szPath)) { // CBackgroundPainter::Instance().SetTextureBG(szPath.data); } // BUGFIX: If the shininess is 0.0f disable phong lighting // This is a workaround for some meshes in the DX SDK (e.g. tiny.x) // FIX: Added this check to the x-loader, but the line remains to // catch other loader doing the same ... if (0.0f == pcMesh->fShininess){ pcMesh->eShadingMode = aiShadingMode_Gouraud; } int two_sided = 0; aiGetMaterialInteger(pcMat,AI_MATKEY_TWOSIDED,&two_sided); pcMesh->twosided = (two_sided != 0); // check whether we have already a material using the same // shader. This will decrease loading time rapidly ... for (unsigned int i = 0; i < mr->GetAsset()->pcScene->mNumMeshes;++i) { if (mr->GetAsset()->pcScene->mMeshes[i] == pcSource) { break; } AssetHelper::MeshHelper* pc = mr->GetAsset()->apcMeshes[i]; if ((pcMesh->piDiffuseTexture !=-1 ? true : false) != (pc->piDiffuseTexture !=-1 ? true : false)) continue; if ((pcMesh->piSpecularTexture !=-1 ? true : false) != (pc->piSpecularTexture !=-1 ? true : false)) continue; if ((pcMesh->piAmbientTexture !=-1 ? true : false) != (pc->piAmbientTexture !=-1 ? true : false)) continue; if ((pcMesh->piEmissiveTexture !=-1 ? true : false) != (pc->piEmissiveTexture !=-1 ? true : false)) continue; if ((pcMesh->piNormalTexture !=-1 ? true : false) != (pc->piNormalTexture !=-1 ? true : false)) continue; if ((pcMesh->piOpacityTexture !=-1 ? true : false) != (pc->piOpacityTexture !=-1 ? true : false)) continue; if ((pcMesh->piShininessTexture !=-1 ? true : false) != (pc->piShininessTexture !=-1 ? true : false)) continue; if ((pcMesh->piLightmapTexture !=-1 ? true : false) != (pc->piLightmapTexture !=-1 ? true : false)) continue; if ((pcMesh->eShadingMode != aiShadingMode_Gouraud ? true : false) != (pc->eShadingMode != aiShadingMode_Gouraud ? true : false)) continue; if ((pcMesh->fOpacity != 1.0f ? true : false) != (pc->fOpacity != 1.0f ? true : false)) continue; if (pcSource->HasBones() != mr->GetAsset()->pcScene->mMeshes[i]->HasBones()) continue; // we can reuse this material if (pc->piEffect!=-1) { pcMesh->piEffect = pc->piEffect; pc->bSharedFX = pcMesh->bSharedFX = true; // pcMesh->piEffect->AddRef(); return 2; } } m_iShaderCount++; //if(mr->m_piDefaultEffect==-1) if(0) { typedef struct _D3DXFROMWINEMACRO { LPCSTR Name; LPCSTR Definition; } D3DXFROMWINEMACRO, *LPD3DXFROMWINEMACRO; D3DXFROMWINEMACRO sMacro[64]; // build macros for the HLSL compiler unsigned int iCurrent = 0; if (pcMesh->piDiffuseTexture!=-1) { sMacro[iCurrent].Name = "AV_DIFFUSE_TEXTURE"; sMacro[iCurrent].Definition = "1"; ++iCurrent; if (mapU == aiTextureMapMode_Wrap) sMacro[iCurrent].Name = "AV_WRAPU"; else if (mapU == aiTextureMapMode_Mirror) sMacro[iCurrent].Name = "AV_MIRRORU"; else // if (mapU == aiTextureMapMode_Clamp) sMacro[iCurrent].Name = "AV_CLAMPU"; sMacro[iCurrent].Definition = "1"; ++iCurrent; if (mapV == aiTextureMapMode_Wrap) sMacro[iCurrent].Name = "AV_WRAPV"; else if (mapV == aiTextureMapMode_Mirror) sMacro[iCurrent].Name = "AV_MIRRORV"; else // if (mapV == aiTextureMapMode_Clamp) sMacro[iCurrent].Name = "AV_CLAMPV"; sMacro[iCurrent].Definition = "1"; ++iCurrent; } if (pcMesh->piSpecularTexture!=-1) { sMacro[iCurrent].Name = "AV_SPECULAR_TEXTURE"; sMacro[iCurrent].Definition = "1"; ++iCurrent; } if (pcMesh->piAmbientTexture!=-1) { sMacro[iCurrent].Name = "AV_AMBIENT_TEXTURE"; sMacro[iCurrent].Definition = "1"; ++iCurrent; } if (pcMesh->piEmissiveTexture!=-1) { sMacro[iCurrent].Name = "AV_EMISSIVE_TEXTURE"; sMacro[iCurrent].Definition = "1"; ++iCurrent; } char buff[32]; if (pcMesh->piLightmapTexture!=-1) { sMacro[iCurrent].Name = "AV_LIGHTMAP_TEXTURE"; sMacro[iCurrent].Definition = "1"; ++iCurrent; int idx; if(AI_SUCCESS == aiGetMaterialInteger(pcMat,AI_MATKEY_UVWSRC_LIGHTMAP(0),&idx) && idx >= 1 && pcSource->mTextureCoords[idx]) { sMacro[iCurrent].Name = "AV_TWO_UV"; sMacro[iCurrent].Definition = "1"; ++iCurrent; sMacro[iCurrent].Definition = "IN.TexCoord1"; } else sMacro[iCurrent].Definition = "IN.TexCoord0"; sMacro[iCurrent].Name = "AV_LIGHTMAP_TEXTURE_UV_COORD"; ++iCurrent;float f= 1.f; aiGetMaterialFloat(pcMat,AI_MATKEY_TEXBLEND_LIGHTMAP(0),&f); stx_snprintf(buff,32,"%f",f); sMacro[iCurrent].Name = "LM_STRENGTH"; sMacro[iCurrent].Definition = buff; ++iCurrent; } if ((pcMesh->piNormalTexture!=-1) && !bib) { sMacro[iCurrent].Name = "AV_NORMAL_TEXTURE"; sMacro[iCurrent].Definition = "1"; ++iCurrent; } if (pcMesh->piOpacityTexture!=-1) { sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE"; sMacro[iCurrent].Definition = "1"; ++iCurrent; if (pcMesh->piOpacityTexture == pcMesh->piDiffuseTexture) { sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE_REGISTER_MASK"; sMacro[iCurrent].Definition = "a"; ++iCurrent; } else { sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE_REGISTER_MASK"; sMacro[iCurrent].Definition = "r"; ++iCurrent; } } if (pcMesh->eShadingMode != aiShadingMode_Gouraud && !mr->m_sOptions.bNoSpecular) { sMacro[iCurrent].Name = "AV_SPECULAR_COMPONENT"; sMacro[iCurrent].Definition = "1"; ++iCurrent; if (pcMesh->piShininessTexture!=-1) { sMacro[iCurrent].Name = "AV_SHININESS_TEXTURE"; sMacro[iCurrent].Definition = "1"; ++iCurrent; } } if (1.0f != pcMesh->fOpacity) { sMacro[iCurrent].Name = "AV_OPACITY"; sMacro[iCurrent].Definition = "1"; ++iCurrent; } if( pcSource->HasBones()) { sMacro[iCurrent].Name = "AV_SKINNING"; sMacro[iCurrent].Definition = "0";//???"1"; ++iCurrent; } /* // If a cubemap is active, we'll need to lookup it for calculating // a physically correct reflection if (CBackgroundPainter::TEXTURE_CUBE == CBackgroundPainter::Instance().GetMode()) { sMacro[iCurrent].Name = "AV_SKYBOX_LOOKUP"; sMacro[iCurrent].Definition = "1"; ++iCurrent; }*/ sMacro[iCurrent].Name = 0; sMacro[iCurrent].Definition = 0; //Construct defines from sMacro and compine with mr->m_szMaterialShader string std::string extra; unsigned int iiCurrent = 0; while ((sMacro[iiCurrent].Name != 0)&& (sMacro[iiCurrent].Definition != 0)) { extra.append("#define "); extra.append(sMacro[iiCurrent].Name); extra.append(" "); extra.append(sMacro[iiCurrent].Definition); extra.append(";\n"); iiCurrent++; } // compile the shader #if 1 const char *ShaderName = mr->m_szShaderName.c_str(); //LOG_PRINT("ShaderName=%s\n", ShaderName); ShaderID shd=MeshRendererShadersFactory::GetShader(ShaderName, "main", "main"); //LOG_PRINT("m_SimpleShader=%s\n", m_SimpleShader); #elif 0 const char *m_SimpleShader = MeshRendererShadersFactory::GetShader("SimpleShader"); mr->m_piDefaultEffect=IRenderer::GetRendererInstance()->addHLSLShader( m_SimpleShader, "main", "main");//D1??? #elif 0 mr->m_piDefaultEffect=IRenderer::GetRendererInstance()->addHLSLShader( g_szMaterialShader.c_str(), "MaterialVShader_D1", "MaterialPShaderSpecular_D1",0,0,extra.c_str());//D1??? #elif 0 mr->m_piDefaultEffect=IRenderer::GetRendererInstance()->addHLSLShader( g_szDefaultShader.c_str(), "DefaultVShader", "DefaultPShaderSpecular_D1",0,0,extra.c_str());//D1??? #endif //mr->m_piMaterialEffect=mr->m_piDefaultEffect; #if 1 FormatDesc Fmt[] = { #if 0 { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 }, { 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 }, { 0, 28, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 }, { 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 }, { 0, 52, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 }, { 0, 60, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 }, { 0, 68, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 }, { 0, 72, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0 }, #else {0, TYPE_VERTEX, FORMAT_FLOAT, 3}, {0, TYPE_TEXCOORD, FORMAT_FLOAT, 2}, /* {0, TYPE_NORMAL, FORMAT_FLOAT, 3}, {0, TYPE_TEXCOORD, FORMAT_FLOAT, 3},//??? {0, TYPE_TEXCOORD, FORMAT_FLOAT, 2}, {0, TYPE_TEXCOORD, FORMAT_FLOAT, 4},//??? {0, TYPE_TEXCOORD, FORMAT_FLOAT, 4}//??? */ #endif }; //mr->m_DefaultVertexDecl = IRenderer::GetRendererInstance()->addVertexFormat(Fmt, elementsOf(Fmt), mr->m_piDefaultEffect);//??? #endif } if(0)//-1== mr->m_piMaterialEffect) { // get the name of the material and use it in the log message if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_NAME,&szPath) && '\0' != szPath.data[0]) { std::string sz = "[ERROR] Unable to load material: "; sz.append(szPath.data); //CLogDisplay::Instance().AddEntry(sz); } else { //CLogDisplay::Instance().AddEntry("Unable to load material: UNNAMED"); } return 0; } else { /* // use Fixed Function effect when working with shaderless cards if( mr->m_sCaps.PixelShaderVersion < D3DPS_VERSION(2,0)) { ////LOG_PRINT("mr->m_piDefaultEffect=%d\n",mr->m_piDefaultEffect); IRenderer::GetRendererInstance()->SetTechnique( MaterialFX_FFh); }*/ } // if( piBuffer) piBuffer->Release(); LOG_FNLN; LOG_PRINT("ShaderName=%d\n",mr->m_szShaderName.c_str()); ShaderID shd = MeshRendererShadersFactory::GetShader(mr->m_szShaderName.c_str(), "main", "main"); IRenderer::GetRendererInstance()->setShader(shd); // now commit all constants to the shader // // This is not necessary for shared shader. Shader constants for // shared shaders are automatically recommited before the shader // is being used for a particular mesh if (1.0f != pcMesh->fOpacity) { //???IRenderer::GetRendererInstance()->SetFloat("TRANSPARENCY",pcMesh->fOpacity); } if (pcMesh->eShadingMode != aiShadingMode_Gouraud && !mr->m_sOptions.bNoSpecular) { IRenderer::GetRendererInstance()->SetFloat("SPECULARITY",pcMesh->fShininess);//??? IRenderer::GetRendererInstance()->SetFloat("SPECULAR_STRENGTH",pcMesh->fSpecularStrength); } IRenderer::GetRendererInstance()->SetVector("DIFFUSE_COLOR",&pcMesh->vDiffuseColor); //IRenderer::GetRendererInstance()->SetVector("SPECULAR_COLOR",&pcMesh->vSpecularColor); IRenderer::GetRendererInstance()->SetVector("AMBIENT_COLOR",&pcMesh->vAmbientColor); IRenderer::GetRendererInstance()->SetVector("EMISSIVE_COLOR",&pcMesh->vEmissiveColor); if (pcMesh->piDiffuseTexture!=-1) { IRenderer::GetRendererInstance()->SetTexture("DIFFUSE_SAMPLER",pcMesh->piDiffuseTexture); } if (pcMesh->piOpacityTexture!=-1) { IRenderer::GetRendererInstance()->SetTexture("OPACITY_SAMPLER",pcMesh->piOpacityTexture); } if (pcMesh->piSpecularTexture!=-1) { IRenderer::GetRendererInstance()->SetTexture("SPECULAR_SAMPLER",pcMesh->piSpecularTexture); } if (pcMesh->piAmbientTexture!=-1) { IRenderer::GetRendererInstance()->SetTexture("AMBIENT_SAMPLER",pcMesh->piAmbientTexture); } if (pcMesh->piEmissiveTexture!=-1) { IRenderer::GetRendererInstance()->SetTexture("EMISSIVE_SAMPLER",pcMesh->piEmissiveTexture); } if (pcMesh->piNormalTexture!=-1) { IRenderer::GetRendererInstance()->SetTexture("NORMAL_SAMPLER",pcMesh->piNormalTexture); } if (pcMesh->piShininessTexture!=-1) { IRenderer::GetRendererInstance()->SetTexture("SHININESS_SAMPLER",pcMesh->piShininessTexture); } if (pcMesh->piLightmapTexture!=-1) { IRenderer::GetRendererInstance()->SetTexture("LIGHTMAP_SAMPLER",pcMesh->piLightmapTexture); } /* if (CBackgroundPainter::TEXTURE_CUBE == CBackgroundPainter::Instance().GetMode()){ IRenderer::GetRendererInstance()->SetTexture("lw_tex_envmap",CBackgroundPainter::Instance().GetTexture()); }*/ #endif return 1; }
void Tile::SetTexture( std::string fileName ) { LoadTexture(fileName); SetColour(fileName); }
void CreateHeightFieldMesh (NewtonCollision* collision, Entity* ent) { int width; int height; dFloat hScale; dFloat vScale; unsigned short* elevations; NewtonCollisionInfoRecord collisionInfo; // keep the compiler happy memset (&collisionInfo, 0, sizeof (NewtonCollisionInfoRecord)); NewtonCollisionGetInfo (collision, &collisionInfo); // get the info from the collision mesh and create a visual mesh width = collisionInfo.m_heightField.m_width; height = collisionInfo.m_heightField.m_height; elevations = collisionInfo.m_heightField.m_elevation; vScale = collisionInfo.m_heightField.m_verticalScale; hScale = collisionInfo.m_heightField.m_horizonalScale; // allocate space to store vertex data ent->m_vertexCount = width * height; ent->m_vertex = (dFloat*) malloc (3 * width * height * sizeof (dFloat)); ent->m_normal = (dFloat*) malloc (3 * width * height * sizeof (dFloat)); ent->m_uv = (dFloat*) malloc (2 * width * height * sizeof (dFloat)); // scan the height field and convert every cell into two triangles for (int z = 0; z < height; z ++) { int z0; int z1; z0 = ((z - 1) < 0) ? 0 : z - 1; z1 = ((z + 1) > (height - 1)) ? height - 1 : z + 1 ; for (int x = 0; x < width; x ++) { int x0; int x1; x0 = ((x - 1) < 0) ? 0 : x - 1; x1 = ((x + 1) > (width - 1)) ? width - 1 : x + 1 ; dVector p0 (hScale * x0, elevations[z * width + x1] * vScale, hScale * z); dVector p1 (hScale * x1, elevations[z * width + x0] * vScale, hScale * z); dVector x10 (p1 - p0); dVector q0 (hScale * x, elevations[z0 * width + x] * vScale, hScale * z0); dVector q1 (hScale * x, elevations[z1 * width + x] * vScale, hScale * z1); dVector z10 (q1 - q0); dVector normal (z10 * x10); normal = normal.Scale (dSqrt (1.0f / (normal % normal))); dVector point (hScale * x, elevations[z * width + x] * vScale, hScale * z); ent->m_vertex[(z * width + x) * 3 + 0] = point.m_x; ent->m_vertex[(z * width + x) * 3 + 1] = point.m_y; ent->m_vertex[(z * width + x) * 3 + 2] = point.m_z; ent->m_normal[(z * width + x) * 3 + 0] = normal.m_x; ent->m_normal[(z * width + x) * 3 + 1] = normal.m_y; ent->m_normal[(z * width + x) * 3 + 2] = normal.m_z; ent->m_uv[(z * width + x) * 2 + 0] = x * TEXTURE_SCALE; ent->m_uv[(z * width + x) * 2 + 1] = z * TEXTURE_SCALE; } } // since the bitmap sample is 256 x 256, i fix into a single 16 bit index vertex array with ent->m_subMeshCount = 1; ent->m_subMeshes = (Entity::SubMesh*) malloc (sizeof (Entity::SubMesh)); // allocate space to the index list ent->m_subMeshes[0].m_textureHandle = LoadTexture ("grassAndDirt.tga"); ent->m_subMeshes[0].m_indexCount = (width - 1) * (height - 1) * 6; ent->m_subMeshes[0].m_indexArray = (unsigned short*) malloc (ent->m_subMeshes[0].m_indexCount * sizeof (unsigned short)); // now following the grid pattern and create and index list int index; int vertexIndex; index = 0; vertexIndex = 0; for (int z = 0; z < height - 1; z ++) { vertexIndex = z * width; for (int x = 0; x < width - 1; x ++) { ent->m_subMeshes[0].m_indexArray[index + 0] = GLushort (vertexIndex); ent->m_subMeshes[0].m_indexArray[index + 1] = GLushort (vertexIndex + width); ent->m_subMeshes[0].m_indexArray[index + 2] = GLushort (vertexIndex + 1); index += 3; ent->m_subMeshes[0].m_indexArray[index + 0] = GLushort (vertexIndex + 1); ent->m_subMeshes[0].m_indexArray[index + 1] = GLushort (vertexIndex + width); ent->m_subMeshes[0].m_indexArray[index + 2] = GLushort (vertexIndex + width + 1); index += 3; vertexIndex ++; } } // Optimize the mesh for hardware rendering if possible ent->OptimizeMesh(); /* dVector boxP0; dVector boxP1; // get the position of the aabb of this geometry dMatrix matrix (ent->m_curRotation, ent->m_curPosition); NewtonCollisionCalculateAABB (collision, &matrix[0][0], &boxP0.m_x, &boxP1.m_x); // place the origin of the visual mesh at the center of the height field matrix.m_posit = (boxP0 + boxP1).Scale (-0.5f); matrix.m_posit.m_w = 1.0f; ent->m_curPosition = matrix.m_posit; ent->m_prevPosition = matrix.m_posit; // create the level rigid body body = NewtonCreateBody(world, collision); // release the collision tree (this way the application does not have to do book keeping of Newton objects NewtonReleaseCollision (world, collision); // save the pointer to the graphic object with the body. NewtonBodySetUserData (body, ent); // set the global position of this body NewtonBodySetMatrix (body, &matrix[0][0]); // set the destructor for this object // NewtonBodySetDestructorCallback (body, Destructor); // get the position of the aabb of this geometry NewtonCollisionCalculateAABB (collision, &matrix[0][0], &boxP0.m_x, &boxP1.m_x); // add some extra padding the world size boxP0.m_x -= 10.0f; boxP0.m_y -= 10.0f; boxP0.m_z -= 10.0f; boxP1.m_x += 10.0f; boxP1.m_y += 400.0f; boxP1.m_z += 10.0f; // set the world size NewtonSetWorldSize (world, &boxP0.m_x, &boxP1.m_x); return body; */ }
/* simple display function for GLUT */ void display(void) { GLfloat mat_red[] = {1.0, 0.0, 0.0, 0.0}; GLfloat mat_green[] = {0.0, 1.0, 0.0, 0.0}; GLfloat mat_blue[] = {0.0, 0.0, 1.0, 0.0}; GLfloat mat_black[] = {0.0, 0.0, 0.0, 0.0}; /* light placed at infinity in the direcion <10,10,10>*/ GLfloat light_position[] = {light1_x, light1_y, light1_z, 0.0}; /* this will be your shadow matrix. You need to specify what this contains. * OpenGL has a funky ordering for rows and columns * use this ordering for rows and columns. The identity matrix with Mr,c = M3,3 = 0; */ m[0]= 1; m[4]= 0; m[8] = -(light1_x/light1_z); m[12]= 0; m[1]= 0; m[5]= 1; m[9] = -(light1_y/light1_z); m[13]= 0; m[2]= 0; m[6]= 0; m[10]= 0; m[14]= 0; m[3]= 0; m[7]= 0; m[11]= 0; m[15]= 1; /* replaces the matrix in the top of the stack with the identity matrix */ glLoadIdentity(); /* multiplies the current matrix by a tranformation matrix that puts the eyepoint * at <eye_x,eye_y,eye_z>, center of the image at <0,0,0>, * and up vector of <0,0,1> (z-axis). */ gluLookAt(eye_x,eye_y,eye_z, 0,0,0, 0,0,1); /* move light0 to 'light_position' */ glLightfv(GL_LIGHT0, GL_POSITION, light_position); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* draw checkered floor */ /* enable textures */ glEnable(GL_TEXTURE_2D); /* set texture mode */ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); /* set current texture to 'texName' */ glBindTexture(GL_TEXTURE_2D, texName); /* to load texture image */ LoadTexture(); /* draw polygon floor */ glBegin(GL_QUADS); /* z=-0.01 so that the floor doesn't overlap your shadows * glTexCoord fixes a point in the texture to the vertex that follows it. */ glTexCoord2f(0.0, 0.0); glVertex3f(-4.0, -4.0, -0.01); glTexCoord2f(0.0, 1.0); glVertex3f(-4.0, 4.0, -0.01); glTexCoord2f(1.0, 1.0); glVertex3f( 4.0, 4.0, -0.01); glTexCoord2f(1.0, 0.0); glVertex3f( 4.0, -4.0, -0.01); glEnd(); glFlush(); /* disable textures so that we can draw other polys w/o the texture */ glDisable(GL_TEXTURE_2D); /* draw unit cone of radius of 1 and height 1 */ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_blue); /* draw all objects with colors */ draw_scene(0); /* draw all objects shadows */ draw_scene(1); glFlush(); }
BouncyBee::BouncyBee(TileMap *tm, SDL_Renderer *renderTarget_) : Enemy(tm, renderTarget_) { dx = 0; dy = 0; targX = 860; targY = 154; maxSpeed = 1.8; moveSpeed = maxSpeed; maxFallSpeed = 0; fallSpeed = maxFallSpeed; width = 52; height = 40; cwidth = 52; cheight = 40; maxHealth = 1; health = maxHealth; damage = 1; dead = false; flinching = false; active = false; triggerState = false; triggerBox = NULL; //load sprites numAnimations = 2; frameNumbers = NULL; frameNumbers = new int[numAnimations]; int tempNums[2] = {1, 2}; for (int i=0; i<numAnimations; i++) frameNumbers[i] = tempNums[i]; sprite_rects = NULL; sprite_rects = new SDL_Rect*[numAnimations]; for (int i=0; i<numAnimations; i++) { sprite_rects[i] = NULL; sprite_rects[i] = new SDL_Rect[frameNumbers[i]]; //printf("DEBUG: frameNumbers[%d] = %d\n", i, frameNumbers[i]); } animationTexture = LoadTexture("./Resources/Sprites/Enemies/GoS_BouncyBeeSprites.bmp", renderTarget); if (animationTexture) printf("DEBUG: Loaded bouncy bee textures\n"); for (int i=0; i<numAnimations; i++) { for (int j=0; j<frameNumbers[i]; j++) { sprite_rects[i][j].x = j*width; sprite_rects[i][j].y = i*height; sprite_rects[i][j].w = width; sprite_rects[i][j].h = height; } } currentAction = IDLE; animation.setFrames(animationTexture, sprite_rects[currentAction], frameNumbers[currentAction]); animation.setDelay(-1); width = sprite_rects[currentAction][animation.getFrame()].w; bee_sound = new AudioPlayer("./Resources/SFX/BMOGame_BouncyBeeIntro.wav", false); right = true; facingRight = right; }
void World::PlaceBlocks() { Entity * projectile = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 0.0f, TILEHEIGHT * 6.0, -4.0f, 0.0f); projectiles.push_back(projectile); Entity * projectile2 = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 0.0f, TILEHEIGHT * 7.0, -4.0f, 0.0f); projectiles.push_back(projectile2); for ( size_t j = 0; j < RAINDROPS; j++ ) { Entity * raindrop = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 0.0f, TILEHEIGHT * 4.0, 0.0, -3.33); rain.push_back(raindrop); } float randX, randY; for ( size_t i = 0; i < BLOCKS; i++ ) { randX = (rand() % 16 - 8) / 10.0; randY = (rand() % 1600) / 10.0; Entity * cloud = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 0.0, TILEHEIGHT * 2, randX, randY); blocks.push_back(cloud); } Entity * minus1 = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 3.0f, TILEHEIGHT * 0.0, 0.05, 0.0); statics.push_back(minus1); Entity * plus1 = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 3.0f, TILEHEIGHT * 1.0, 0.05, 0.0); statics.push_back(plus1); // bubbles Entity * outofbounds = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 3.0f, TILEHEIGHT * 2.0, 0.05, 0.0); statics.push_back(outofbounds); Entity * outofbounds2 = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 3.0f, TILEHEIGHT * 2.0, 0.05, 0.0); statics.push_back(outofbounds2); // miniatures Entity * outofbounds1 = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 1.0f, TILEHEIGHT * 1.0, 0.05, 0.0); statics.push_back(outofbounds1); Entity * outofbounds3 = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 1.0f, TILEHEIGHT * 1.0, 0.05, 0.0); statics.push_back(outofbounds3); Entity * panelRight = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 10.0f, TILEHEIGHT * 0.0, 0.93, 0.0); panelRight->height = TILEHEIGHT * 7.0; statics.push_back(panelRight); Entity * panelLeft = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 11.0f, TILEHEIGHT * 0.0, -0.93, 0.0); panelLeft->height = TILEHEIGHT * 7.0; statics.push_back(panelLeft); // Menu items Entity * players = new Entity(LoadTexture(menuSheet), TILEWIDTH * 0.0f, TILEHEIGHT * 0.2, 0.0f, 0.0f); players->width = TILEWIDTH * 10.0; players->height = TILEHEIGHT * 8.0; menuItems.push_back(players); Entity * s = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 3.0f, TILEHEIGHT * 3.0, 0.0, 0.0); menuItems.push_back(s); Entity * s1 = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 3.0f, TILEHEIGHT * 4.0, 0.0, 0.0); menuItems.push_back(s1); Entity * decor = new Entity(LoadTexture(menuSheet), TILEWIDTH * 10.5f, TILEHEIGHT * 0.0, 0.94, 0.0); decor->height = TILEHEIGHT * 10.0f; decor->width = TILEWIDTH * 3.0f; menuItems.push_back(decor); Entity * v = new Entity(LoadTexture(spriteSheet), TILEWIDTH * 10.0f, TILEHEIGHT * 7.0, 0.0, 0.4); v->width = TILEWIDTH * 3.5f; v->height = TILEHEIGHT * 2.0f; menuItems.push_back(v); // Buttons for ( int k = 0; k < 6; k++ ) { Entity * b = new Entity(LoadTexture(spriteSheet), TILEWIDTH * (4.0f + k), TILEHEIGHT * 6.0, -0.95f, 0.0f); buttons.push_back(b); } for ( int l = 0; l < 6; l++ ) { Entity * b2 = new Entity(LoadTexture(spriteSheet), TILEWIDTH * (4.0f + l), TILEHEIGHT * 8.0, 0.95, 0.0f); buttons.push_back(b2); } }
int main(int argc, char *argv[]) { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("Simon Project 1", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL); // SDL Window, title, position,position,width,height, type of graphics? SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); glClearColor(0.5, 0.5, 0.0, .9);//Green-color //Setup glViewport(0, 0, 800, 600); glMatrixMode(GL_PROJECTION); glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0); glMatrixMode(GL_MODELVIEW); glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0); //LoadTextures GLuint paddleID = LoadTexture("pngs/paddle.png"); GLuint ballID = LoadTexture("pngs/ball.png"); GLuint leftwinID = LoadTexture24("pngs/leftwin.png"); GLuint rightwinID = LoadTexture24("pngs/rightwin.png"); //Init Entities initBall(ballID); initPaddleLeft(paddleID); initPaddleRight(paddleID); initRightwin(rightwinID); initLeftwin(leftwinID); //Time float lastFrameTicks = 0.0; SDL_Event event; bool done = false; while (!done) { glClear(GL_COLOR_BUFFER_BIT); float ticks = (float)SDL_GetTicks() / 1000.0f; float elapsed = ticks - lastFrameTicks; lastFrameTicks = ticks; //Read Input and Update World while (SDL_PollEvent(&event)) { // a lot of events could cue up, no?, could also get all keyboard states and check for those. I think I like that better. - specially for pong if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) { done = true; } } const Uint8 *keys = SDL_GetKeyboardState(NULL); if (keys[SDL_SCANCODE_UP]) { paddleright.y += elapsed*paddleright.velocity_y; if (paddleright.y > (1 - .2)){ paddleright.y = 1 - .2; } } else if (keys[SDL_SCANCODE_DOWN]) { paddleright.y -= elapsed*paddleright.velocity_y; if (paddleright.y < (-1 + .2)){ paddleright.y = -1 + .2; } } if (keys[SDL_SCANCODE_W]) { paddleleft.y += elapsed*paddleleft.velocity_y; if (paddleleft.y >(1 - .2)){ paddleleft.y = 1 - .2; } } else if (keys[SDL_SCANCODE_S]) { paddleleft.y -= elapsed*paddleleft.velocity_y; if (paddleleft.y < (-1 + .2)){ paddleleft.y = -1 + .2; } } updateBall(elapsed); isWin(); //Render World ball.Draw(); paddleleft.Draw(); paddleright.Draw(); if (rightwin) { endGame(); rightwinE.Draw(); } if (leftwin) { endGame(); leftwinE.Draw(); } SDL_GL_SwapWindow(displayWindow);//Swaps old modelview with new one? } SDL_Quit(); return 0; }
void Element::InitializeElements() { _texture = LoadTexture("../../../Assets/Gui/box.png"); }
Texture::Texture(const char *filename) { m_textureID = LoadTexture(filename, &m_width, &m_height); }
int main(int argc, char *argv[]) { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("Shunman Tse Assignment 1 - My Scene", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); bool done = false; SDL_Event event; // Basic setup for the rendering pipeline glViewport(0, 0, 800, 600); glMatrixMode(GL_PROJECTION); glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0); glMatrixMode(GL_MODELVIEW); // Load Textures GLuint spinningLollipop = LoadTexture("lollipopRed.png"); GLuint asteroid = LoadTexture("meteorBig.png"); GLuint player = LoadTexture("player.png"); GLuint enemy = LoadTexture("enemyShip.png"); // Set up timing variables float lastFrameTicks = 0.0f; float starRotation = 0.0f; float asteroidRotation = 0.0f; float asteroid2Rotation = 45.0f; while (!done) { while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) { done = true; } } // Keeping time in the while loop float ticks = (float)SDL_GetTicks()/ 1000.0f; float elapsed = ticks - lastFrameTicks; lastFrameTicks = ticks; // Clear screen glClearColor(0.5f, 0.4f, 0.7f, 1.0f); // Purple Screen //glClearColor(1.0f, 1.0f, 1.0f, 1.0f); // White Screen glClear(GL_COLOR_BUFFER_BIT); //-- Natural Elements // Spinning Candy Star (top left) starRotation += (elapsed * 20.0f); DrawSprite(spinningLollipop, -1.1, 0.8, starRotation, 0.3); // Asteroids asteroidRotation += (elapsed * 30.0f); DrawSprite(asteroid, 0.0, -0.4, asteroidRotation, 0.4); asteroid2Rotation += (elapsed * 35.0f); DrawSprite(asteroid, 0.6, -0.2, asteroid2Rotation, 0.3); DrawSprite(asteroid, -0.6, -0.2, asteroid2Rotation, 0.3); DrawSprite(asteroid, 1.2, -0.2, 0, 0.5); DrawSprite(asteroid, -1.2, -0.2, 180, 0.5); //-- Player Forces // 2 Player Ships (bottom) DrawSprite(player, -0.5, -0.8, 0, 0.2); DrawSprite(player, 0.5, -0.8, 0, 0.2); //-- Enemy Forces // 5 Enemy Ships (top) DrawSprite(enemy, 0.0, 0.0, 0, 0.2); DrawSprite(enemy, 0.2, 0.2, 0, 0.2); DrawSprite(enemy, -0.2, 0.2, 0, 0.2); DrawSprite(enemy, 0.6, 0.4, 0, 0.2); DrawSprite(enemy, -0.6, 0.4, 0, 0.2); // Rainbow Capital Ship (triangle with vertex colors) // Resize the ship accordingly glLoadIdentity(); glScalef(0.1, 0.1, 0.1); glTranslatef(0.0, 6.5, 0.0); // Array of vertex position data GLfloat capitalShip [] = { 0.0, 3.0, 1.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0, -2.0, 0.0, -3.0, -1.0, -2.0, -2.0, 1.0, -3.0, 2.0, -1.0, 3.0 }; // 10 points glVertexPointer(2, GL_FLOAT, 0, capitalShip); glEnableClientState(GL_VERTEX_ARRAY); // Array of Vertex Color Data GLfloat capitalShipColors[] = { 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.5, 0.5, 0.5, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0 }; glColorPointer(3, GL_FLOAT, 0, capitalShipColors); glEnableClientState(GL_COLOR_ARRAY); glDrawArrays(GL_POLYGON, 0, 10); glDisableClientState(GL_COLOR_ARRAY); SDL_GL_SwapWindow(displayWindow); } SDL_Quit(); return 0; }
int main(int argc, char *argv[]) { // Initializing and loading variables SDL_Window *window = nullptr; SDL_Renderer *renderTarget = nullptr; int currentTime = 0; int prevTime = 0; float delta = 0.0f; const Uint8 *keyState; SDL_Rect camerRect = { 0, 0, 640, 480 }; int levelWidth, levelHeight; SDL_Init(SDL_INIT_VIDEO); if(IMG_Init(imgFlags) != imgFlags) std::cout << "Error: " << IMG_GetError() << std::endl; int data = 10; window = SDL_CreateWindow("SDL CodingMadeEasy Series", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_SHOWN); renderTarget = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); Player player1(renderTarget, "image.png", 0, 0, 3, 4); Player player2(renderTarget, "image.png", 500, 300, 3, 4); SDL_Texture *texture = LoadTexture("rect.png", renderTarget); SDL_QueryTexture(texture, NULL, NULL, &levelWidth, &levelHeight); bool isRunning = true; SDL_Event ev; while(isRunning) { prevTime = currentTime; currentTime = SDL_GetTicks(); delta = (currentTime - prevTime) / 1000.0f; while(SDL_PollEvent(&ev) != 0) { // Getting the events if(ev.type == SDL_QUIT) isRunning = false; } keyState = SDL_GetKeyboardState(NULL); player1.Update(delta, keyState); player2.Update(delta, keyState); camerRect.x = player1.GetOriginX() - 320; camerRect.y = player1.GetOriginY() - 240; if(camerRect.x < 0) camerRect.x = 0; if(camerRect.y < 0) camerRect.y = 0; if(camerRect.x + camerRect.w >= levelWidth) camerRect.x = levelWidth - 640; if(camerRect.y + camerRect.h >= levelHeight) camerRect.y = levelHeight - 480; player1.IntersectsWith(player2); SDL_RenderClear(renderTarget); SDL_RenderCopy(renderTarget, texture, &camerRect, NULL); player1.Draw(renderTarget, camerRect); player2.Draw(renderTarget, camerRect); SDL_RenderPresent(renderTarget); } SDL_DestroyWindow(window); SDL_DestroyRenderer(renderTarget); SDL_DestroyTexture(texture); texture = nullptr; window = nullptr; renderTarget = nullptr; IMG_Quit(); SDL_Quit(); return 0; }
void ResourceManager::LoadResource() { LoadTexture(); LoadSound(); m_bIsReady = true; }
Texture3D::Texture3D(int width, int height, int depth, const char *data, Format format, int stride /*= -1*/, Type type) : _id(0) { SetGLType(type); LoadTexture(width, height, depth, data, format, stride); }
int main(int argc, char *argv[]) { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); #ifdef _WINDOWS glewInit(); #endif SDL_Event event; bool done = false; ShaderProgram program(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl"); glBlendFunc(GL_SRC_ALPHA, GL_ONE); GLuint blank = LoadTexture("blank.png"); Matrix projectionMatrix; Matrix modelMatrix; Matrix viewMatrix; projectionMatrix.setOrthoProjection(-1.7777f, 1.7777f, -1.0f, 1.0f, -1.0f, 1.0f); float portWidth = 640; float portHeight = 320; float lastFrameTicks = 0.0f; float ballPosx = .0f; float ballPosy = 0.0f; float ballAngle = 180.0f; float ballSpeed = 2.0f; float paddlePos1 = 0.0f; float paddlePos2 = 0.0f; float paddleSpeed = 0.0015f; float server = 0.0f; while (!done) { while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) { done = true; } } const Uint8 *keys = SDL_GetKeyboardState(NULL); //player1 input if (keys[SDL_SCANCODE_W]){ paddlePos1 += paddleSpeed; if (paddlePos1 + 0.2 >= 1) paddlePos1 = 1 - 0.2; } else if (keys[SDL_SCANCODE_S]){ paddlePos1 += -1 * paddleSpeed; if (paddlePos1 - 0.2 <= -1) paddlePos1 = -1 + 0.2; } //player2 input if (keys[SDL_SCANCODE_O]){ paddlePos2 += paddleSpeed; if (paddlePos2 + 0.2 >= 1) paddlePos2 = 1 - 0.2; } else if (keys[SDL_SCANCODE_L]){ paddlePos2 += -1 * paddleSpeed; if (paddlePos2 - 0.2 <= -1) paddlePos2 = -1 + 0.2; } //update float ticks = (float)SDL_GetTicks() / 1000.0f; float elapsed = ticks - lastFrameTicks; lastFrameTicks = ticks; if (abs(ballAngle) - 90 <= 20 && abs(ballAngle) -90 >= -20) ballSpeed = 4; else ballSpeed = 2; float dist = elapsed*ballSpeed; ballPosx += cos(ballAngle * PI / 180)*dist; ballPosy += sin(ballAngle * PI / 180)*dist; //collison test if (ballPosy >= 1){ ballAngle = -1 * ballAngle; ballPosy = 1; } else if (ballPosy <= -1){ ballAngle = -1 * ballAngle; ballPosy = -1; } if (ballPosx <= -1.5 && ballPosx >= -1.6 && ballPosy <= paddlePos1 + 0.2 && ballPosy >= paddlePos1 - 0.2){ if (ballPosy > paddlePos1 + 0.1 || ballPosy < paddlePos1 - 0.1){ if (ballAngle > 0) ballAngle = 180 - ballAngle + 20; else ballAngle = -180 - ballAngle - 20; } else if (ballPosy > paddlePos1 + 0.175 || ballPosy < paddlePos1 - 0.175){ if (ballAngle > 0) ballAngle = 180 - ballAngle + 15; else ballAngle = -180 - ballAngle - 15; } else { if (ballAngle > 0) ballAngle = 180 - ballAngle; else ballAngle = -180 - ballAngle; } ballPosx = -1.5; } else if (ballPosx >= 1.5 && ballPosx <= 1.6 && ballPosy <= paddlePos2 + 0.2 && ballPosy >= paddlePos2 - 0.2){ if (ballPosy > paddlePos2 + 0.1 || ballPosy < paddlePos2 - 0.1){ if (ballAngle > 0) ballAngle = 180 - ballAngle - 20; else ballAngle = -180 - ballAngle + 20; } else if (ballPosy > paddlePos2 + 0.175 || ballPosy < paddlePos2 - 0.175){ if (ballAngle > 0) ballAngle = 180 - ballAngle - 15; else ballAngle = -180 - ballAngle + 15; } else { if (ballAngle > 0) ballAngle = 180 - ballAngle; else ballAngle = -180 - ballAngle; } ballPosx = 1.5; } //victory condition test if (ballPosx <= -1.8){ ballPosx = 0; ballPosy = 0; ballAngle = 0; paddlePos1 = 0; paddlePos2 = 0; server = 1; } else if (ballPosx >= 1.8){ ballPosx = 0; ballPosy = 0; ballAngle = 180; paddlePos1 = 0; paddlePos2 = 0; server = -1; } //render glViewport(0, 0, portWidth, portHeight); float verticesBall[] = { -0.03f, -0.03f, 0.03f, 0.03f, -0.03f, 0.03f, 0.03f, 0.03f, -0.03f, -0.03f, 0.03f, -0.03f }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, verticesBall); glEnableVertexAttribArray(program.positionAttribute); float texCoordsBall[] = { 0.0, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0 }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoordsBall); glEnableVertexAttribArray(program.texCoordAttribute); glBindTexture(GL_TEXTURE_2D, blank); modelMatrix.identity(); modelMatrix.Translate(ballPosx,ballPosy,0.0); program.setModelMatrix(modelMatrix); program.setProjectionMatrix(projectionMatrix); program.setViewMatrix(viewMatrix); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); float verticesPad1[] = { -0.1f, -0.2f, 0.0f, 0.2f, -0.1f, 0.2f, 0.0f, 0.2f, -0.1f, -0.2f, 0.0f, -0.2f }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, verticesPad1); glEnableVertexAttribArray(program.positionAttribute); float texCoordsPad1[] = { 0.0, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0 }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoordsPad1); glEnableVertexAttribArray(program.texCoordAttribute); modelMatrix.identity(); modelMatrix.Translate(-1.5, paddlePos1, 0.0); program.setModelMatrix(modelMatrix); program.setProjectionMatrix(projectionMatrix); program.setViewMatrix(viewMatrix); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); float verticesPad2[] = { 0.1f, -0.2f, 0.0f, 0.2f, 0.1f, 0.2f, 0.0f, 0.2f, 0.1f, -0.2f, 0.0f, -0.2f }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, verticesPad2); glEnableVertexAttribArray(program.positionAttribute); float texCoordsPad2[] = { 0.0, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0 }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoordsPad2); glEnableVertexAttribArray(program.texCoordAttribute); modelMatrix.identity(); modelMatrix.Translate(1.5, paddlePos2, 0.0); program.setModelMatrix(modelMatrix); program.setProjectionMatrix(projectionMatrix); program.setViewMatrix(viewMatrix); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); if (server){ float verticesfl[] = { -0.025f, 0.0f, 0.025f, 0.1f, -0.025f, 0.1f, 0.025f, 0.1f, -0.025f, 0.0f, 0.0f, 0.0f }; glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, verticesfl); glEnableVertexAttribArray(program.positionAttribute); float texCoordsfl[] = { 0.0, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0 }; glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texCoordsfl); glEnableVertexAttribArray(program.texCoordAttribute); modelMatrix.identity(); modelMatrix.Translate(server, -1, 0.0); program.setModelMatrix(modelMatrix); program.setProjectionMatrix(projectionMatrix); program.setViewMatrix(viewMatrix); glDrawArrays(GL_TRIANGLES, 0, 6); glDisableVertexAttribArray(program.positionAttribute); glDisableVertexAttribArray(program.texCoordAttribute); } SDL_GL_SwapWindow(displayWindow); glClear(GL_COLOR_BUFFER_BIT); } /*Game app; while (!app.UpdateAndRender()) {}*/ //SDL_Quit(); return 0; }
void GameWorld::initCPS() { GLuint texId = 0; if (!LoadTexture(CIRCLE_PARTICLE_TEX_FILE, texId, GL_BGRA, GL_RGBA)) { printf("load texture fail:\s\n", CIRCLE_PARTICLE_TEX_FILE); }