void Test3() { LoadBCP("data.bcp"); ReadLanguageFile(); InitWindow(); //InitRectDrawing(); //IDirect3DTexture9 *mytex = GetTexture("Interface\\LOADING SCREEN 1.tga"); //IDirect3DPixelShader9 *psh = LoadPixelShader("test.psh"); InitScene(); LoadMap("testmap.bcm"); while(!appexit) { BeginDrawing(); //ddev->SetRenderState(D3DRS_ZENABLE, FALSE); //ddev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); //ddev->SetPixelShader(psh); //ddev->SetTexture(0, mytex); //DrawRect(0, 0, 640, 480, -1); DrawScene(); EndDrawing(); HandleWindow(); if(keyheld[VK_UP]) camerapos += Vector3(0.0f, 0.0f, walkstep); if(keyheld[VK_DOWN]) camerapos -= Vector3(0.0f, 0.0f, walkstep); if(keyheld[VK_LEFT]) camerapos -= Vector3(walkstep, 0.0f, 0.0f); if(keyheld[VK_RIGHT]) camerapos += Vector3(walkstep, 0.0f, 0.0f); if(keyheld['E']) camerapos += Vector3(0.0f, walkstep, 0.0f); if(keyheld['D']) camerapos -= Vector3(0.0f, walkstep, 0.0f); } }
/* virtual */ bool EditPanel::MouseButton( int btn, bool up ) { if ( mDrawing && up ) { EndDrawing(); return true; } if ( DrawPanel::MouseButton( btn, up ) ) { return true; } bool left = btn == wxMOUSE_BTN_LEFT; bool right = btn == wxMOUSE_BTN_RIGHT; if (mMousePoint.x == -1 || mMousePoint.y == -1 || PointInZone( mMousePoint ) || !this->HasFocus() ) { return false; } if (left || right) { mCurrentColour = right ? mRightColour : mLeftColour; } if ( !up && ( left || right ) ) { return BeginDrawing(); } return false; }
void Test28() { InitWindow(); static Bitmap bm; bm.w = bm.h = 256; bm.form = BMFORMAT_B8G8R8A8; bm.pal = 0; bm.pix = (uchar*)malloc(bm.w * bm.h * 4); memset(bm.pix, 127, bm.w * bm.h * 4); static int px = 61, py = 89, vx = 2, vy = -3; *(uint*)(bm.pix + (py*bm.w + px) * 4) = -1; static texture t = CreateTexture(&bm, 1); while(!appexit) { px += vx; if(px < 0 || px >= 256) {px -= vx; vx = -vx;} py += vy; if(py < 0 || py >= 256) {py -= vy; vy = -vy;} *(uint*)(bm.pix + (py*bm.w + px) * 4) = -1; renderer->UpdateTexture(t, &bm); BeginDrawing(); InitRectDrawing(); SetTexture(0, t); DrawRect(0, 0, 256, 256, -1); EndDrawing(); HandleWindow(); } }
// Draw game (one frame) void DrawGame(void) { BeginDrawing(); ClearBackground(RAYWHITE); if (!gameOver) { DrawRectangleRec(player.rec, player.color); if (wave == FIRST) DrawText("FIRST WAVE", screenWidth/2 - MeasureText("FIRST WAVE", 40)/2, screenHeight/2 - 40, 40, Fade(BLACK, alpha)); else if (wave == SECOND) DrawText("SECOND WAVE", screenWidth/2 - MeasureText("SECOND WAVE", 40)/2, screenHeight/2 - 40, 40, Fade(BLACK, alpha)); else if (wave == THIRD) DrawText("THIRD WAVE", screenWidth/2 - MeasureText("THIRD WAVE", 40)/2, screenHeight/2 - 40, 40, Fade(BLACK, alpha)); for (int i = 0; i < activeEnemies; i++) { if (enemy[i].active) DrawRectangleRec(enemy[i].rec, enemy[i].color); } for (int i = 0; i < NUM_SHOOTS; i++) { if (shoot[i].active) DrawRectangleRec(shoot[i].rec, shoot[i].color); } DrawText(FormatText("%04i", score), 20, 20, 40, GRAY); if (victory) DrawText("YOU WIN", screenWidth/2 - MeasureText("YOU WIN", 40)/2, screenHeight/2 - 40, 40, BLACK); if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY); } else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY); EndDrawing(); }
int main() { int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing"); Vector2 ballPosition = { (float)screenWidth/2, (float)screenHeight/2 }; SetTargetFPS(60); while(!WindowShouldClose()) { if (IsKeyDown(KEY_RIGHT)) ballPosition.x += 0.8f; if (IsKeyDown(KEY_LEFT)) ballPosition.x -= 0.8f; if (IsKeyDown(KEY_UP)) ballPosition.y -= 0.8f; if (IsKeyDown(KEY_DOWN)) ballPosition.y += 0.8f; BeginDrawing(); ClearBackground(RAYWHITE); DrawCircleV(ballPosition, 50, MAROON); EndDrawing(); } CloseWindow(); return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards"); // Define the camera to look into our 3d world Camera camera = {{ 5.0, 4.0, 5.0 }, { 0.0, 2.0, 0.0 }, { 0.0, 1.0, 0.0 }}; Texture2D bill = LoadTexture("resources/billboard.png"); // Our texture billboard Vector3 billPosition = { 0.0, 2.0, 0.0 }; // Position where draw billboard SetCameraMode(CAMERA_ORBITAL); // Set an orbital camera mode SetCameraPosition(camera.position); // Set internal camera position to match our camera position SetCameraTarget(camera.target); // Set internal camera target to match our camera target SetTargetFPS(60); // Set our game to run at 60 frames-per-second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- UpdateCamera(&camera); // Update internal camera and our camera //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); Begin3dMode(camera); DrawBillboard(camera, bill, billPosition, 2.0f, WHITE); DrawGrid(10.0, 1.0); // Draw a grid End3dMode(); DrawFPS(10, 10); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadTexture(bill); // Unload texture CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
void Test22() { int curgrp = 0; char tb[512]; printf("Use LTTT? "); int uselt = atoi(fgets(tb, 511, stdin)); LoadBCP("data.bcp"); InitWindow(); InitFont(); if(uselt) LoadLTTT("Maps\\Map_Textures\\128_4Peaks.lttt"); LoadMapTextures(); //MessageBox(hWindow, "Terrain textures loaded.", appName, 64); printf("%u groups:\n", maptexgroup.len); for(int i = 0; i < maptexgroup.len; i++) { MapTextureGroup *g = maptexgroup.getpnt(i); printf(" * %s\n", g->name); printf(" %u textures:\n", g->tex->len); for(int j = 0; j < g->tex->len; j++) printf(" - %u\n", g->tex->getpnt(j)->id); } //texture t = GetTexture("Warrior Kings Game Set\\Textures\\Tavern.pcx"); while(!appexit) { BeginDrawing(); InitRectDrawing(); //SetTexture(0, maptexgroup.getpnt(0)->tex->getpnt(0)->t); //SetTexture(0, t); //DrawRect(0, 0, 256, 256, -1); MapTextureGroup *g = maptexgroup.getpnt(curgrp); sprintf(tb, "%s (%u/%u)", g->name, curgrp, maptexgroup.len); DrawFont(0, 0, tb); for(int i = 0; i < g->tex->len; i++) { MapTexture *t = g->tex->getpnt(i); SetTexture(0, t->t); DrawRect(i * 65, 32, 64, 64, -1, t->x / 256.f, t->y / 256.f, t->w / 256.f, t->h / 256.f); sprintf(tb, "%u", t->id); DrawFont(i * 65, 96, tb); } if(keypressed[VK_LEFT]) { if(curgrp > 0) curgrp--; } if(keypressed[VK_RIGHT]) { if(curgrp < maptexgroup.len-1) curgrp++; } EndDrawing(); HandleWindow(); } }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode"); // Define the camera to look into our 3d world Camera camera; camera.position = (Vector3){ 0.0f, 10.0f, 10.0f }; // Camera position camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; // Camera looking at point camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; // Camera up vector (rotation towards target) camera.fovy = 45.0f; // Camera field-of-view Y Vector3 cubePosition = { 0.0f, 0.0f, 0.0f }; SetTargetFPS(60); // Set our game to run at 60 frames-per-second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // TODO: Update your variables here //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); Begin3dMode(camera); DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED); DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON); DrawGrid(10, 1.0f); End3dMode(); DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY); DrawFPS(10, 10); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [texture] example - texture rectangle"); const char textLine1[] = "Lena image is a standard test image which has been in use since 1973."; const char textLine2[] = "It comprises 512x512 pixels, and it is probably the most widely used"; const char textLine3[] = "test image for all sorts of image processing algorithms."; // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) Texture2D texture = LoadTexture("resources/lena.png"); // Texture loading Rectangle eyesRec = { 225, 240, 155, 50 }; // Part of the texture to draw Vector2 position = { 369, 241 }; //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // TODO: Update your variables here //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawText("LENA", 220, 100, 20, PINK); DrawTexture(texture, screenWidth/2 - 256, 0, Fade(WHITE, 0.1f)); // Draw background image DrawTextureRec(texture, eyesRec, position, WHITE); // Draw eyes part of image DrawText(textLine1, 220, 140, 10, DARKGRAY); DrawText(textLine2, 220, 160, 10, DARKGRAY); DrawText(textLine3, 220, 180, 10, DARKGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadTexture(texture); // Texture unloading CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing"); //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // TODO: Update your variables here //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawText("some basic shapes available on raylib", 20, 20, 20, DARKGRAY); DrawLine(18, 42, screenWidth - 18, 42, BLACK); DrawCircle(screenWidth/4, 120, 35, DARKBLUE); DrawCircleGradient(screenWidth/4, 220, 60, GREEN, SKYBLUE); DrawCircleLines(screenWidth/4, 340, 80, DARKBLUE); DrawRectangle(screenWidth/4*2 - 60, 100, 120, 60, RED); DrawRectangleGradient(screenWidth/4*2 - 90, 170, 180, 130, MAROON, GOLD); DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE); DrawTriangle((Vector2){screenWidth/4*3, 80}, (Vector2){screenWidth/4*3 - 60, 150}, (Vector2){screenWidth/4*3 + 60, 150}, VIOLET); DrawTriangleLines((Vector2){screenWidth/4*3, 160}, (Vector2){screenWidth/4*3 - 20, 230}, (Vector2){screenWidth/4*3 + 20, 230}, DARKBLUE); DrawPoly((Vector2){screenWidth/4*3, 320}, 6, 80, 0, BROWN); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input"); Vector2 ballPosition = { (float)screenWidth/2, (float)screenHeight/2 }; Vector2 gamepadMovement = { 0.0f, 0.0f }; SetTargetFPS(60); // Set target frames-per-second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- if (IsGamepadAvailable(GAMEPAD_PLAYER1)) { gamepadMovement = GetGamepadMovement(GAMEPAD_PLAYER1); ballPosition.x += gamepadMovement.x; ballPosition.y -= gamepadMovement.y; if (IsGamepadButtonPressed(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_A)) { ballPosition.x = (float)screenWidth/2; ballPosition.y = (float)screenHeight/2; } } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawText("move the ball with gamepad", 10, 10, 20, DARKGRAY); DrawCircleV(ballPosition, 50, MAROON); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
void Test5() { LoadBCP("data.bcp"); ReadLanguageFile(); InitWindow(); LoadGameSet("Warrior Kings Game Set\\small extensions.cpp"); printf("Game set loaded!\n"); printf("Declared items:\n"); for(int i = 0; i < strItems.len; i++) printf(" - %s\n", strItems[i]); printf("Defined values:\n"); for(int i = 0; i < defvalue.len; i++) printf(" - %s = %f\n", strDefValue[i], defvalue[i]); printf("Appearance tags:\n"); for(int i = 0; i < strAppearTag.len; i++) printf(" - %s\n", strAppearTag[i]); printf("ObjDefs:\n"); for(int i = 0; i < strObjDef.len; i++) printf(" - %s (%s)\n", strObjDef[i], CLASS_str[typeObjDef[i]]); printf("Looking at first object:\n"); printf(" - Tooltip: %s\n", objdef[0].tooltip); printf(" - First start item: %f\n", objdef[0].startItems[0]); printf(" - Shadow: %i\n", objdef[0].shadowtype); printf("2nd's subtypes:\n"); for(int i = 0; i < pstObjDef[1]->len; i++) printf(" - %s\n", (pstObjDef[1])->getdp(i)); printf("1st's subtypes (%i):\n", pstObjDef[0]->len); for(int i = 0; i < pstObjDef[0]->len; i++) printf(" - %s\n", (pstObjDef[0])->getdp(i)); printf("These ObjDefs have \"Default\" subtype and \"Default\" appearance:\n"); for(int i = 0; i < strObjDef.len; i++) printf("- %s: %s\n", strObjDef[i], objdef[i].subtypes[0].appear[0].def?"Yes":"No"); // :S getch(); //InitMeshDrawing(); int a = FindObjDef(CLASS_BUILDING, "Manor"); while(!appexit) { BeginDrawing(); BeginMeshDrawing(); SetModelMatrices(); objdef[a].subtypes[0].appear[0].def->draw(); // :S EndDrawing(); HandleWindow(); } }
// Draw game (one frame) void DrawGame(void) { BeginDrawing(); ClearBackground(RAYWHITE); if (!gameOver) { // Draw missiles for (int i = 0; i < MAX_MISSILES; i++) { if (missile[i].active) { DrawLine(missile[i].origin.x, missile[i].origin.y, missile[i].position.x, missile[i].position.y, RED); if (framesCounter % 16 < 8) DrawCircle(missile[i].position.x, missile[i].position.y, 3, YELLOW); } } // Draw interceptors for (int i = 0; i < MAX_INTERCEPTORS; i++) { if (interceptor[i].active) { DrawLine(interceptor[i].origin.x, interceptor[i].origin.y, interceptor[i].position.x, interceptor[i].position.y, GREEN); if (framesCounter % 16 < 8) DrawCircle(interceptor[i].position.x, interceptor[i].position.y, 3, BLUE); } } // Draw explosions for (int i = 0; i < MAX_EXPLOSIONS; i++) { if (explosion[i].active) DrawCircle(explosion[i].position.x, explosion[i].position.y, EXPLOSION_RADIUS*explosion[i].radiusMultiplier, EXPLOSION_COLOR); } // Draw buildings and launchers for (int i = 0; i < LAUNCHERS_AMOUNT; i++) { if (launcher[i].active) DrawRectangle(launcher[i].position.x - LAUNCHER_SIZE/2, launcher[i].position.y - LAUNCHER_SIZE/2, LAUNCHER_SIZE, LAUNCHER_SIZE, GRAY); } for (int i = 0; i < BUILDINGS_AMOUNT; i++) { if (building[i].active) DrawRectangle(building[i].position.x - BUILDING_SIZE/2, building[i].position.y - BUILDING_SIZE/2, BUILDING_SIZE, BUILDING_SIZE, LIGHTGRAY); } // Draw score DrawText(FormatText("SCORE %4i", score), 20, 20, 40, LIGHTGRAY); if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY); } else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY); EndDrawing(); }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [text] example - bmfont and ttf sprite fonts loading"); const char msgBm[64] = "THIS IS AN AngelCode SPRITE FONT"; const char msgTtf[64] = "THIS SPRITE FONT has been GENERATED from a TTF"; // NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required) SpriteFont fontBm = LoadSpriteFont("resources/fonts/bmfont.fnt"); // BMFont (AngelCode) SpriteFont fontTtf = LoadSpriteFont("resources/fonts/pixantiqua.ttf"); // TTF font Vector2 fontPosition; fontPosition.x = screenWidth/2 - MeasureTextEx(fontBm, msgBm, fontBm.size, 0).x/2; fontPosition.y = screenHeight/2 - fontBm.size/2 - 80; SetTargetFPS(60); //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // TODO: Update variables here... //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawTextEx(fontBm, msgBm, fontPosition, fontBm.size, 0, MAROON); DrawTextEx(fontTtf, msgTtf, (Vector2){ 75.0f, 240.0f }, fontTtf.size*0.8f, 2, LIME); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadSpriteFont(fontBm); // AngelCode SpriteFont unloading UnloadSpriteFont(fontTtf); // TTF SpriteFont unloading CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
void Test21() { InitWindow(); while(!appexit) { BeginDrawing(); EndDrawing(); HandleWindow(); Sleep(1000/30); } }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib test - DDS texture loading and drawing"); // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) //Texture2D texture = LoadTexture("resources/raylib_logo.dds"); // Texture loading //Texture2D texture = LoadTexture("resources/raylib_logo_uncompressed.dds"); // Texture loading Image image = LoadImage("resources/raylib_logo_uncompressed.dds"); Texture2D texture = CreateTexture(image, false); // NOTE: With OpenGL 3.3 mipmaps generation works great SetTargetFPS(60); //--------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // TODO: Update your variables here //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE); DrawText("this IS a texture!", 360, 370, 10, GRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- //UnloadTexture(texture); // Texture unloading CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib test - texture pro"); // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) Texture2D texture = LoadTexture("resources/raylib_logo.png"); // Texture loading Vector2 position = { 200, 100 }; Rectangle sourceRec = { 128, 128, 128, 128 }; Rectangle destRec = { 128, 128, 128, 128 }; Vector2 origin = { 64, 64 }; // NOTE: origin is relative to destRec size //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // TODO: Update your variables here //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); //DrawTextureEx(texture, position, 45, 1, MAROON); DrawTexturePro(texture, sourceRec, destRec, origin, 45, GREEN); DrawLine(destRec.x, 0, destRec.x, screenHeight, RED); DrawLine(0, destRec.y, screenWidth, destRec.y, RED); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadTexture(texture); // Texture unloading CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values"); int framesCounter = 0; // Variable used to count frames int randValue = GetRandomValue(-8,5); // Get a random integer number between -8 and 5 (both included) SetTargetFPS(60); // Set our game to run at 60 frames-per-second //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- framesCounter++; // Every two seconds (120 frames) a new random value is generated if (((framesCounter/120)%2) == 1) { randValue = GetRandomValue(-8,5); framesCounter = 0; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON); DrawText(FormatText("%i", randValue), 360, 180, 80, LIGHTGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing"); InitAudioDevice(); // Initialize audio device Sound fxWav = LoadSound("resources/audio/weird.wav"); // Load WAV audio file Sound fxOgg = LoadSound("resources/audio/tanatana.ogg"); // Load OGG audio file SetTargetFPS(60); //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- if (IsKeyPressed(KEY_SPACE)) PlaySound(fxWav); // Play WAV sound if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg); // Play OGG sound //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, LIGHTGRAY); DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, LIGHTGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadSound(fxWav); // Unload sound data UnloadSound(fxOgg); // Unload sound data CloseAudioDevice(); // Close audio device CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Setup int screenWidth = 800; int screenHeight = 450; InitWindow( screenWidth, screenHeight, "raylib [network] example - udp server"); SetTargetFPS(60); SetTraceLogLevel(LOG_DEBUG); // Networking InitNetwork(); // Create the server // // Performs // getaddrinfo // socket // setsockopt // bind // listen server_res = AllocSocketResult(); if (!SocketCreate(&server_cfg, server_res)) { TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", server_res->status, server_res->socket->status); } else { if (!SocketBind(&server_cfg, server_res)) { TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", server_res->status, server_res->socket->status); } } // Create & Add sockets to the socket set socket_set = AllocSocketSet(1); msglen = strlen(pingmsg) + 1; memset(recvBuffer, '\0', sizeof(recvBuffer)); AddSocket(socket_set, server_res->socket); // Main game loop while (!WindowShouldClose()) { BeginDrawing(); ClearBackground(RAYWHITE); NetworkUpdate(); EndDrawing(); } // Cleanup CloseWindow(); return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input"); int mouseX, mouseY; Vector2 ballPosition = { -100.0, -100.0 }; //--------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) { mouseX = GetMouseX(); mouseY = GetMouseY(); ballPosition.x = (float)mouseX; ballPosition.y = (float)mouseY; } //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawCircleV(ballPosition, 40, GOLD); DrawText("mouse click to draw the ball", 10, 10, 20, DARKGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main(void) { // Initialization //-------------------------------------------------------------------------------------- const int screenWidth = 800; const int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input"); Vector2 ballPosition = { -100.0f, -100.0f }; Color ballColor = DARKBLUE; SetTargetFPS(60); // Set our game to run at 60 frames-per-second //--------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- ballPosition = GetMousePosition(); if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ballColor = MAROON; else if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) ballColor = LIME; else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) ballColor = DARKBLUE; //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawCircleV(ballPosition, 40, ballColor); DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [textures] example - image loading"); // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) Image image = LoadImage("resources/raylib_logo.png"); // Loaded in CPU memory (RAM) Texture2D texture = LoadTextureFromImage(image); // Image converted to texture, GPU memory (VRAM) UnloadImage(image); // Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM //--------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // TODO: Update your variables here //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE); DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadTexture(texture); // Texture unloading CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
void Test15() { InitWindow(); LoadBCP("data.bcp"); InitFont(); /* GUIPage gpage; GUISimpleButton gbutton(2, 2, 64, 64, OnTestButtonClick); GUITextButton gtxtbutton(2, 80, 100, 16, OnTestButtonClick, "Hello!"); gpage.add(&gbutton); gpage.add(>xtbutton); //actualpage = &gpage; InitMenuBar(); menubar.parent = &gpage; actualpage = &menubar; */ actualpage = new GEContainer; GEMenuBar *b = new GEMenuBar(mbs, mbe, 2, actualpage); actualpage->add(b); b->setRect(0, 0, 640, 20); GEWindow *win = new GEWindow; actualpage->add(win); win->setCaption("Test15"); win->setRect(32, 32, 150, 150); win->onResize(); win->bgColor = 0x80008000; GETextButton *t = new GETextButton; win->add(t); t->setRect(16, 36, 64, 64); t->setCaption("LOL!"); GEScrollBar *sb = new GEScrollBar; win->add(sb); sb->setRect(90, 36, 16, 80); while(!appexit) { BeginDrawing(); InitRectDrawing(); actualpage->draw(0, 0); EndDrawing(); HandleWindow(); } }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel"); int boxPositionY = screenHeight/2 - 40; int scrollSpeed = 4; // Scrolling speed in pixels SetTargetFPS(60); //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- boxPositionY -= (GetMouseWheelMove()*scrollSpeed); //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON); DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY); DrawText(FormatText("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib test - ogg audio loading and playing"); InitAudioDevice(); // Initialize audio device Sound fx = LoadSound("resources/audio/0564.ogg"); // Load audio file //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- if (IsKeyPressed(KEY_SPACE)) PlaySound(fx); // Play the sound! //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawText("Press SPACE to PLAY the SOUND!", 240, 200, 20, LIGHTGRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- UnloadSound(fx); // Unload sound data CloseAudioDevice(); // Close audio device CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }
void Test14() { InitWindow(); LoadBCP("data.bcp"); InitFont(); ReadLanguageFile(); char *msg = GetLocText("AI_BIOG_PAUL_THE_SIMPLE"); while(!appexit) { BeginDrawing(); InitRectDrawing(); //DrawRect(2, 2, 64, 64, 0xFF); //for(int i = 0; i < 40; i++) // DrawFont(i*12, i*12, "Hello! \x21\x22\x7d\x7e\xa1\xa2\xa3"); //DrawFont(0, 0, msg); deffont->DrawInRect(scrw, 0, 0, msg, 0xFF00FFFF); EndDrawing(); HandleWindow(); } }
void Test4() { LoadBCP("data.bcp"); InitWindow(); Mesh tm("Warrior Kings Game Set\\Characters\\Abaddon\\ABADDON_MOVE.MESH3"); Mesh tn("Warrior Kings Game Set\\Characters\\Michael\\MICHAEL1.MESH3"); //InitMeshDrawing(); while(!appexit) { BeginDrawing(); BeginMeshDrawing(); SetModelMatrices(); tm.draw(1); tn.draw(2); EndDrawing(); HandleWindow(); } }
void Test27() { scrw = 1024; scrh = 768; LoadBCP("data.bcp"); InitWindow(); ImGuiImpl_Init(); LoadMapTextures(); //mapfogcolor = 0xFF204080; while(!appexit) { ImGuiImpl_NewFrame(); IGAutotileTest(); BeginDrawing(); renderer->InitImGuiDrawing(); ImGui::Render(); EndDrawing(); HandleWindow(); } }
int main() { // Initialization //-------------------------------------------------------------------------------------- int screenWidth = 800; int screenHeight = 450; InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes"); //-------------------------------------------------------------------------------------- // Main game loop while (!WindowShouldClose()) // Detect window close button or ESC key { // Update //---------------------------------------------------------------------------------- // TODO: Update your variables here //---------------------------------------------------------------------------------- // Draw //---------------------------------------------------------------------------------- BeginDrawing(); ClearBackground(RAYWHITE); DrawRectangle(screenWidth/2 - 128, screenHeight/2 - 128, 256, 256, BLACK); DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, RAYWHITE); DrawText("raylib", screenWidth/2 - 44, screenHeight/2 + 48, 50, BLACK); DrawText("this is NOT a texture!", 350, 370, 10, GRAY); EndDrawing(); //---------------------------------------------------------------------------------- } // De-Initialization //-------------------------------------------------------------------------------------- CloseWindow(); // Close window and OpenGL context //-------------------------------------------------------------------------------------- return 0; }