c++ - एसडीएल रेंडरर क्या है?




sdl sdl-2 (2)

SDL_Window

SDL_Window वह संरचना है जिसमें खिड़की के बारे में सारी जानकारी होती है: आकार, स्थिति, पूर्ण स्क्रीन, सीमाएं इत्यादि।

SDL_Renderer

SDL_Renderer एक ऐसी संरचना है जो सभी प्रतिपादन को संभालती है। यह एक SDL_Window से जुड़ा हुआ है, इसलिए यह केवल उस SDL_Window भीतर प्रस्तुत कर सकता है। यह प्रतिपादन से संबंधित सेटिंग्स को ट्रैक करता है। SDL_Renderer से जुड़े कई महत्वपूर्ण फ़ंक्शन हैं

  • SDL_SetRenderDrawColor(renderer, r, g, b, a);
    यह उस रंग को सेट करता है जिसे आप स्क्रीन साफ़ करते हैं (नीचे देखें)

  • SDL_RenderClear(renderer);
    यह उपरोक्त ड्रॉ रंग सेट के साथ प्रतिपादन लक्ष्य को साफ़ करता है

  • SDL_RenderCopy(
    यह शायद वह फ़ंक्शन है जिसका आप सबसे अधिक उपयोग करेंगे, इसका उपयोग SDL_Texture को प्रस्तुत करने के लिए किया जाता है और इसमें निम्न पैरामीटर हैं:

    • SDL_Renderer* renderer,
      प्रतिपादन के लिए आप जिस रेंडरर का उपयोग करना चाहते हैं।
    • SDL_Texture* texture,
      वह बनावट जिसे आप प्रस्तुत करना चाहते हैं।
    • const SDL_Rect* srcrect, बनावट का वह हिस्सा जिसे आप प्रस्तुत करना चाहते हैं, नल अगर आप पूरे बनावट को प्रस्तुत करना चाहते हैं
    • const SDL_Rect* dstrect)
      जहां आप खिड़की में बनावट प्रस्तुत करना चाहते हैं। यदि इस SDL_Rect की चौड़ाई और ऊंचाई बनावट के आयामों से छोटी या बड़ी है, तो बनावट इस SDL_Rect अनुसार फैली SDL_Rect

  • SDL_RenderPresent(renderer);
    अन्य एसडीएल_रेंडर * फ़ंक्शंस एक छिपे हुए लक्ष्य को आकर्षित करता है। यह कार्य उन सभी को ले जाएगा और इसे रेंडरर से जुड़ी खिड़की में खींच देगा।

एसडीएल_Textures और एसडीएल_Surface

SDL_Renderer , SDL_Renderer प्रस्तुत SDL_TextureSDL_Texture एक तत्व की पिक्सेल जानकारी हैं। यह SDL_Surface का नया संस्करण है जो बहुत समान है। अंतर यह है कि SDL_Texture केवल एक struct युक्त पिक्सेल सूचना है, जबकि SDL_Texture पिक्सेल डेटा का एक कुशल, ड्राइवर-विशिष्ट प्रतिनिधित्व है।

आप एसडीएल_Surface * का उपयोग कर SDL_Texture में कनवर्ट कर सकते हैं

SDL_Texture* SDL_CreateTextureFromSurface(SDL_Renderer* renderer,
                                          SDL_Surface*  surface)

इसके बाद, एसडीएल_Surface का उपयोग कर मुक्त किया जाना चाहिए

SDL_FreeSurface( SDL_Surface* surface )

एक और महत्वपूर्ण अंतर यह है कि SDL_Texture सॉफ़्टवेयर प्रतिपादन (सीपीयू के माध्यम से) का उपयोग करता है जबकि SDL_Texture हार्डवेयर प्रतिपादन (GPU के माध्यम से) का उपयोग करता है।

SDL_Rect

एसडीएल में सबसे सरल संरचना। इसमें केवल चार शॉर्ट्स हैं। x, y जो स्थिति और w, h रखती है w, h चौड़ाई और ऊंचाई रखती है।

यह ध्यान रखना महत्वपूर्ण है कि 0, 0 एसडीएल में ऊपरी-बाएं कोने है। तो एक उच्च y -value का मतलब कम है, और निचले दाएं कोने में समन्वय x + w, y + h

आप मेरे blog. पर एसडीएल 2 के बारे में अधिक पढ़ सकते हैं blog.

मैं एसडीएल 2 के साथ शुरू कर रहा हूं और एसडीएल_ रेंडरर क्या समझने की कोशिश कर रहा हूं।

यह क्या है? यह क्या करता है? SDL_Renderer, SDL_Window, SDL_Surface और SDL_Texture और वे कैसे संबंधित हैं के बीच अंतर क्या है?

इस प्रारंभिक कोड को समझने की कोशिश करते समय मुझे इसके साथ समस्याएं थीं:

#include <iostream>
#include <SDL2/SDL.h>

int main()
{
    /* Starting SDL */
    if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
        std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl;
        return 1;
    }

    /* Create a Window */
    SDL_Window *window = SDL_CreateWindow("Hello World!", 100, 100, 640, 480, SDL_WINDOW_SHOWN);
    if (window == nullptr) {
        std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
        return 1;
    }

    /* Create a Render */
    SDL_Renderer *render = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if (render == nullptr) {
        std::cout << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
        return 1;
    }

    /* Load bitmap image */
    SDL_Surface *bmp = SDL_LoadBMP("./Tutorial/res/Lesson1/hello.bmp");
    if (bmp == nullptr) {
        std::cout << "SDL_LoadBMP Error: " << SDL_GetError() << std::endl;
        return 1;
    }

    /* Upload surface to render, and then, free the surface */
    SDL_Texture *texture = SDL_CreateTextureFromSurface(render, bmp);
    SDL_FreeSurface(bmp);
    if (texture == nullptr){
        std::cout << "SDL_CreateTextureFromSurface Error: " << SDL_GetError() << std::endl;
        return 1;
    }

    /* Draw the render on window */
    SDL_RenderClear(render); // Fill render with color
    SDL_RenderCopy(render, texture, NULL, NULL); // Copy the texture into render
    SDL_RenderPresent(render); // Show render on window

    /* Wait 2 seconds */
    SDL_Delay(5000);

    /* Free all objects*/
    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(render);
    SDL_DestroyWindow(window);

    /* Quit program */
    SDL_Quit();
    return 0;
}

मैं ट्विंकलेबियर ट्यूटोरियल (एसडीएल विकी पर सुझाया गया) का उपयोग कर रहा था और एसडीएल विकी दस्तावेज़ीकरण और कुछ किताबों पर भी देखा। लेकिन वे सभी मानते हैं कि मैं इन परिभाषाओं को जानता हूं।


SDL_Window को भौतिक पिक्सल के रूप में सोचें, और SDL_Renderer और सेटिंग / संदर्भ स्टोर करने के लिए एक जगह।

तो आप संसाधनों का एक गुच्छा बनाते हैं, और उन्हें रेंडरर से लटकाते हैं; और फिर जब यह तैयार हो, तो आप इसे सभी को एक साथ रखने और विंडो को परिणाम भेजने के लिए प्रस्तुतकर्ता को बताते हैं।





sdl-2