标签: render-to-texture

我正在尝试使用ffmpeg渲染帧并将其从视频转换为OpenGL纹理以放置在四边形上.我已经筋疲力尽了谷歌并没有找到答案,我找到了答案,但似乎没有一个有效.

基本上,我avcodec_decode_video2()用来解码帧然后sws_scale()将帧转换为RGB然后glTexSubImage2D()从它创建一个openGL纹理,但似乎无法使任何东西工作.

我确保"目标"AVFrame在SWS上下文设置中具有2维的功能.这是我的代码:

SwsContext *img_convert_ctx = sws_getContext(pCodecCtx->width,
                pCodecCtx->height, pCodecCtx->pix_fmt, 512,
                256, PIX_FMT_RGB24, SWS_BICUBIC, NULL,
                NULL, NULL);

//While still frames to read
while(av_read_frame(pFormatCtx, &packet)>=0) {
    glClear(GL_COLOR_BUFFER_BIT);

    //If the packet is from the video stream
    if(packet.stream_index == videoStream) {
        //Decode the video
        avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);

        //If we got a frame then convert it and put it into RGB buffer
        if(frameFinished) {
            printf("frame finished: %i\n", number);
            sws_scale(img_convert_ctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);

            glBindTexture(GL_TEXTURE_2D, texture);
            //gluBuild2DMipmaps(GL_TEXTURE_2D, …

我一直无法找到简单的代码来将场景渲染到OpenGL ES中的纹理(特别是对于iPhone,如果这很重要).我有兴趣知道以下内容:

1. 如何在OpenGL ES中将场景渲染到纹理？
2. 必须使用哪些参数来创建能够成为OpenGL ES渲染目标的纹理？
3. 将此渲染纹理应用于其他基元是否有任何影响？

我通过帧缓冲对象渲染到纹理,当我绘制透明图元时,图元与在单个绘制步骤中绘制的其他图元正确混合,但它们没有与帧缓冲区的先前内容正确混合.

有没有办法正确地将纹理内容与新数据混合？

编辑:更多信息需要,我会尝试更清楚地解释;

我使用的blendmode是GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA.(我相信这通常是标准的混合模式)

我正在创建一个跟踪鼠标移动的应用程序.它绘制了将前一个鼠标位置连接到当前鼠标位置的线条,因为我不想在每个帧上再次绘制线条,我想我会绘制一个纹理,从不清除纹理然后只绘制一个矩形它上面的纹理来显示它.

这一切都很好,除了当我在纹理上绘制alpha小于1的形状时,它不能与纹理的先前内容正确混合.假设我有一些黑色线条,alpha = .6被绘制到纹理上.一对夫妇画了一个周期之后,我在那些线上画了一个alpha = .4的黑色圆圈.圆圈"下方"的线条被完全覆盖.虽然圆圈不是扁平的黑色(它与白色背景正确混合),但圆圈下方没有"深色线条",正如您所期望的那样.

但是,如果我在同一帧中绘制线条和圆圈,它们会正确混合.我的猜测是纹理不会与之前的内容混合.它就像它只与glclearcolor混合.(在这种情况下,<1.0f,1.0f,1.0f,1.0f>)

我需要一种渲染到GL_TEXTURE_EXTERNAL_OES纹理的方法.我尝试将纹理绑定到帧缓冲区但我得到了GL_INVALID_ENUM错误.以下是一些示例代码:

glEnable(GL_TEXTURE_EXTERNAL_OES);
glGenFramebuffersOES(1, &frameBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER, frameBuffer); 
glFramebufferTexture2DOES(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_EXTERNAL_OES, outTexHandle, 0); // I get GL_INVALID_ENUM here
// set viewport, uniforms and draw 
glBindFramebufferOES(GL_FRAMEBUFFER, 0);
glDisable(GL_TEXTURE_EXTERNAL_OES);

我的最终目标是通过在SurfaceTexture上应用一些过滤器来修改相机框架.因此,我的着色器程序同时具有输入和输出相同的GL_TEXTURE_EXTERNAL_OES纹理.这可能吗？如果没有,有没有解决方法？对于我的应用程序,输出纹理必须是GL_TEXTURE_EXTERNAL_OES,我不能使用GL_TEXTURE_2D纹理.

是否可以在iPhone(2G及更早版本)上使用OpenGL ES 1.1渲染纹理？如果我将纹理绑定为渲染缓冲区,则它必须是渲染缓冲区的大小,而不是POT大小.但OpenGL ES 1.1要求纹理为POT.

也许它不能在ES 1.1上完成？

编辑:总结我想做的事情,更简洁:

将大小纹理渲染为wi,hi输出纹理wo,ho,以便保持输入纹理的宽高比,并且它适合输出纹理,如果宽高比不同,则最终使用黑色边框.为此我想使用透视投影,因为我可以旋转或应用其他变换到输入纹理.

然后我希望这个输出纹理显示在屏幕上,大小ws, hs,hs可能大于ws.再次,保持纵横比和适合黑色边框.这里正交投影应该足够,因为只需要渲染到屏幕,不需要进一步处理.

我想在没有黑客的情况下这样做,为了让我的生活更轻松,以防我以后想要旋转,缩放原始纹理.我可以通过试验和错误来计算如何修改参数以获得我现在想要的东西,但宁愿按照预期的方式使用每个矩阵.

我试图在iPhone上进行一些图像处理,基于Apple的GLImageProcessing示例.

最后,我想要做的是将图像加载到纹理中,执行示例代码中的一个或多个操作(色调,饱和度,亮度等),然后将结果图像读回以供以后处理/保存.在大多数情况下,这永远不需要触摸屏幕,所以我认为FBO可能是要走的路.

首先,我拼凑了一个小例子,创建一个屏幕外FBO,绘制它,然后将数据作为图像读回.当它在模拟器中完美运行时我感到很兴奋,然后因为我意识到我在实际设备上只有一个黑屏而感到沮丧.

免责声明:我的OpenGL已经足够老了,我已经对OpenGL ES有了相当多的学习曲线,而且我从来都不是一个纹理向导.我知道该设备在帧缓冲访问方面具有与模拟器不同的特性(强制性的屏幕外FBO和设备上的交换,模拟器上的直接访问),但我无法找到我做错了什么,即使经过相当广泛的搜索.

有什么建议？

// set up the offscreen FBO sizes

int renderBufferWidth = 1280;
int renderBufferHeight = 720;

// now the FBO
GLuint  fbo = 0;
glGenFramebuffersOES(1, &fbo);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, fbo);

GLuint  renderBuffer = 0;
glGenRenderbuffersOES(1, &renderBuffer);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, renderBuffer);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES,
                         GL_RGBA8_OES,
                         renderBufferWidth,
                         renderBufferHeight);

glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
                             GL_COLOR_ATTACHMENT0_OES,
                             GL_RENDERBUFFER_OES,
                             renderBuffer);

GLenum status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
if (status != GL_FRAMEBUFFER_COMPLETE_OES) {
    NSLog(@"Problem with OpenGL framebuffer after specifying color render buffer: %x", status);
}

// throw in a test drawing  
glClearColor(0.5f, 0.5f, 0.5f, 1.0f); …

XNA noob在这里,每天都在学习.我刚刚研究了如何使用RenderTarget2D将多个纹理合成为一个.然而,虽然我可以将RenderTarget2D用作Texture2D用于大多数目的,但是有一个关键的区别:当后缓冲区调整大小时这些渲染的纹理会丢失(毫无疑问,在其他情况下,例如内存不足的图形设备).

目前,我只是将完成的RenderTarget2D复制到一个新的非易失性Texture2D对象中.不过,我这样做的代码非常难看.有没有更优雅的方式来做到这一点？也许我只是累了,但我无法在Google或SO上找到答案.

略有简化:

public static Texture2D  MergeTextures(int width, int height, IEnumerable<Tuple<Texture2D, Color>> textures)
    {
    RenderTarget2D  buffer = new RenderTarget2D(_device, width, height);

    _device.SetRenderTarget(buffer);
    _device.Clear(Color.Transparent);

    SpriteBatch  spriteBatch = new SpriteBatch(_device);
    spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied);

    // Paint each texture over the one before, in the appropriate color
    Rectangle  rectangle = new Rectangle(0, 0, width, height);
    foreach (Tuple<Texture2D, Color> texture in textures)
        spriteBatch.Draw(texture.Item1, rectangle, texture.Item2);

    spriteBatch.End();
    _device.SetRenderTarget((RenderTarget2D)null);

    // Write the merged texture to a Texture2D, so we don't lose it when resizing the back buffer …

为了提高我的OpenGL ES应用程序在iPad上的性能,我计划在纹理上绘制一个很少更新但是渲染时重的元素,所以除非必须重新绘制元素,否则我可以使用纹理.但是,虽然纹理在模拟器和设备上都能正确映射,但只有在模拟器上才能实际渲染到纹理中.

以下是我添加到项目中的代码.在设置场景时,我创建了缓冲区和所需的纹理:

int width = 768;
int height = 270;

// Prepare texture for off-screen rendering.
glGenTextures(1, &wTexture);
glBindTexture(GL_TEXTURE_2D, wTexture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
glClearColor(.9f, .3f, .6f, 1.0f); // DEBUG
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
  GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);

// Depth attachment buffer, always needed.
glGenRenderbuffersOES(1, &wDepth);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, wDepth);
glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES,
  width, height);
glBindRenderbufferOES(GL_RENDERBUFFER_OES, 0);

// Create FBO for render-to-texture.
glGenFramebuffersOES(1, &wBuffer);
glBindFramebufferOES(GL_FRAMEBUFFER_OES, wBuffer);
glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES,
  GL_COLOR_ATTACHMENT0_OES, …

我找到了一些被问过的地方,但我还没有找到一个好的答案.

问题:我想要渲染到纹理,然后我想将渲染的纹理绘制到屏幕IDENTICALLY,如果我跳过渲染到纹理步骤并且只是直接渲染到屏幕,它将如何显示.我目前正在使用混合模式glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA).我也有glBlendFuncSeparate来玩.

我希望能够将部分透明的重叠项呈现给此纹理.我知道混合功能目前正在弄乱基于Alpha的RGB值.我已经看到一些模糊的建议使用"预乘alpha",但描述的含义很差.我在photoshop中制作png文件,我知道它们有一个半透明的位,你不能像TGA一样独立编辑alpha通道.如果需要,我可以切换到TGA,虽然PNG更方便.

现在,为了这个问题,我们假设我们没有使用图像,而是使用带有alpha的全彩色四边形.

一旦我将场景渲染到纹理,我需要将该纹理渲染到另一个场景,并且我需要将纹理再次呈现为部分透明度.事情就是崩溃的地方.在之前的混合步骤中,我明确地改变了基于Alpha的RGB值,如果Alpha为0或1,则再次执行它,但如果它在中间,则结果是那些部分半透明像素进一步变暗.

玩混合模式我运气很少.我能做的最好就是渲染纹理:

glBlendFuncSeparate(GL_ONE,GL_ONE_MINUS_SRC_ALPHA,GL_ONE,GL_ONE);

我发现使用glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)多次渲染将近似正确的颜色(除非事情重叠).但这并不完美(正如您在下图中看到的那样,绿色/红色/蓝色框重叠的部分会变暗或累积alpha.(编辑:如果我在渲染中进行多次绘制以筛选部分而且仅渲染一次纹理,alpha累积问题消失,它确实有效,但为什么？!我不想为屏幕呈现相同的纹理数百次,以使其正确累积)

以下是一些详细说明问题的图像(多个渲染过程使用基本混合(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA),并且它们在纹理渲染步骤中多次渲染.右边的3个框渲染为100%红色,绿色或蓝色(0-255)但蓝色的阿尔法值为50%,红色的阿尔法值为25%,绿色的阿尔法值为75%:

那么,我想知道的细分:

1. 我将混合模式设置为:X？
2. 我将场景渲染为纹理.(也许我必须使用一些混合模式或多次渲染？)
3. 我将混合模式设置为:Y？
4. 我在现有场景上将纹理渲染到屏幕上.(也许我需要一个不同的着色器？也许我需要渲染纹理几次？)

期望的行为是,在该步骤结束时,最终的像素结果与我刚刚执行此操作相同:

1. 我将混合模式设置为:(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)
2. 我将我的场景渲染到屏幕上.

而且,为了完整性,这里有一些我的原始天真尝试的代码(只是定期混合):

    //RENDER TO TEXTURE.
    void Clipped::refreshTexture(bool a_forceRefresh) {
        if(a_forceRefresh || dirtyTexture){
            auto pointAABB = basicAABB();
            auto textureSize = castSize<int>(pointAABB.size());
            clippedTexture = DynamicTextureDefinition::make("", textureSize, {0.0f, 0.0f, 0.0f, 0.0f});
            dirtyTexture = false;
            texture(clippedTexture->makeHandle(Point<int>(), textureSize));
            framebuffer = renderer->makeFramebuffer(castPoint<int>(pointAABB.minPoint), textureSize, clippedTexture->textureId());
            {
                renderer->setBlendFunction(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                SCOPE_EXIT{renderer->defaultBlendFunction(); };

                renderer->modelviewMatrix().push();
                SCOPE_EXIT{renderer->modelviewMatrix().pop(); };
                renderer->modelviewMatrix().top().makeIdentity();

                framebuffer->start();
                SCOPE_EXIT{framebuffer->stop(); };

                const size_t renderPasses = 1; //Not …