Offscreen Rendering: vad är det, tekniker och tillämpning i applikationer

Vad är Offscreen Rendering?

Offscreen Rendering — är en metod för att rendera grafiskt innehåll till en mellanbuffert i videominnet, inte till den huvudsakliga rambufferten (framebuffer) som visas på skärmen. Resultatet av offscreen rendering sparas i en textur eller renderbuffer.

Huvudsyftet med offscreen rendering är flerpassrendering (multi-pass rendering). En komplex scen delas upp i flera pass: först renderas scenen till en textur (offscreen), sedan används denna textur som indata för nästa pass, och så vidare tills den slutliga bilden erhålls. Detta tillvägagångssätt möjliggör effekter som är omöjliga i ett enda pass.

Framebuffer Object (FBO)

Nyckelmekanismen för offscreen rendering i OpenGL ES är Framebuffer Object (FBO). FBO är en behållare till vilken texturbilder eller renderbuffer-objekt kan kopplas. Efter att FBO har kopplats, dirigeras alla efterföljande renderingskommandon till den kopplade texturen, inte till skärmen.

Hur fungerar Offscreen Rendering?

Offscreen Rendering realiseras genom att skapa ett separat rambufferobjekt, koppla en textur eller renderbuffer till det, växla renderingskontexten till denna FBO och utföra ritkommandon. Efter passet växlas kontexten tillbaka till den huvudsakliga rambufferten.

Typisk cykel för offscreen rendering

Processen består av tre steg: skapa FBO och koppla textur — rendera scenen till offscreen-textur — använda den erhållna texturen i nästa pass. GL_COLOR_ATTACHMENT0 bestämmer till vilken färgtextur renderingen ska utföras.

// Skapa en FBO för offscreen rendering (OpenGL ES 3.0)
GLuint fbo, offscreenTex;
glGenFramebuffers(1, &fbo);
glGenTextures(1, &offscreenTex);
glBindTexture(GL_TEXTURE_2D, offscreenTex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
               width, height, 0,
               GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER),
    GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
    offscreenTex, 0);

Tekniker för offscreen rendering

Offscreen Rendering används för ett brett spektrum av grafiska effekter. Varje teknik kräver ett eller flera offscreen-pass och en specifik FBO-konfiguration.

Render-to-Texture (RTT)

Grundläggande teknik där renderingsresultatet sparas i en textur för senare användning. Render-to-Texture används för att skapa minikartor, texturer för dynamiska objekt och förhandsvisualisering av komplexa material.

Flerpassrendering (Multi-pass)

Komplexa effekter (HDR, bloom, skärpedjup) kräver flera på varandra följande pass. Varje pass renderar scenen till en offscreen-textur, tillämpar ett filter och överför resultatet till nästa pass. Detta tillvägagångssätt möjliggör ackumulering av effekter utan kvalitetsförlust av den slutliga bilden.

Skuggkartor (Shadow Mapping)

Shadow Mapping — ett klassiskt exempel på användning av offscreen rendering. Skuggan skapas i två pass: först renderas scenen från ljuskällans perspektiv till en djuptextur (offscreen), sedan under huvudrenderingen jämförs varje fragment med denna djupkarta för att avgöra om det befinner sig i skugga.

Process för skugggenerering

Första passet: kameran placeras i ljuskällans position, scenen renderas till offscreen-bufferten, endast djup (depth) skrivs till texturen. Andra passet: huvudrendering med kontroll av varje fragment — om dess djup är större än värdet i djupkartan, blir fragmentet skuggat.

// Fragment Shader för skuggkartläggning
in vec4 vShadowCoord;
uniform sampler2D uShadowMap;

float calcShadow(vec4 coord) {
    vec3 uvw = coord.xyz / coord.w;
    float depth = texture(uShadowMap, uvw.xy).r;
    return (uvw.z > depth + 0.005) ? 0.3 : 1.0;
}

Prestanda för offscreen rendering

Offscreen Rendering lägger till extra GPU-pass, vilket ökar den totala beräkningsbelastningen och energiförbrukningen. Inom mobil utveckling är detta särskilt kritiskt: varje FBO-växling kräver pipeline-spolning (pipeline flush) och extra tid.

Prestandafaktorer

• Antal pass — varje extra pass renderar hela scenen, vilket fördubblar antalet bearbetade vertikaler och fragment.
• Upplösning av offscreen-textur — val av för hög upplösning ökar belastningen på minnesbandbredden.
• FBO-växling — frekventa byten av rambufferobjekt orsakar pipeline-stopp och minskar GPU-användningen.

Optimering av offscreen rendering

För mobila enheter rekommenderas: använd renderbuffer istället för textur om resultatets läsning inte krävs (endast djuppass); välj minsta nödvändiga upplösning för offscreen-texturer; slå ihop pass där det är möjligt via MRT (Multiple Render Targets).

Kodexempel för Offscreen Rendering

Offscreen Rendering på olika plattformar realiseras genom egna API:er. Låt oss titta på exempel för OpenGL ES och Apple Metal.

Exempel på OpenGL ES 3.0: rendering till textur

// FBO-inställning och rendering av scen till textur
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glViewport(0, 0, texWidth, texHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(offscreenProgram);
glBindVertexArray(sceneVAO);
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, 0);
// Växla tillbaka till standardrambufferten
glBindFramebuffer(GL_FRAMEBUFFER, 0);

Exempel på Metal (iOS)

// Metal: offscreen renderingspass till textur
MTLRenderPassDescriptor passDesc = [MTLRenderPassDescriptor renderPassDescriptor];
passDesc.colorAttachments[0].texture = offscreenTexture;
passDesc.colorAttachments[0].loadAction = MTLLoadActionClear;
passDesc.colorAttachments[0].clearColor =
    MTLClearColorMake(0.0, 0.0, 0.0, 0.0);

id<MTLCommandBuffer> cmdBuffer = [commandQueue commandBuffer];
id<MTLRenderCommandEncoder> enc =
    [cmdBuffer renderCommandEncoderWithDescriptor:passDesc];
[enc drawIndexedPrimitives:MTLPrimitiveTypeTriangle
             indexCount:indexCount
              indexType:MTLIndexTypeUInt16
            indexBuffer:indexBuffer
      indexBufferOffset:0];
[enc endEncoding];