CODEWITHSUNDEEP
memoryopengl-escudawebgl
Marco A.
Marco A.

Reputation: 43662

WebGL - rendering a buffer from memory

I'm a newbie with webgl, is it possible to read a buffer from host memory (RAM) and render it? Or perhaps to read a buffer from a CUDA buffer and render it. I can do the first in openGL but I'm wondering if I can do that in webGL

Edit: I'm trying to be more precise in what I want to do..

I have a RGBA buffer with an image which might immediately be rendered on a GL context with glDrawPixels. This was produced by a CUDA code (so the buffer was originally on the gpu memory). Is there any way to visualize this into a webGL window?

Upvotes: 1

Views: 1404

Answers (2)

david van brink
david van brink

Reputation: 3652

Here's an excerpt from http://omino.com/experiments/webgl/OmGl.js which is the meat of a "drawtexture" method that renders a JavaScript array onto a webgl canvas.

A simple instance of its use it at http://omino.com/experiments/webgl/manualTexture.html. (It references some helpers in OmGl.js; hopefully clear enough, though.)

Hope that helps!

var _omglDrawTextureProgGl = null;
var _omglDrawTextureProg = null;
var _omglPosBuffer = null;

/* 
 * fill the current frame buffer with the texture.
 * Right up to the edges.
 * you can specify which texture unit, if you like.
 * reduce thrashing maybe.
 *
 * pass in your own
 */
OmGl.drawTexture = function drawTexture(gl,texture,textureUnit,prog)
{

if(!textureUnit)
    textureUnit = 0;
if(!prog)
{
    if(gl != _omglDrawTextureProgGl || !_omglDrawTextureProg)
    {
        var dtvs = "attribute vec2 pos;"
                 + "varying vec2 unitPos;"
                 + "void main() {"
                 + " unitPos = (pos.xy + 1.0) / 2.0;"
                 + " gl_Position = vec4(pos,0,1);"
                 + "}";
        var dtfs = "precision mediump float;"
                 + "uniform sampler2D uSampler;"
                 + "varying vec2 unitPos;"
                 + "void main() {"
                 + " gl_FragColor = texture2D(uSampler, unitPos);"
                 + "}";
        _omglDrawTextureProg = OmGl.linkShaderProgram(gl,dtvs,dtfs);
        _omglDrawTextureProgGl = gl;
    }
    prog = _omglDrawTextureProg;
}
gl.useProgram(prog);

// Two triangles which fill the entire canvas.
var posPoints = [
    -1,-1,
    1,-1,
    1,1,
    -1,-1,
    1,1,
    -1,1
];

gl.activeTexture(gl.TEXTURE0 + textureUnit);
gl.bindTexture(gl.TEXTURE_2D, texture);

var z = gl.getUniformLocation(prog, "uSampler");
gl.uniform1i(z, textureUnit);
_omglPosBuffer = OmGl.setAttributeFloats(gl, prog, "pos", 2, posPoints, _omglPosBuffer);
gl.clear(gl.DEPTH_BUFFER_BIT);
gl.drawArrays(gl.TRIANGLES, 0, posPoints.length / 2);
}

(edit -- updated the code at http://omino.com/experiments/webgl/manualTexture.html to be much cleaner.)

Upvotes: 1

datenwolf
datenwolf

Reputation: 162317

If you mean some JavaScript buffer by "host memory", then yes: You upload that into a WebGL buffer object and do whatever you want with it then. There's no CUDA interaction for WebGL. And you can't just "grab" any other process's memory for your things. Memory protection is a good thing.

Please be a bit more specific at what you want to do.

Update due to comment.

You think you may have a RGBA buffer, but you don't. Some other process has or had this buffer, but as far as WebGL is concerned, this buffer doesn't exist. It's part of a different process, which memory (and the system makes no difference between CPU and GPU memory there) is (or at least should be) protected from the access of other processes.

Think about it: If your browser (via WebGL) could access random stuff that resides in part of your system's memory that don't belong to it, this would hugely impair security. When it comes to regular OpenGL you are actually able to look into the uninitialized parts of memory to see what was there before. But for WebGL, being an Internet technology, a lot of checking is done, that you can't reach outside your sandbox. Heck, there were even new extensions introduced to make OpenGL more robust against data exfiltration and GPU based attack vectors.

It goes even so far, that in WebGL not only the memory is protected between processes, but also between WebGL instances, which may run in the same process.

Upvotes: 4

Related Questions