pbrtools/nodegl.js

laya pbr tools

'use strict';
var fs = require('fs');
var parsehdr = require('./parse-hdr');
var PNG = require('pngjs').PNG;

/**
 * @param buff {ArrayBuffer}
 */
function saveAsPng(file, buff, width, height) {
    var png = new PNG({
        filterType: 4,
        width: width,
        height: height,
        inputHasAlpha: true
    });
    png.data = new Buffer(new Uint8Array(buff));
    png.pack()
        .pipe(fs.createWriteStream(file))
        .on('finish', function () {
            console.log('save end:' + file);
        });
}

function loadShader(gl, shaderSource, shaderType) {
    var shader = gl.createShader(shaderType);
    gl.shaderSource(shader, shaderSource);
    gl.compileShader(shader);

    // Check the compile status
    var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
    if (!compiled) {
        // Something went wrong during compilation; get the error
        var lastError = gl.getShaderInfoLog(shader);
        console.log('*** Error compiling shader "' + shader + '":' + lastError);
        gl.deleteShader(shader);
        return null;
    }

    return shader;
}

function createProgram(gl, shaders, opt_attribs, opt_locations) {
    var program = gl.createProgram();
    shaders.forEach(function (shader) {
        gl.attachShader(program, shader);
    });
    if (opt_attribs) {
        opt_attribs.forEach(function (attrib, ndx) {
            gl.bindAttribLocation(
                program,
                opt_locations ? opt_locations[ndx] : ndx,
                attrib);
        });
    }
    gl.linkProgram(program);

    // Check the link status
    var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
    if (!linked) {
        // something went wrong with the link
        var lastError = gl.getProgramInfoLog(program);
        console.log('Error in program linking:' + lastError);

        gl.deleteProgram(program);
        return null;
    }
    return program;
}

function createProgramFromSources(gl, shaderSources, opt_attribs, opt_locations) {
    var defaultShaderType = [
        'VERTEX_SHADER',
        'FRAGMENT_SHADER'
    ];

    var shaders = [];
    for (var ii = 0; ii < shaderSources.length; ++ii) {
        shaders.push(loadShader(gl, shaderSources[ii], gl[defaultShaderType[ii]]));
    }
    return createProgram(gl, shaders, opt_attribs, opt_locations);
}


var vertex_src = `
attribute vec2 a_position;
void main() {
    gl_Position = vec4(a_position, 0, 1);
}`;


var fragment_src = `
void main() {
gl_FragColor = vec4(0, 1, 0, 1);  
}`;


//Create context 
var width = 1024;
var height = 512;
var gl = require('gl')(width, height, { preserveDrawingBuffer: true });

//Clear screen to red 
gl.clearColor(1, 0, 0, 1);
gl.clear(gl.COLOR_BUFFER_BIT);

// setup a GLSL program
var program = createProgramFromSources(gl, [vertex_src, fragment_src]);

if (!program) {
    return;
}

gl.useProgram(program);

// look up where the vertex data needs to go.
var positionLocation = gl.getAttribLocation(program, 'a_position');

// Create a buffer and put a single clipspace rectangle in
// it (2 triangles)
var buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.bufferData(
    gl.ARRAY_BUFFER,
    new Float32Array([
        -1.0, -1.0,
        1.0, -1.0,
        -1.0, 1.0,
        -1.0, 1.0,
        1.0, -1.0,
        1.0, 1.0]),
    gl.STATIC_DRAW);
gl.enableVertexAttribArray(positionLocation);
gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0);

// draw
gl.drawArrays(gl.TRIANGLES, 0, 6);

//Write output as a PPM formatted image 
var pixels = new Uint8Array(width * height * 4);
gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
//process.stdout.write(['P3\n# gl.ppm\n', width, " ", height, '\n255\n'].join(''))
saveAsPng('d:/temp/fff.png', pixels.buffer, width, height);