Как использовать текстуру SDL2 в качестве обновления холста? - PullRequest
Новая
       31

Как использовать текстуру SDL2 в качестве обновления холста?

4 голосов
/ 22 мая 2019

Я пытаюсь создать динамический плоттер в SDL2 для встроенного проекта. В настоящее время код выполняется на обеих архитектурах, x86 и ARM. На x86 у меня работает плотно работающий плоттер, однако на ARM он работает очень медленно на доли кадров, которые я получаю на x86. Я почти уверен, что это происходит потому, что я перерисовываю каждый пиксель на поверхности, что приводит к сильному перегреву встроенного устройства.

Я пытался отобразить новый контент в текстуру, скопировать его в средство визуализации и затем выполнить рендеринг, но это не сработало вообще.

Из-за двойной буферизации мне приходится очищать каждый кадр. В противном случае я буду «сбрасывать» изменения. Но мне также нужно рендерить старые точки данных и перезаписывать их только тогда, когда плоттер снова достигает их.

Есть ли способ в SDL2 сохранить эти точки данных на каком-то холсте и добавить (перерисовать) только что добавленные?

Вот мой исходный код:

Plotter.cpp 

#include <SDL2/SDL.h>
#include <stdio.h>
#include "PlotterHelper.h"

/*Implementation*/
int main(int arhc, char * argv[])
{
    //Top and bottom viewport
    SDL_Rect topViewport;
    SDL_Rect bottomViewport;
    topViewport = CreateViewPort(0,0, SCREEN_WIDTH, (SCREEN_HEIGHT/2));
    bottomViewport = CreateViewPort(0,(SCREEN_HEIGHT/2), SCREEN_WIDTH, SCREEN_HEIGHT/2);

    float timeFrame = 4.0;
    int updateWidth = round(SCREEN_WIDTH/(60.0 * timeFrame));


    uint8_t backgroundColor = 0xff;

    int delayTime = 0;
    int sinusScale = 0;
    int rectWidth = RECT_WIDTH;
    bool rectEnd = false;

    SDL_Point points[SCREEN_WIDTH] = {0,0};
    int pointPosition = 0;

    if (!init())
    {
        printf("Init failed!\n");
    }
    else
    {

        SDL_ShowCursor(SDL_DISABLE);
        //Main lopp flag
        bool quit = false;
        //Event handler
        SDL_Event event;

        //While application is running
        while(!quit)
        {
            //Handle events on queue
            while (SDL_PollEvent( &event) != 0)
            {
                //User requests quit
                if(event.type == SDL_QUIT)
                {
                    quit = true;
                }
                else if(event.type == SDL_KEYDOWN)
                {
                    switch(event.key.keysym.sym)
                    {
                    case SDLK_w:
                        delayTime += 50;
                        if(delayTime > 5000)
                            delayTime = 5000;
                        break;
                    case SDLK_s:
                        delayTime -= 50;
                        if(delayTime < 0)
                            delayTime = 0;
                        break;
                    case SDLK_d:
                        timeFrame -= 1;
                        if(timeFrame < 1)
                            timeFrame = 1.0;
                        updateWidth = round(SCREEN_WIDTH/(60.0 * timeFrame));
                        printf("timeFrame = %lf\n", timeFrame);
                        break;
                    case SDLK_a:
                        timeFrame += 1;
                        if(timeFrame > 44)
                            timeFrame = 44.0;
                        updateWidth = round(SCREEN_WIDTH/(60.0 * timeFrame));
                        printf("timeFrame = %lf\n", timeFrame);
                        break;
                    case SDLK_r:
                        if(backgroundColor == 0x3f)
                            break;
                        else
                        {
                            ++backgroundColor;
                            break;
                        }
                    case SDLK_f:
                        if(backgroundColor == 0x00)
                                break;
                        else
                        {
                            --backgroundColor;
                            break;
                        }
                    }
                }
            }

            //Reset Plotter when the end of the window was reached
            if(pointPosition > SCREEN_WIDTH-1)
            {
                pointPosition = 0;
                sinusScale = (rand() % 100 + 1) - 50;
                rectWidth = RECT_WIDTH;
                rectEnd = false;
            }

            //Handler eraser when he reaches end of window
            if(((SCREEN_WIDTH-1) - pointPosition) < RECT_WIDTH)
            {
                rectWidth = (SCREEN_WIDTH -1) - pointPosition;
                rectEnd = true;

            }


            //Clear screen
            SDL_SetRenderDrawColor(gRenderer, backgroundColor, backgroundColor, backgroundColor, 0xff);
            SDL_RenderClear(gRenderer);


            //Draw top viewport
            SDL_RenderSetViewport( gRenderer, &topViewport );

            SDL_SetRenderDrawColor(gRenderer, 0x00, 0x66, 0x00, 0xff);
            for(int iterator = 0; iterator <= SCREEN_WIDTH -1; ++iterator)
            {
                SDL_RenderDrawLine(
                        gRenderer,
                        points[iterator].x,
                        0,
                        points[iterator].x,
                        SCREEN_HEIGHT/2);
            }

            PlotEraser(rectEnd, backgroundColor, rectWidth,points[pointPosition].x );

            //raw bottom viewport
            SDL_RenderSetViewport( gRenderer, &bottomViewport );

            SDL_SetRenderDrawColor(gRenderer, 0x00, 0x66, 0x00, 0xff);
            for(int iterator = 0; iterator <= SCREEN_WIDTH -1; ++iterator)
                {
                    SDL_RenderDrawLine(
                            gRenderer,
                            points[iterator].x,
                            SCREEN_HEIGHT/2,
                            points[iterator].x,
                            points[iterator].y);
                }

            PlotEraser(rectEnd, backgroundColor, rectWidth,points[pointPosition].x );


            for(int iterator = pointPosition; iterator <= pointPosition + updateWidth; ++iterator)
            {
                points[iterator].x = iterator;
                points[iterator].y = round(((SCREEN_HEIGHT/4 )* sin(iterator/(100.0+sinusScale))) + SCREEN_HEIGHT/4);
            }
            pointPosition += updateWidth;

            //Update Screen
            SDL_RenderPresent(gRenderer);

            SDL_Delay(delayTime);
        }

    }

    //Free resources and close SDL
    close();

    return 0;
}

/*End of File*/

PlotterHelper.cpp 

/*Includes*/

#include "PlotterHelper.h"

SDL_Window  * gWindow = NULL;
SDL_Renderer * gRenderer = NULL;
SDL_Renderer * intermediate = NULL;

/*Implementation*/

/*********************************************************************
 *********************************************************************
 *********************************************************************
*/
bool init()
{
    //Init  flag
    bool success = true;

    //Init SDL
    if(SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        printf( "SDL could not initialize! SDL_Error: %s\n", SDL_GetError() );
        success = false;
    }
    else
    {
        //Set texture filtering to linear
        if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
        {
            printf( "Warning: Linear texture filtering not enabled!" );
        }

        //Set VSYNC
        if( !SDL_SetHint( SDL_HINT_RENDER_VSYNC, "1" ) )
        {
            printf( "Warning: VSYNC not enabled!" );
        }

        //Create window
        gWindow = SDL_CreateWindow(
                "SDL Plotter",
                SDL_WINDOWPOS_UNDEFINED,
                SDL_WINDOWPOS_UNDEFINED,
                SCREEN_WIDTH,
                SCREEN_HEIGHT,
                SDL_WINDOW_SHOWN );
        if (NULL == gWindow)
        {
            printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );
            success = false;
        }
        else
        {
            //Create renderer for window
            gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED );
            if(NULL == gRenderer)
            {
                printf("Renderer could not be created! SDLError: %s\n", SDL_GetError());
                success = false;
            }
            else
            {
                //Initialise renderer colour
                SDL_SetRenderDrawColor(gRenderer, 0xff, 0xff, 0xff, 0xff);
            }

        }
    }
    return success;
}

/*********************************************************************
 *********************************************************************
 *********************************************************************
*/
void close()
{
    //Destroy window
    SDL_DestroyRenderer(gRenderer);
    SDL_DestroyWindow(gWindow);
    gRenderer = NULL;
    gWindow = NULL;

    //Quit SDL subsystems
    SDL_Quit();
}

/*********************************************************************
 *********************************************************************
 *********************************************************************
*/

SDL_Rect CreateViewPort(int x, int y, int w, int h)
{
    SDL_Rect Viewport;
    Viewport.x = x;
    Viewport.y = y;
    Viewport.w = w;
    Viewport.h = h;

    return Viewport;
}
/*********************************************************************
 *********************************************************************
 *********************************************************************
*/
void PlotEraser(bool rectEnd, uint8_t backgroundColor, int rectWidth, int x)
{
    SDL_Rect fillRectBot = {x, 0, rectWidth, SCREEN_HEIGHT/2};

    SDL_SetRenderDrawColor(gRenderer, backgroundColor, backgroundColor, backgroundColor, 0xff);
    SDL_RenderFillRect(gRenderer, &fillRectBot);

    if(rectEnd)
    {
        int startRecWidth = RECT_WIDTH - rectWidth;

        SDL_Rect startRec = {0, 0, startRecWidth, SCREEN_HEIGHT/2};
        SDL_RenderFillRect(gRenderer, &startRec);
    }
}

/*End of File*/

PlotterHelper.h 



#ifndef PLOTTER_HELPER_H_
#define PLOTTER_HELPER_H_

#include <SDL2/SDL.h>
#include <stdio.h>
#include <cmath>
#include <string>
/*Globals*/

//Screen  constants
const int SCREEN_WIDTH = 1024;
const int SCREEN_HEIGHT = 768;
const int RECT_WIDTH = 10;

//The window we'll be rendering to
extern SDL_Window * gWindow;
//The window renderer
extern SDL_Renderer * gRenderer;
extern SDL_Renderer * intermediate;


/*Prototypes*/
/*********************************************************************
 *********************************************************************
 *********************************************************************
*/
//Starts up SDL and creates window
bool init();
/*********************************************************************
 *********************************************************************
 *********************************************************************
*/
//Free media and shut down SDL
void close();
/*********************************************************************
 *********************************************************************
 *********************************************************************
*/
//CreateVieport
SDL_Rect CreateViewPort(int x, int y, int w, int h);
/*********************************************************************
 *********************************************************************
 *********************************************************************
*/
//Plot Eraser
void PlotEraser(bool rectEnd, uint8_t backgroundColor, int rectWidth, int x);
#endif /* PLOTTER_HELPER_H_ */
/*End of File*/

1 Ответ

3 голосов
/ 30 мая 2019

Возможно, у вас есть несколько вариантов, которые могут помочь:

Использовать цель рендеринга текстуры

Вы должны быть в состоянии сделать это, используя "текстуру цели рендеринга". Это SDL_Texture, который вы создаете (см. SDL_CreateTexture) с флагом SDL_TEXTUREACCESS_TARGET.

Вы бы нарисовали новые точки для этой текстуры, вызвав SDL_SetRenderTarget и передав эту текстуру, прежде чем рендерить точки.

Ваш главный цикл должен будет вызвать SDL_SetRenderTarget и передать nullptr, чтобы восстановить окно в качестве цели рендеринга. Затем вы визуализируете свою текстуру в окне каждый кадр.

Документация SDL содержит небольшой пример демонстрации использования целевой текстуры рендеринга.

обновление до SDL 2.0.9 и использование пакетного рендеринга

последняя версия SDL 2 поддерживает пакетное рендеринг, если вы установили SDL_HINT_RENDER_BATCHING (SDL_SetHint(SDL_HINT_RENDER_BATCHING, "1");). Вы должны использовать SDL_CreateWindowAndRenderer(), чтобы убедиться, что дозирование включено.

Это может ничего не делать, если ваша платформа не поддерживает аппаратное ускорение. Вы можете использовать это вместе с целью рендеринга. Прочтите о пакете рендеринга SDL здесь .

Пакетная обработка ваших баллов / баллов

Это отдельно от пакетного рендеринга и должно работать на любой версии SDL 2.

Если вы можете, соберите все свои прямоугольники / точки в массив, который вы можете использовать SDL_RenderDrawPoints или SDL_RenderDrawRects, чтобы SDL выполнял их все сразу, что должно улучшить производительность, даже если у вас нет аппаратного ускорения. Это можно использовать вместе с целью рендеринга.

Кювет SDL_Renderer / SDL_Texture

Если вашему устройству не хватает аппаратного ускорения, то может быть быстрее отказаться от SDL_Renderer и вместо этого использовать SDL_GetWindowSurface, чтобы получить SDL_Surface для окна, и использовать SDL_BlitSurface (или вручную устанавливать пиксели через surface->pixels) для рисования непосредственно к этому тогда обновите окно с SDL_UpdateWindowSurface. См. Также SDL_UpdateWindowSurfaceRects, чтобы узнать, как обновить только изменяемые прямоугольники для повышения производительности.

Вам необходимо ознакомиться с SDL_Surface, поскольку вам нужно будет проверить формат пикселей поверхности окна, чтобы правильно его обновить, если вы решите напрямую манипулировать пикселями.

...