Home Reference Source

cables_dev/cables_ui/src/ui/components/overlay/overlaymeshes.js

  1. import { mat4, vec3 } from "gl-matrix";
  2. import { Framebuffer2, Geometry, Mesh, Shader, Uniform } from "cables-corelibs";
  3. import { DEG2RAD } from "cables-corelibs/cgl/cgl_utils.js";
  4. import { nl } from "cables-corelibs/cg/constants.js";
  5. import overlayShaderVert from "./overlaymeshes.vert";
  6. import { gui } from "../../gui.js";
  8. const helperMeshes = {};
  9. helperMeshes.count = 0;
  11. export default helperMeshes;
  13. helperMeshes.startFramebuffer = function (cgl)
  14. {
  15.     if (!helperMeshes.FB || !helperMeshes.FB.fb)
  16.     {
  17.         helperMeshes.FB = {};
  19.         helperMeshes.FB.fb = new Framebuffer2(cgl, 8, 8, {
  20.             "isFloatingPointTexture": false,
  21.             "depth": true,
  22.             "clear": false,
  23.             "multisampling": true,
  24.             "multisamplingSamples": 4,
  25.         });
  26.     }
  28.     if (helperMeshes.FB.oldWidth != cgl.getViewPort()[2] || helperMeshes.FB.oldHeight != cgl.getViewPort()[3])
  29.     {
  30.         helperMeshes.FB.fb.setSize(cgl.getViewPort()[2], cgl.getViewPort()[3]);
  31.         helperMeshes.FB.oldWidth = cgl.getViewPort()[2];
  32.         helperMeshes.FB.oldHeight = cgl.getViewPort()[3];
  33.     }
  35.     helperMeshes.FB.fb.renderStart(cgl);
  37.     if (cgl.frameCycler != helperMeshes.FB.oldFrameCycle)
  38.     {
  39.         cgl.gl.clearColor(0, 0, 0, 0);
  40.         cgl.gl.clear(cgl.gl.COLOR_BUFFER_BIT | cgl.gl.DEPTH_BUFFER_BIT);
  41.         helperMeshes.FB.oldFrameCycle = cgl.frameCycler;
  42.     }
  43. };
  45. helperMeshes.endFramebuffer = function (cgl)
  46. {
  47.     helperMeshes.FB.fb.renderEnd();
  48. };
  50. helperMeshes.getDefaultShader = function (cgl, options = {})
  51. {
  52.     let name = "defaultShader";
  54.     if (options.billboarded)name = "defaultShaderBillboard";
  56.     if (!helperMeshes[name])
  57.     {
  58.         helperMeshes[name] = new Shader(cgl, "marker shader");
  59.         helperMeshes[name].setSource(overlayShaderVert, Shader.getDefaultFragmentShader(0.6, 0.6, 0.6));
  60.         if (options.billboarded)helperMeshes[name].toggleDefine("BILLBOARD", true);
  61.     }
  62.     return helperMeshes[name];
  63. };
  65. helperMeshes.getSelectedShader = function (cgl, options = {})
  66. {
  67.     let name = "selectedShader";
  69.     if (options.billboarded)name = "selectedShaderBillboard";
  71.     if (!helperMeshes[name])
  72.     {
  73.         helperMeshes[name] = new Shader(cgl, "marker shader");
  74.         helperMeshes[name].setSource(overlayShaderVert, Shader.getDefaultFragmentShader(0, 1, 1));
  75.         if (options.billboarded)helperMeshes[name].toggleDefine("BILLBOARD", true);
  76.     }
  77.     return helperMeshes[name];
  78. };
  80. helperMeshes.drawCircle = function (op, size)
  81. {
  83.     /** @type {CglContext} */
  84.     const cgl = op.patch.cgl;
  86.     if (!helperMeshes.CIRCLE)
  87.     {
  88.         helperMeshes.CIRCLE = {};
  90.         helperMeshes.CIRCLE.vScale = vec3.create();
  91.         function bufferData()
  92.         {
  93.             let verts = [];
  94.             let tc = [];
  95.             const segments = 80;
  96.             let degInRad = 0;
  97.             const radius = 1;
  99.             for (let i = 0; i <= Math.round(segments); i++)
  100.             {
  101.                 degInRad = (360.0 / Math.round(segments)) * i * DEG2RAD;
  102.                 verts.push(
  103.                     Math.cos(degInRad) * radius,
  104.                     Math.sin(degInRad) * radius,
  105.                     0
  106.                 );
  107.                 tc.push(0, 0);
  108.             }
  110.             let geom = new Geometry("sphere marker");
  111.             geom.setPointVertices(verts);
  112.             geom.setTexCoords(tc);
  113.             geom.vertexNormals = verts.slice();
  114.             helperMeshes.CIRCLE.mesh = new Mesh(cgl, geom);
  115.         }
  117.         bufferData();
  118.     }
  120.     if (cgl.lastMesh) cgl.lastMesh.unBind();
  122.     cgl.pushModelMatrix();
  123.     helperMeshes.startFramebuffer(cgl);
  125.     vec3.set(helperMeshes.CIRCLE.vScale, size, size, size);
  126.     mat4.scale(cgl.mvMatrix, cgl.mvMatrix, helperMeshes.CIRCLE.vScale);
  128.     let shader = helperMeshes.getDefaultShader(cgl, { "billboarded": true });
  130.     if (gui.patchView.isCurrentOp(op)) shader = helperMeshes.getSelectedShader(cgl, { "billboarded": true });
  131.     shader.glPrimitive = cgl.gl.LINE_STRIP;
  133.     helperMeshes.CIRCLE.mesh.render(shader);
  134.     helperMeshes.count++;
  135.     cgl.popModelMatrix();
  136.     helperMeshes.endFramebuffer(cgl);
  137. };
  139. helperMeshes.drawSphere = function (op, size)
  140. {
  141.     const cgl = op.patch.cgl;
  143.     if (!helperMeshes.SPHERE)
  144.     {
  145.         helperMeshes.SPHERE = {};
  147.         helperMeshes.SPHERE.vScale = vec3.create();
  148.         function bufferData()
  149.         {
  150.             let verts = [];
  151.             let tc = [];
  152.             const segments = 80;
  153.             let i = 0, degInRad = 0;
  154.             const radius = 1;
  156.             for (i = 0; i <= Math.round(segments); i++)
  157.             {
  158.                 degInRad = (360.0 / Math.round(segments)) * i * DEG2RAD;
  159.                 verts.push(Math.cos(degInRad) * radius);
  160.                 verts.push(0);
  161.                 verts.push(Math.sin(degInRad) * radius);
  162.                 tc.push(0, 0);
  163.             }
  165.             const geom = new Geometry("sphere marker");
  166.             geom.setPointVertices(verts);
  167.             geom.setTexCoords(tc);
  168.             geom.vertexNormals = verts.slice();
  170.             //---
  172.             verts = [];
  173.             tc = [];
  174.             for (i = 0; i <= Math.round(segments); i++)
  175.             {
  176.                 degInRad = (360.0 / Math.round(segments)) * i * DEG2RAD;
  177.                 verts.push(Math.cos(degInRad) * radius);
  178.                 verts.push(Math.sin(degInRad) * radius);
  179.                 verts.push(0);
  180.                 tc.push(0, 0);
  181.             }
  183.             const geom2 = new Geometry("sphere marker");
  184.             geom2.setPointVertices(verts);
  185.             geom2.setTexCoords(tc);
  186.             geom2.vertexNormals = verts.slice();
  188.             //---
  190.             verts = [];
  191.             tc = [];
  192.             for (i = 0; i <= Math.round(segments); i++)
  193.             {
  194.                 degInRad = (360.0 / Math.round(segments)) * i * DEG2RAD;
  195.                 verts.push(0);
  196.                 verts.push(Math.cos(degInRad) * radius);
  197.                 verts.push(Math.sin(degInRad) * radius);
  198.                 tc.push(0, 0);
  199.             }
  201.             const geom3 = new Geometry("sphere marker");
  202.             geom3.setPointVertices(verts);
  203.             geom3.setTexCoords(tc);
  204.             geom3.vertexNormals = verts.slice();
  206.             geom.merge(geom2);
  207.             geom.merge(geom3);
  208.             helperMeshes.SPHERE.mesh = new Mesh(cgl, geom);
  209.         }
  211.         bufferData();
  212.     }
  214.     if (cgl.lastMesh) cgl.lastMesh.unBind();
  216.     cgl.pushModelMatrix();
  217.     helperMeshes.startFramebuffer(cgl);
  219.     vec3.set(helperMeshes.SPHERE.vScale, size, size, size);
  220.     mat4.scale(cgl.mvMatrix, cgl.mvMatrix, helperMeshes.SPHERE.vScale);
  222.     let shader = helperMeshes.getDefaultShader(cgl);
  223.     if (gui.patchView.isCurrentOp(op)) shader = helperMeshes.getSelectedShader(cgl);
  225.     shader.glPrimitive = cgl.gl.LINE_STRIP;
  226.     helperMeshes.SPHERE.mesh.render(shader);
  227.     helperMeshes.count++;
  228.     cgl.popModelMatrix();
  230.     helperMeshes.endFramebuffer(cgl);
  231. };
  233. helperMeshes.drawAxisMarker = function (op, size)
  234. {
  235.     const cgl = op.patch.cgl;
  237.     if (!helperMeshes.MARKER)
  238.     {
  239.         helperMeshes.MARKER = {};
  241.         const geom = new Geometry("marker");
  242.         geom.setPointVertices([
  243.             0.00001, 0, 0, 1, 0, 0,
  244.             0, 0.00001, 0, 0, 1, 0,
  245.             0, 0, 0.00001, 0, 0, 1
  246.         ]);
  247.         // geom.resetTextureCoords();
  249.         helperMeshes.MARKER.mesh = new Mesh(cgl, geom, { "glPrimitive": cgl.gl.LINES });
  250.         helperMeshes.MARKER.mesh.setGeom(geom);
  252.         const frag = "" + nl + "IN vec3 axisColor;" + nl + "void main()" + nl + "{" + nl + "    vec4 col=vec4(axisColor,1.0);" + nl + "    outColor = col;" + nl + "}";
  254.         const vert = "" + nl
  255.             + "IN vec3 vPosition;" + nl
  256.             + "UNI mat4 projMatrix;" + nl
  257.             + "UNI mat4 mvMatrix;" + nl
  258.             + "OUT vec3 axisColor;" + nl
  259.             + "void main()" + nl
  260.             + "{" + nl
  261.             + "   vec4 pos=vec4(vPosition, 1.0);" + nl
  262.             + "   if(pos.x!=0.0)axisColor=vec3(1.0,0.3,0.0);" + nl
  263.             + "   if(pos.y!=0.0)axisColor=vec3(0.0,1.0,0.2);" + nl
  264.             + "   if(pos.z!=0.0)axisColor=vec3(0.0,0.5,1.0);" + nl
  265.             + "   gl_Position = projMatrix * mvMatrix * pos;" + nl
  266.             + "}";
  268.         helperMeshes.MARKER.shader = new Shader(cgl, "markermaterial");
  269.         helperMeshes.MARKER.shader.setSource(vert, frag);
  271.         helperMeshes.MARKER.vScale = vec3.create();
  272.     }
  274.     helperMeshes.startFramebuffer(cgl);
  276.     if (size === undefined) size = 2;
  277.     cgl.pushModelMatrix();
  279.     cgl.pushShader(helperMeshes.MARKER.shader);
  281.     vec3.set(helperMeshes.MARKER.vScale, size, size, size);
  282.     mat4.scale(cgl.mvMatrix, cgl.mvMatrix, helperMeshes.MARKER.vScale);
  284.     cgl.pushDepthTest(false);
  286.     helperMeshes.MARKER.mesh.render(cgl.getShader());
  288.     helperMeshes.count++;
  289.     cgl.popDepthTest();
  290.     cgl.popShader();
  291.     cgl.popModelMatrix();
  293.     helperMeshes.endFramebuffer(cgl);
  294. };
  296. helperMeshes.drawLineSourceDest = function (op, sourceX, sourceY, sourceZ, destX, destY, destZ)
  297. {
  298.     const cgl = op.patch.cgl;
  299.     if (!helperMeshes.ARROW_SRC_DST)
  300.     {
  301.         helperMeshes.ARROW_SRC_DST = {};
  303.         const verts = [];
  304.         verts.push(sourceX, sourceY, sourceZ);
  305.         verts.push(destX, destY, destZ);
  307.         const tc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  308.         const geom = new Geometry("helpermesh");
  309.         geom.vertices = verts;
  310.         geom.setTexCoords(tc);
  311.         geom.vertexNormals = verts.slice();
  312.         helperMeshes.ARROW_SRC_DST.geom = geom;
  313.         helperMeshes.ARROW_SRC_DST.cube = new Mesh(cgl, geom, { "glPrimitive": cgl.gl.LINES });
  314.     }
  315.     else
  316.     {
  317.         helperMeshes.ARROW_SRC_DST.geom.setVertices([sourceX, sourceY, sourceZ, destX, destY, destZ]);
  318.         helperMeshes.ARROW_SRC_DST.cube.updateVertices(helperMeshes.ARROW_SRC_DST.geom);
  319.     }
  321.     if (cgl.lastMesh) cgl.lastMesh.unBind();
  323.     cgl.pushModelMatrix();
  324.     helperMeshes.startFramebuffer(cgl);
  326.     let shader = helperMeshes.getDefaultShader(cgl);
  327.     if (gui.patchView.isCurrentOp(op)) shader = helperMeshes.getSelectedShader(cgl);
  329.     helperMeshes.ARROW_SRC_DST.cube.render(shader);
  330.     helperMeshes.count++;
  332.     cgl.popModelMatrix();
  333.     helperMeshes.endFramebuffer(cgl);
  334. };
  336. helperMeshes.drawArrow = function (op, sizeX, rotX, rotY, rotZ)
  337. {
  338.     const cgl = op.patch.cgl;
  340.     if (!helperMeshes.ARROW)
  341.     {
  342.         helperMeshes.ARROW = {};
  343.         helperMeshes.ARROW.vScale = vec3.create();
  345.         function bufferData()
  346.         {
  347.             const verts = [];
  349.             verts.push(0, -1, 0);
  350.             verts.push(0.25, -0.75, 0);
  352.             verts.push(0, -1, 0);
  353.             verts.push(-0.25, -0.75, 0);
  355.             verts.push(0, -1, 0);
  356.             verts.push(0, 0, 0);
  358.             const tc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  360.             const geom = new Geometry("helpermesh");
  361.             geom.vertices = verts;
  362.             geom.setTexCoords(tc);
  363.             geom.vertexNormals = verts.slice();
  365.             helperMeshes.ARROW.cube = new Mesh(cgl, geom, { "glPrimitive": cgl.gl.LINES });
  366.         }
  368.         bufferData();
  369.     }
  371.     if (cgl.lastMesh) cgl.lastMesh.unBind();
  373.     cgl.pushModelMatrix();
  374.     helperMeshes.startFramebuffer(cgl);
  376.     vec3.set(helperMeshes.ARROW.vScale, sizeX, sizeX, sizeX);
  377.     mat4.scale(cgl.mvMatrix, cgl.mvMatrix, helperMeshes.ARROW.vScale);
  379.     if (rotX) mat4.rotateX(cgl.mvMatrix, cgl.mvMatrix, rotX * DEG2RAD);
  380.     if (rotY) mat4.rotateY(cgl.mvMatrix, cgl.mvMatrix, rotY * DEG2RAD);
  381.     if (rotZ) mat4.rotateZ(cgl.mvMatrix, cgl.mvMatrix, rotZ * DEG2RAD);
  383.     let shader = helperMeshes.getDefaultShader(cgl);
  384.     if (gui.patchView.isCurrentOp(op)) shader = helperMeshes.getSelectedShader(cgl);
  386.     helperMeshes.ARROW.cube.render(shader);
  387.     helperMeshes.count++;
  389.     cgl.popModelMatrix();
  390.     helperMeshes.endFramebuffer(cgl);
  391. };
  393. helperMeshes.drawXPlane = function (op, sizeX, rotX, rotY, rotZ)
  394. {
  395.     const cgl = op.patch.cgl;
  397.     if (!helperMeshes.XPLANE)
  398.     {
  399.         helperMeshes.XPLANE = {};
  400.         helperMeshes.XPLANE.vScale = vec3.create();
  402.         function bufferData()
  403.         {
  404.             const verts = [
  405.                 -1, -1, 0,
  406.                 1, 1, 0,
  407.                 -1, 1, 0,
  408.                 1, -1, 0,
  409.                 1, 1, 0,
  410.                 -1, 1, 0,
  411.                 -1, -1, 0,
  412.                 1, -1, 0
  413.             ];
  415.             const tc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  417.             const geom = new Geometry("helpermesh");
  418.             geom.vertices = verts;
  419.             geom.setTexCoords(tc);
  420.             geom.vertexNormals = verts.slice();
  422.             helperMeshes.XPLANE.mesh = new Mesh(cgl, geom, cgl.gl.LINE_STRIP);
  423.         }
  425.         bufferData();
  426.     }
  428.     if (cgl.lastMesh) cgl.lastMesh.unBind();
  430.     cgl.pushModelMatrix();
  431.     helperMeshes.startFramebuffer(cgl);
  433.     vec3.set(helperMeshes.XPLANE.vScale, sizeX, sizeX, sizeX);
  434.     mat4.scale(cgl.mvMatrix, cgl.mvMatrix, helperMeshes.XPLANE.vScale);
  436.     if (rotX) mat4.rotateX(cgl.mvMatrix, cgl.mvMatrix, rotX * DEG2RAD);
  437.     if (rotY) mat4.rotateY(cgl.mvMatrix, cgl.mvMatrix, rotY * DEG2RAD);
  438.     if (rotZ) mat4.rotateZ(cgl.mvMatrix, cgl.mvMatrix, rotZ * DEG2RAD);
  440.     let shader = helperMeshes.getDefaultShader(cgl);
  441.     if (gui.patchView.isCurrentOp(op)) shader = helperMeshes.getSelectedShader(cgl);
  443.     helperMeshes.XPLANE.mesh.render(shader);
  444.     helperMeshes.count++;
  446.     cgl.popModelMatrix();
  447.     helperMeshes.endFramebuffer(cgl);
  448. };
  450. helperMeshes.drawCube = function (op, sizeX, sizeY, sizeZ)
  451. {
  452.     const cgl = op.patch.cgl;
  454.     if (!helperMeshes.CUBE)
  455.     {
  456.         helperMeshes.CUBE = {};
  457.         helperMeshes.CUBE.vScale = vec3.create();
  459.         function bufferData()
  460.         {
  461.             const verts = new Float32Array([
  462.                 -1, -1, 1,
  463.                 1, -1, 1,
  464.                 1, 1, 1,
  465.                 -1, 1, 1,
  466.                 -1, -1, 1,
  468.                 -1, -1, -1,
  469.                 1, -1, -1,
  470.                 1, 1, -1,
  471.                 -1, 1, -1,
  472.                 -1, -1, -1,
  474.                 -1, -1, -1,
  475.                 -1, 1, -1,
  476.                 -1, 1, 1,
  477.                 -1, -1, 1,
  478.                 -1, -1, -1,
  480.                 1, -1, -1,
  481.                 1, 1, -1,
  482.                 1, 1, 1,
  483.                 1, -1, 1,
  484.                 1, -1, -1
  485.             ]);
  487.             const tc = new Float32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
  489.             const geom = new Geometry("helpermesh");
  490.             geom.vertices = verts;
  491.             geom.setTexCoords(tc);
  492.             geom.vertexNormals = verts.slice();
  494.             helperMeshes.CUBE.mesh = new Mesh(cgl, geom, cgl.gl.LINE_STRIP);
  495.         }
  497.         bufferData();
  498.     }
  500.     if (cgl.lastMesh) cgl.lastMesh.unBind();
  502.     cgl.pushModelMatrix();
  503.     helperMeshes.startFramebuffer(cgl);
  505.     if (sizeY == undefined) sizeY = sizeX;
  506.     if (sizeZ == undefined) sizeZ = sizeX;
  507.     vec3.set(helperMeshes.CUBE.vScale, sizeX, sizeY, sizeZ);
  508.     mat4.scale(cgl.mvMatrix, cgl.mvMatrix, helperMeshes.CUBE.vScale);
  510.     let shader = helperMeshes.getDefaultShader(cgl);
  511.     if (gui.patchView.isCurrentOp(op)) shader = helperMeshes.getSelectedShader(cgl);
  513.     helperMeshes.CUBE.mesh.render(shader);
  514.     helperMeshes.count++;
  516.     cgl.popModelMatrix();
  517.     helperMeshes.endFramebuffer(cgl);
  518. };
  520. helperMeshes.drawMarkerLayer = function (cgl, size)
  521. {
  522.     if (!gui.shouldDrawOverlay) return;
  524.     if (helperMeshes.count == 0) return;
  525.     helperMeshes.count = 0;
  527.     if (!helperMeshes.FB || !helperMeshes.FB.fb) return;
  529.     const currentViewPort = cgl.getViewPort();
  530.     const w = currentViewPort[2];
  531.     const h = currentViewPort[3];
  533.     if (!helperMeshes.fullscreenRectMesh || helperMeshes.FSWIDTH != w || helperMeshes.FSHEIGHT != h)
  534.     {
  535.         const fsGeom = new Geometry("fullscreen rectangle");
  537.         helperMeshes.FSWIDTH = w;
  538.         helperMeshes.FSHEIGHT = h;
  540.         // prettier-ignore
  541.         fsGeom.vertices = new Float32Array([
  542.             w, h, 0,
  543.             0, h, 0,
  544.             w, 0, 0,
  545.             0, 0, 0
  546.         ]);
  548.         fsGeom.texCoords = new Float32Array([
  549.             1.0, 1.0,
  550.             0.0, 1.0,
  551.             1.0, 0.0,
  552.             0.0, 0.0,
  553.         ]);
  555.         fsGeom.vertexNormals = new Float32Array([
  556.             0, 0, 1,
  557.             0, 0, 1,
  558.             0, 0, 1,
  559.             0, 0, 1
  560.         ]);
  562.         fsGeom.verticesIndices = new Uint16Array([
  563.             0, 1, 2,
  564.             3, 1, 2,
  565.         ]);
  567.         // helperMeshes.fsGeom=fsGeom;
  568.         if (!helperMeshes.fullscreenRectMesh) helperMeshes.fullscreenRectMesh = new Mesh(cgl, fsGeom);
  569.         else helperMeshes.fullscreenRectMesh.setGeom(fsGeom);
  571.         // ------------
  573.         if (!helperMeshes.fullscreenRectShader)
  574.         {
  575.             const shader = new Shader(cgl, "marker overlay");
  577.             const shader_frag = "" + nl
  578.                 + "UNI sampler2D tex;" + nl
  579.                 + "IN vec2 texCoord;" + nl
  580.                 + "void main()" + nl
  581.                 + "{"
  583.             /*
  584.                  * +nl+'   vec3 gray = vec3(dot( vec3(0.2126,0.7152,0.0722),  texture2D(tex,vec2(texCoord.x,(1.0-texCoord.y))).rgb ));'
  585.                  * +nl+'   gl_FragColor = vec4(gray,1.0);'
  586.                  */
  588.                     + nl
  589.                 + "   gl_FragColor = texture2D(tex,texCoord);"
  590.                 // +nl+'   if(gl_FragColor.a<0.5)gl_FragColor.a=0.7;'
  592.                     + nl
  593.                 + "}";
  595.             const shader_vert = "" + nl
  596.                 + "IN vec3 vPosition;" + nl
  597.                 + "UNI mat4 projMatrix;" + nl
  598.                 + "UNI mat4 mvMatrix;" + nl
  599.                 + "OUT vec2 texCoord;" + nl
  600.                 + "IN vec2 attrTexCoord;" + nl
  601.                 + "void main()" + nl
  602.                 + "{" + nl
  603.                 + "   vec4 pos=vec4(vPosition, 1.0);" + nl
  604.                 + "   texCoord=vec2(attrTexCoord.x,1.0-attrTexCoord.y);" + nl
  605.                 + "   gl_Position = projMatrix * mvMatrix * pos;" + nl
  606.                 + "}";
  608.             shader.setSource(shader_vert, shader_frag);
  609.             shader.texUniform = new Uniform(shader, "t", "tex", 0);
  611.             helperMeshes.fullscreenRectShader = shader;
  613.             /*
  614.              * shader.bindTextures = function ()
  615.              * {
  616.              *     cgl.gl.activeTexture(cgl.gl.TEXTURE0);
  617.              *     cgl.gl.bindTexture(cgl.gl.TEXTURE_2D, helperMeshes.FB.fb.getTextureColor().tex);
  618.              * };
  619.              */
  620.         }
  621.     }
  623.     cgl.gl.clear(cgl.gl.DEPTH_BUFFER_BIT);
  624.     cgl.pushPMatrix();
  625.     mat4.identity(cgl.pMatrix);
  626.     mat4.ortho(cgl.pMatrix, 0, w, h, 0, -10.0, 1000);
  628.     cgl.pushModelMatrix();
  629.     mat4.identity(cgl.mvMatrix);
  631.     cgl.pushViewMatrix();
  632.     mat4.identity(cgl.vMatrix);
  634.     helperMeshes.fullscreenRectShader.popTextures();
  635.     helperMeshes.fullscreenRectShader.pushTexture(helperMeshes.fullscreenRectShader.texUniform, helperMeshes.FB.fb.getTextureColor().tex);
  637.     cgl.pushShader(helperMeshes.fullscreenRectShader);
  639.     /*
  640.      * helperMeshes.fullscreenRectShader.bind();
  641.      * cgl.getShader().bind
  642.      */
  644.     /*
  645.      * for (var i =0;i< cgl.gl.getProgramParameter(cgl.getShader().getProgram(), cgl.gl.ACTIVE_ATTRIBUTES) ; i++)
  646.      * {
  647.      *     console.log(i, cgl.gl.getActiveAttrib(cgl.getShader().getProgram(), i) );
  648.      * }
  649.      */
  651.     cgl.pushBlend(true);
  653.     cgl.gl.blendEquation(cgl.gl.FUNC_ADD);
  654.     cgl.gl.blendFunc(cgl.gl.ONE, cgl.gl.ONE_MINUS_SRC_ALPHA);
  656.     helperMeshes.fullscreenRectMesh.render(cgl.getShader());
  657.     cgl.gl.blendFunc(cgl.gl.SRC_ALPHA, cgl.gl.ONE_MINUS_SRC_ALPHA);
  659.     cgl.gl.clear(cgl.gl.DEPTH_BUFFER_BIT);
  660.     cgl.popBlend();
  662.     cgl.popShader();
  664.     cgl.popPMatrix();
  665.     cgl.popModelMatrix();
  666.     cgl.popViewMatrix();
  668.     cgl.frameCycler = !cgl.frameCycler;
  669. };