વિન્ડોઝ ડેસ્કટોપ

Paul Boyer

સોમવાર, 30 ડિસેમ્બર, 2024 એ 01:40:36 AM વાગ્યે

Windows માં 2D ગેમ ડેવલપમેન્ટ સાથે પ્રારંભ કરવું

વિન્ડોઝ ડેસ્કટોપ એપ્લિકેશન માટે 2D ગેમ બનાવવી એ રોમાંચક અને પડકારજનક બંને હોઈ શકે છે. ઘણા વિકાસકર્તાઓ માટે, C++ નો ઉપયોગ અજોડ નિયંત્રણ અને પ્રદર્શન પ્રદાન કરે છે. જો કે, શરૂઆતથી આખું ગેમ એન્જિન બનાવવું કદાચ વ્યવહારુ ન હોય. ત્યાં જ હાલના માળખા અને સાધનોનો લાભ લેવાથી સમય અને પ્રયત્નો બચી શકે છે. 🎮

કલ્પના કરો કે તમે Windows વપરાશકર્તાઓ માટે પઝલ ગેમ અથવા સરળ પ્લેટફોર્મર વિકસાવી રહ્યાં છો. તમે મૂળભૂત રમત એન્જિન મિકેનિક્સને ફરીથી શોધવાને બદલે ગેમપ્લે અને ડિઝાઇન પર ધ્યાન કેન્દ્રિત કરવા માંગો છો. સદ્ભાગ્યે, ઘણા C++ ફ્રેમવર્ક તમને ઝડપથી શરૂ કરવા માટે સમૃદ્ધ પુસ્તકાલયો અને સમુદાય સપોર્ટ ઓફર કરે છે. આ અભિગમ સુનિશ્ચિત કરે છે કે તમે અસરકારક રીતે પરિણામ આપી શકો છો.

દાખલા તરીકે, SDL2 અથવા SFML જેવા ફ્રેમવર્કનો ઉપયોગ કરવાથી ગ્રાફિક્સ રેન્ડરિંગ, ઇનપુટ હેન્ડલિંગ અને ઑડિયો મેનેજ કરવા જેવા કાર્યોને સરળ બનાવી શકાય છે. આ સાધનો સારી રીતે દસ્તાવેજીકૃત અને વ્યાપકપણે ઉપયોગમાં લેવાય છે, જે તેમને વિશ્વસનીય પસંદગીઓ બનાવે છે. તેમની સાથે, હાલની ડેસ્કટોપ એપ્લિકેશનમાં રમતને એમ્બેડ કરવી સીધી અને સીમલેસ બની જાય છે.

પછી ભલે તમે અનુભવી પ્રોગ્રામર હોવ અથવા હમણાં જ પ્રારંભ કરો, યોગ્ય સાધનો અને માર્ગદર્શન તમારી દ્રષ્ટિને વાસ્તવિકતામાં પરિવર્તિત કરી શકે છે. તમારા પ્રોજેક્ટને અનુરૂપ ફ્રેમવર્ક પર ધ્યાન કેન્દ્રિત કરીને, તમે પોલિશ્ડ 2D ગેમ અનુભવ પ્રાપ્ત કરી શકો છો. માં ડૂબકી મારવા માટે તૈયાર છો? ચાલો શક્યતાઓનું અન્વેષણ કરીએ! 🚀

આદેશ	ઉપયોગનું ઉદાહરણ
SDL_Init	વિડિઓ અને અન્ય સબસિસ્ટમ માટે SDL લાઇબ્રેરીનો પ્રારંભ કરે છે. ઉદાહરણ તરીકે, SDL_Init(SDL_INIT_VIDEO) વિડિઓ સબસિસ્ટમને ઉપયોગ માટે તૈયાર કરે છે.
SDL_CreateWindow	શીર્ષક, સ્થિતિ, પહોળાઈ અને ઊંચાઈ જેવા ઉલ્લેખિત પરિમાણો સાથે નવી વિન્ડો બનાવે છે. દાખલા તરીકે, SDL_CreateWindow("2D ગેમ", 100, 100, 800, 600, SDL_WINDOW_SHOWN).
SDL_CreateRenderer	વિન્ડો માટે 2D રેન્ડરીંગ સંદર્ભ બનાવે છે. ઉદાહરણ: SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED \| SDL_RENDERER_PRESENTVSYNC) હાર્ડવેર પ્રવેગક અને vsync સક્ષમ કરે છે.
SDL_SetRenderDrawColor	રેન્ડરીંગ માટે વપરાયેલ રંગ સુયોજિત કરે છે. ઉદાહરણ તરીકે, SDL_SetRenderDrawColor(ren, 255, 0, 0, 255) રંગને અપારદર્શક લાલ પર સેટ કરે છે.
SDL_RenderFillRect	વર્તમાન રેન્ડરિંગ રંગ સાથે લંબચોરસ ભરે છે. ઉદાહરણ: SDL_RenderFillRect(ren, &rect) SDL_Rect દ્વારા વ્યાખ્યાયિત એક લંબચોરસ ભરે છે.
SDL_PollEvent	SDL ઇવેન્ટ કતારમાંથી ઇવેન્ટ્સ પુનઃપ્રાપ્ત કરે છે. ઉદાહરણ: SDL_PollEvent(&e) વિન્ડો બંધ કરવા જેવા નવા વપરાશકર્તા ઇનપુટ્સ માટે તપાસે છે.
SFML RenderWindow	SFML ગ્રાફિક્સ રેન્ડરિંગ માટે વિન્ડો બનાવે છે. ઉદાહરણ તરીકે, sf::RenderWindow window(sf::VideoMode(800, 600), "2D ગેમ").
sf::RectangleShape	2D લંબચોરસ આકારને વ્યાખ્યાયિત કરે છે જે સ્ક્રીન પર દોરી શકાય છે. ઉદાહરણ: sf::Rectangleshape rectangle(sf::Vector2f(400, 300)).
sf::Event	SFML માં વિન્ડો બંધ અથવા કી પ્રેસ જેવી ઘટનાઓનું સંચાલન કરે છે. દાખલા તરીકે, જ્યારે (window.pollEvent(event)) વપરાશકર્તાના ઇનપુટ્સ માટે તપાસ કરે છે.
assert	રનટાઇમ દરમિયાન શરતો માન્ય કરે છે. ઉદાહરણ તરીકે, assert(win != nullptr) ખાતરી કરે છે કે SDL વિન્ડો સફળતાપૂર્વક બનાવવામાં આવી હતી.

2D ગેમ ડેવલપમેન્ટ માટે સ્ક્રિપ્ટ્સને બ્રેકિંગ ડાઉન

ઉપરની સ્ક્રિપ્ટો C++ નો ઉપયોગ કરીને વિન્ડોઝ ડેસ્કટોપ એપ્લિકેશનમાં 2D ગેમ બનાવવા અને એમ્બેડ કરવા માટેની બે અલગ અલગ પદ્ધતિઓ દર્શાવે છે. પ્રથમ પદ્ધતિ લાભ આપે છે SDL2, મલ્ટીમીડિયા હેન્ડલિંગ માટે એક શક્તિશાળી પુસ્તકાલય. તે SDL લાઇબ્રેરીનો ઉપયોગ કરીને પ્રારંભ કરીને શરૂ થાય છે SDL_Init, જે વિડિયો સબસિસ્ટમ સેટ કરે છે. સ્ક્રિપ્ટ તેની સાથે વિન્ડો બનાવવા માટે આગળ વધે છે SDL_CreateWindow અને સાથે રેન્ડરીંગ સંદર્ભ SDL_CreateRenderer. એકસાથે, આ ઘટકો સ્ક્રીન પર ગ્રાફિક્સ પ્રદર્શિત કરવા માટે બેકબોન બનાવે છે. ઉદાહરણ તરીકે, રેટ્રો-શૈલીની આર્કેડ ગેમ બનાવવાની કલ્પના કરો; તમે આ રેન્ડરરનો ઉપયોગ પાત્રો અને અવરોધો જેવા રમત તત્વોને દોરવા માટે કરશો. 🎮

એકવાર વિન્ડો અને રેન્ડરર તૈયાર થઈ જાય, રમત તેના મુખ્ય લૂપમાં પ્રવેશ કરે છે. આ લૂપ દ્વારા વપરાશકર્તાના ઇનપુટ માટે સતત સાંભળે છે SDL_PollEvent, ખેલાડીઓને રમત સાથે ક્રિયાપ્રતિક્રિયા કરવાની મંજૂરી આપે છે. લૂપની અંદર, જેમ કે આદેશો SDL_SetRenderDrawColor અને SDL_RenderFillRect તમને ઑબ્જેક્ટ્સને ગતિશીલ રીતે દોરવા અને અપડેટ કરવામાં સક્ષમ કરે છે. ઉદાહરણ તરીકે, પ્લેટફોર્મર ગેમમાં, તમે આનો ઉપયોગ પ્લેટફોર્મને રેન્ડર કરવા અને તેમની સ્થિતિને સમાયોજિત કરવા માટે કરી શકો છો. આ અભિગમ સરળ રમતો માટે ઉત્તમ છે પરંતુ જટિલ 2D એપ્લિકેશનો માટે પણ સારી રીતે સ્કેલ કરે છે. સ્ક્રિપ્ટ સંસાધનોને સાફ કરીને સમાપ્ત થાય છે SDL_DestroyRenderer અને SDL_ છોડો, કાર્યક્ષમ મેમરી વ્યવસ્થાપન સુનિશ્ચિત કરે છે.

બીજું ઉદાહરણ ઉપયોગ કરે છે SFML, જે 2D ગેમ ડેવલપમેન્ટ માટેનું બીજું મજબૂત માળખું છે. અહીં, ઉપયોગ કરીને વિન્ડો બનાવવામાં આવે છે sf::રેન્ડર વિન્ડો, અને લંબચોરસ જેવા ગ્રાફિકલ ઑબ્જેક્ટ્સ સાથે સંચાલિત થાય છે sf::લંબચોરસ આકાર. આ પદ્ધતિ અત્યંત મોડ્યુલર છે અને ફરીથી વાપરી શકાય તેવા ઘટકો માટે પરવાનગી આપે છે, જે તેને જાળવી શકાય તેવા કોડબેઝ બનાવવા માટે આદર્શ બનાવે છે. ઉદાહરણ તરીકે, જો તમે 2D પઝલ ગેમ પર કામ કરી રહ્યાં છો, તો દરેક પઝલ એલિમેન્ટ એક સ્વતંત્ર મોડ્યુલ હોઈ શકે છે. માઉસ ક્લિક અથવા કી પ્રેસ જેવી ઘટનાઓ દ્વારા નિયંત્રિત કરવામાં આવે છે sf::ઇવેન્ટ લૂપ, તમને વપરાશકર્તાની ક્રિયાપ્રતિક્રિયાઓ પર સંપૂર્ણ નિયંત્રણ આપે છે.

SDL2 અને SFML બંને સ્ક્રિપ્ટો મોડ્યુલર અને ફરીથી વાપરી શકાય તે રીતે ડિઝાઇન કરવામાં આવી છે. SDL સ્ક્રિપ્ટ એ વિકાસકર્તાઓ માટે વધુ અનુકૂળ છે જે રેન્ડરિંગ પર ઝીણવટભર્યું નિયંત્રણ મેળવવા માગે છે, જ્યારે SFML સ્ક્રિપ્ટ વધુ પ્રારંભિક-મૈત્રીપૂર્ણ અભિગમ પ્રદાન કરે છે. આ પુસ્તકાલયોને યોગ્ય સંસાધન વ્યવસ્થાપન અને એરર હેન્ડલિંગ સાથે જોડીને, તમે આકર્ષક 2D ગેમ્સ બનાવી શકો છો જે Windows પ્લેટફોર્મ પર સરળતાથી ચાલે છે. ભલે તમે પિક્સેલ-આર્ટ અક્ષરો દોરતા હોવ અથવા રીઅલ-ટાઇમમાં ઑબ્જેક્ટને એનિમેટ કરી રહ્યાં હોવ, આ સ્ક્રિપ્ટો તમારા રમતના વિચારોને જીવંત કરવા માટે મજબૂત પાયો પ્રદાન કરે છે. 🚀

C++ સાથે Windows ડેસ્કટોપ એપ્લિકેશનમાં 2D ગેમને એમ્બેડ કરવી

Windows ડેસ્કટોપ એપ્લિકેશનમાં 2D રમતો બનાવવા અને એમ્બેડ કરવા માટે SDL2 નો ઉપયોગ કરવો. SDL2 એ ગ્રાફિક્સ, ઇનપુટ અને ઑડિયોને હેન્ડલ કરવા માટે ક્રોસ-પ્લેટફોર્મ લાઇબ્રેરી છે.

#include <SDL.h>
#include <iostream>
int main(int argc, char* argv[]) {
    // Initialize SDL
    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
        std::cerr << "SDL_Init Error: " << SDL_GetError() << std::endl;
        return 1;
    }
    // Create a window
    SDL_Window* win = SDL_CreateWindow("2D Game", 100, 100, 800, 600, SDL_WINDOW_SHOWN);
    if (win == nullptr) {
        std::cerr << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }
    // Create a renderer
    SDL_Renderer* ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if (ren == nullptr) {
        SDL_DestroyWindow(win);
        std::cerr << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }
    // Game loop
    bool running = true;
    SDL_Event e;
    while (running) {
        while (SDL_PollEvent(&e)) {
            if (e.type == SDL_QUIT) {
                running = false;
            }
        }
        // Clear the renderer
        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
        SDL_RenderClear(ren);
        // Draw a rectangle
        SDL_SetRenderDrawColor(ren, 255, 0, 0, 255);
        SDL_Rect rect = {200, 150, 400, 300};
        SDL_RenderFillRect(ren, &rect);
        // Present the renderer
        SDL_RenderPresent(ren);
    }
    // Clean up
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();
    return 0;
}

C++ માં SFML સાથે મોડ્યુલર ગેમ બનાવવી

મોડ્યુલર 2D ગેમ ડેવલપમેન્ટ માટે SFML, એક સરળ અને ઝડપી મલ્ટીમીડિયા લાઇબ્રેરીનો ઉપયોગ કરીને. SFML તેના ઉપયોગમાં સરળતાને કારણે નવા નિશાળીયા માટે ખાસ કરીને શ્રેષ્ઠ છે.

#include <SFML/Graphics.hpp>
int main() {
    // Create a window
    sf::RenderWindow window(sf::VideoMode(800, 600), "2D Game");
    // Define a shape
    sf::RectangleShape rectangle(sf::Vector2f(400, 300));
    rectangle.setFillColor(sf::Color::Red);
    rectangle.setPosition(200, 150);
    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }
        window.clear(sf::Color::Black);
        window.draw(rectangle);
        window.display();
    }
    return 0;
}

એકમ પરીક્ષણ SDL2 ગેમ ઉદાહરણ

SDL2 આરંભ અને વિન્ડો બનાવવાની કાર્યક્ષમતાને માન્ય કરવા માટે એકમ પરીક્ષણ ઉમેરવું.

#include <cassert>
#include <SDL.h>
void testSDLInitialization() {
    assert(SDL_Init(SDL_INIT_VIDEO) == 0);
    SDL_Window* win = SDL_CreateWindow("Test", 100, 100, 800, 600, SDL_WINDOW_SHOWN);
    assert(win != nullptr);
    SDL_DestroyWindow(win);
    SDL_Quit();
}
int main() {
    testSDLInitialization();
    std::cout << "All tests passed!" << std::endl;
    return 0;
}

2D ગેમ્સ એમ્બેડ કરવા માટે ફ્રેમવર્ક અને ટૂલ્સનું અન્વેષણ કરવું

C++ નો ઉપયોગ કરીને વિન્ડોઝ ડેસ્કટોપ એપ્લિકેશનમાં 2D ગેમ વિકસાવતી અથવા એમ્બેડ કરતી વખતે, ઉપલબ્ધ ફ્રેમવર્કની અનન્ય સુવિધાઓ ધ્યાનમાં લેવી આવશ્યક છે. એક વિકલ્પ જે બહાર રહે છે તે છે ઇમગુઇ, ગ્રાફિકલ યુઝર ઇન્ટરફેસ (GUIs) બનાવવા માટે રચાયેલ લાઇબ્રેરી. જ્યારે મુખ્યત્વે ટૂલ્સ અને એડિટર્સ માટે ઉપયોગમાં લેવામાં આવે છે, ત્યારે તેને ડેસ્કટૉપ એપ્લિકેશન્સમાં 2D ગેમ્સને એમ્બેડ કરવા માટે અનુકૂળ કરી શકાય છે. દાખલા તરીકે, જો તમે તમારી રમત માટે લેવલ એડિટર અથવા ડીબગ ઓવરલે બનાવી રહ્યાં છો, તો ImGui વિકાસને ઝડપી બનાવવા માટે પૂર્વ-બિલ્ટ વિજેટ્સ અને નિયંત્રણો પ્રદાન કરે છે.

અન્વેષણ કરવા યોગ્ય અન્ય સાધન છે Qt. તેની મજબૂત એપ્લિકેશન-નિર્માણ ક્ષમતાઓ માટે જાણીતું, Qt ડેસ્કટોપ પર્યાવરણમાં એકીકૃત 2D ગેમને એકીકૃત કરી શકે છે. નો ઉપયોગ કરીને QGraphicsView વર્ગ, તમે રમતના દ્રશ્યોને અસરકારક રીતે મેનેજ અને રેન્ડર કરી શકો છો. આ પદ્ધતિ નાની રમતોને મોટા ડેસ્કટોપ સોફ્ટવેરમાં એમ્બેડ કરવા માટે આદર્શ છે, જેમ કે એકીકૃત મીની-ગેમ્સ સાથે શૈક્ષણિક એપ્લિકેશન. વધુમાં, Qt ક્રોસ-પ્લેટફોર્મ સપોર્ટ પૂરો પાડે છે, જે તેને બહુમુખી ઓપરેટિંગ સિસ્ટમોને લક્ષ્યાંક બનાવતા વિકાસકર્તાઓ માટે બહુમુખી પસંદગી બનાવે છે.

રમત-વિશિષ્ટ ફ્રેમવર્ક માટે, Cocos2d-x સુવિધાથી ભરપૂર સોલ્યુશન આપે છે. આ લાઇટવેઇટ ગેમ એન્જિન અદ્યતન 2D રેન્ડરિંગ અને એનિમેશનને સપોર્ટ કરે છે જ્યારે ઉત્તમ પ્રદર્શન જાળવી રાખે છે. તેની મોડ્યુલર ડિઝાઇન હાલના C++ પ્રોજેક્ટ્સમાં એકીકૃત થવાનું સરળ બનાવે છે. ભલે તમે એકલ રમત બનાવી રહ્યાં હોવ અથવા ઉત્પાદકતા એપ્લિકેશનમાં એમ્બેડ કરી રહ્યાં હોવ, આ સાધનો પ્રક્રિયાને સરળ બનાવે છે, જે તમને સર્જનાત્મકતા અને કાર્યક્ષમતા પર ધ્યાન કેન્દ્રિત કરવાની મંજૂરી આપે છે. 🎮

2D ગેમ્સ એમ્બેડ કરવા વિશે વારંવાર પૂછાતા પ્રશ્નો

2D ગેમ ડેવલપમેન્ટ માટે શ્રેષ્ઠ C++ ફ્રેમવર્ક કયું છે?
શ્રેષ્ઠ માળખું તમારા પ્રોજેક્ટ પર આધાર રાખે છે. એકલ રમતો માટે, SDL2 અથવા SFML ઉત્તમ છે. GUI-ભારે પ્રોજેક્ટ્સ માટે, ધ્યાનમાં લો Qt.
હું 2D ગેમને Windows ડેસ્કટોપ એપ્લિકેશનમાં કેવી રીતે એકીકૃત કરી શકું?
જેવા ફ્રેમવર્કનો ઉપયોગ કરો Qt તેની સાથે QGraphicsView અથવા પુસ્તકાલયો જેવી ImGui GUI એકીકરણ માટે.
શું SDL2 2D રમતો માટે SFML કરતાં વધુ સારું છે?
બંને મહાન છે. SDL2 વધુ નિમ્ન-સ્તરના નિયંત્રણની તક આપે છે, જ્યારે SFML નવા નિશાળીયા માટે વધુ વપરાશકર્તા મૈત્રીપૂર્ણ છે.
શું હું C++ માં 2D રમતો માટે OpenGL નો ઉપયોગ કરી શકું?
હા, OpenGL શક્તિશાળી રેન્ડરિંગ ક્ષમતાઓ પ્રદાન કરે છે, પરંતુ તેની સરખામણીમાં તેને વધુ સેટઅપની જરૂર છે SDL2 અથવા SFML.
શું આ ફ્રેમવર્ક ક્રોસ-પ્લેટફોર્મ ડેવલપમેન્ટ માટે યોગ્ય છે?
હા, પુસ્તકાલયો ગમે છે SDL2, SFML, અને Cocos2d-x Windows, macOS અને Linux સહિત બહુવિધ પ્લેટફોર્મને સપોર્ટ કરે છે. 🚀

2D ગેમ્સ વિકસાવવા પર અંતિમ વિચારો

2D ગેમ બનાવવી અથવા Windows ડેસ્કટોપ એપ્લિકેશનમાં એમ્બેડ કરવું એ SDL2, SFML અને Qt જેવા ફ્રેમવર્ક સાથે સુલભ અને કાર્યક્ષમ છે. આ સાધનો વિકાસકર્તાઓને કોર મિકેનિક્સને ફરીથી શોધવાને બદલે ગેમપ્લે અને ડિઝાઇન પર ધ્યાન કેન્દ્રિત કરવા સક્ષમ કરે છે. 🎮

C++ કુશળતા સાથે યોગ્ય સાધનોને જોડીને, વિકાસકર્તાઓ પોલીશ્ડ 2D ગેમિંગ અનુભવો બનાવી શકે છે. વ્યક્તિગત પ્રોજેક્ટ્સ અથવા વ્યાવસાયિક એપ્લિકેશનો માટે, હાલની લાઇબ્રેરીઓનો લાભ લેવાથી કામગીરી, સુરક્ષા અને સર્જનાત્મક સુગમતા સુનિશ્ચિત થાય છે. તમારી આગલી રમત વિકાસ યાત્રા શરૂ કરવા માટે તૈયાર છો? કોડિંગ સાહસ શરૂ થવા દો! 🚀

2D ગેમ ડેવલપમેન્ટ માટે સ્ત્રોતો અને સંદર્ભો

2D ગેમ ડેવલપમેન્ટ માટે SDL2 નો ઉપયોગ કરવાની માહિતી સત્તાવાર SDL દસ્તાવેજીકરણમાંથી સ્વીકારવામાં આવી હતી. સ્ત્રોતની મુલાકાત લો: SDL2 સત્તાવાર વેબસાઇટ .
SFML અને તેના ઉપયોગની સરળતા વિશેની વિગતો તેની વ્યાપક ઑનલાઇન માર્ગદર્શિકામાંથી મેળવવામાં આવી હતી. અહીં વધુ જાણો: SFML સત્તાવાર વેબસાઇટ .
GUI અને 2D ગેમ એમ્બેડિંગ માટે Qt ને એકીકૃત કરવાની આંતરદૃષ્ટિ Qt ના વિકાસકર્તા માર્ગદર્શિકામાંથી સંદર્ભિત કરવામાં આવી હતી. દસ્તાવેજોનું અન્વેષણ કરો: Qt સત્તાવાર દસ્તાવેજીકરણ .
Cocos2d-x એકીકરણ તકનીકો અને તેના મોડ્યુલર લક્ષણો તેના સમુદાય સંસાધનો પર આધારિત હતા. અહીં ફ્રેમવર્ક ઍક્સેસ કરો: Cocos2d-x સત્તાવાર વેબસાઇટ .
રમતના વિકાસમાં C++ શ્રેષ્ઠ પ્રથાઓ પર સામાન્ય માર્ગદર્શન પ્રતિષ્ઠિત પ્રોગ્રામિંગ બ્લોગ્સ દ્વારા પ્રેરિત હતું. ઉદાહરણો જુઓ: LearnCpp .

વિન્ડોઝ ડેસ્કટોપ એપ્લિકેશનમાં 2D ગેમ બનાવવા અથવા એકીકૃત કરવા માટે C++ નો ઉપયોગ કરવો