void PaintWidget::resizeGL(int width, int height) { // Set the viewport size. viewport(0, 0, width, height); // Set projection matrix to some fixed values WMatrix4x4 proj; proj.perspective(45, ((double)width)/height, 1, 40); uniformMatrix4(pMatrixUniform_, proj); }
void DrawGLWidget::initializeGL() { // Init variables useLighting=true; ambientColor.assign(0.2,0.2,0.2); lightDirection.assign(-1.0,-1.0,-1.0); lightDirection.normalize(); lightDirection.scale(-1.0); lightColor.assign(0.8); // Init Angles angleX = -30.0; velAngleX = 0.0; angleY = 0.0; velAngleY = 0.0; accelAngle = 0.1; zDepth = -6.0; // Init Javascript Matrix (ClientSide) WMatrix4x4 worldTransform; worldTransform.setToIdentity(); jsMatrix_ = createJavaScriptMatrix4(); setJavaScriptMatrix4(jsMatrix_, worldTransform); rotMatrix=createJavaScriptMatrix4(); //setClientSideWalkHandler(rotMatrix,0.01,0.01); setClientSideLookAtHandler(rotMatrix,0,0,0,0,1,0,0.007,0.007); // Init Texture pointer initShaders(); initBuffers(); initTextures(); viewport(0, 0, 500, 500); clearColor(0, 0, 0, 1.0); enable(DEPTH_TEST); }
WMatrix4x4 WGLWidget::JavaScriptMatrix4x4::value() const { if (!hasContext()) throw WException("JavaScriptMatrix4x4: matrix not assigned to a WGLWidget"); WMatrix4x4 originalCpy; for (unsigned i = 0; i<context_->jsMatrixList_.size(); i++) if (context_->jsMatrixList_[i].id == id_) originalCpy = context_->jsMatrixList_[i].serverSideCopy; // apply all operations int nbMult = 0; for (unsigned i = 0; i<operations_.size(); i++) { switch (operations_[i]) { case op::TRANSPOSE: originalCpy = originalCpy.transposed(); break; case op::INVERT: #ifndef WT_TARGET_JAVA originalCpy = #endif originalCpy.inverted(); break; case op::MULTIPLY: #ifndef WT_TARGET_JAVA originalCpy = originalCpy * matrices_[nbMult]; #else originalCpy.mul(matrices_[nbMult]); #endif nbMult++; break; } } return originalCpy; }
void initializeGL() { jsMatrix_ = createJavaScriptMatrix4(); WMatrix4x4 worldTransform; worldTransform.lookAt(0, 0, 5, 0, 0, -1, 0, 1, 0); setJavaScriptMatrix4(jsMatrix_, worldTransform); //setClientSideWalkHandler(jsMatrix_, 1./20, 1./100); setClientSideLookAtHandler(jsMatrix_, 0, 0, 0, 0, 1, 0, 0.005, 0.005); // First, load a simple shader Shader fragmentShader = createShader(FRAGMENT_SHADER); shaderSource(fragmentShader, fragmentShaderSrc); compileShader(fragmentShader); Shader vertexShader = createShader(VERTEX_SHADER); shaderSource(vertexShader, vertexShaderSrc); compileShader(vertexShader); shaderProgram_ = createProgram(); attachShader(shaderProgram_, vertexShader); attachShader(shaderProgram_, fragmentShader); linkProgram(shaderProgram_); useProgram(shaderProgram_); vertexPositionAttribute_ = getAttribLocation(shaderProgram_, "aVertexPosition"); enableVertexAttribArray(vertexPositionAttribute_); vertexColorAttribute_ = getAttribLocation(shaderProgram_, "aVertexColor"); enableVertexAttribArray(vertexColorAttribute_); pMatrixUniform_ = getUniformLocation(shaderProgram_, "uPMatrix"); cMatrixUniform_ = getUniformLocation(shaderProgram_, "uCMatrix"); mvMatrixUniform_ = getUniformLocation(shaderProgram_, "uMVMatrix"); // Next, load a texture shader Shader texFragmentShader = createShader(FRAGMENT_SHADER); shaderSource(texFragmentShader, texFragmentShaderSrc); compileShader(texFragmentShader); Shader texVertexShader = createShader(VERTEX_SHADER); shaderSource(texVertexShader, texVertexShaderSrc); compileShader(texVertexShader); texShaderProgram_ = createProgram(); attachShader(texShaderProgram_, texVertexShader); attachShader(texShaderProgram_, texFragmentShader); linkProgram(texShaderProgram_); useProgram(texShaderProgram_); texVertexPositionAttribute_ = getAttribLocation(texShaderProgram_, "aVertexPosition"); enableVertexAttribArray(texVertexPositionAttribute_); texCoordAttribute_ = getAttribLocation(texShaderProgram_, "aTextureCoord"); enableVertexAttribArray(texCoordAttribute_); texPMatrixUniform_ = getUniformLocation(texShaderProgram_, "uPMatrix"); texCMatrixUniform_ = getUniformLocation(shaderProgram_, "uCMatrix"); texMvMatrixUniform_ = getUniformLocation(texShaderProgram_, "uMVMatrix"); texSamplerUniform_ = getUniformLocation(texShaderProgram_, "uSampler"); // Now, preload buffers triangleVertexPositionBuffer_ = createBuffer(); bindBuffer(ARRAY_BUFFER, triangleVertexPositionBuffer_); double trianglePosition[] = { 0.0, 1.0, 0.0, -1.0,-1.0, 0.0, 1.0,-1.0, 0.0 }; bufferDatafv(ARRAY_BUFFER, trianglePosition, 9, STATIC_DRAW); triangleVertexColorBuffer_ = createBuffer(); bindBuffer(ARRAY_BUFFER, triangleVertexColorBuffer_); double triangleColor[] = { 1.0,0.0,0.0,1.0, 0.0,1.0,0.0,1.0, 0.0,0.0,1.0,1.0 }; bufferDatafv(ARRAY_BUFFER, triangleColor, 12, STATIC_DRAW); squareVertexPositionBuffer_ = createBuffer(); bindBuffer(ARRAY_BUFFER, squareVertexPositionBuffer_); double squarePosition[] = { 1.0, 1.0,0.0, -1.0, 1.0,0.0, 1.0,-1.0,0.0, -1.0,-1.0,0.0 }; bufferDatafv(ARRAY_BUFFER, squarePosition, 12, STATIC_DRAW); squareVertexColorBuffer_ = createBuffer(); bindBuffer(ARRAY_BUFFER, squareVertexColorBuffer_); double squareColor[] = { 1.0,0.0,0.0,1.0, 0.0,1.0,0.0,1.0, 0.0,0.0,1.0,1.0, 0.0,1.0,1.0,1.0 }; bufferDatafv(ARRAY_BUFFER, squareColor, 16, STATIC_DRAW); squareElementBuffer_ = createBuffer(); bindBuffer(ELEMENT_ARRAY_BUFFER, squareElementBuffer_); int elements[] = { 0, 1, 2, 3 }; bufferDataiv(ELEMENT_ARRAY_BUFFER, elements, 4, STATIC_DRAW, DT_UNSIGNED_BYTE); texture_ = createTextureAndLoad("texture.jpg"); bindTexture(TEXTURE_2D, texture_); pixelStorei(UNPACK_FLIP_Y_WEBGL, true); texImage2D(TEXTURE_2D, 0, RGB, RGB, PT_UNSIGNED_BYTE, texture_); texParameteri(TEXTURE_2D, TEXTURE_MAG_FILTER, LINEAR); texParameteri(TEXTURE_2D, TEXTURE_MIN_FILTER, LINEAR); textureCoordBuffer_ = createBuffer(); bindBuffer(ARRAY_BUFFER, textureCoordBuffer_); float textureCoords[] = { 1, 1, 0, 1, 1, 0, 0, 0 }; bufferDatafv(ARRAY_BUFFER, textureCoords, 8, STATIC_DRAW); }
void paintGL() { // Drawing starts here! //clearColor(0.8, 0.8, 0.8, 1); clearColor(0, 0, 0, 1); clearDepth(1); disable(DEPTH_TEST); disable(CULL_FACE); depthFunc(LEQUAL); viewport(0, 0, 640, 360); clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT); WMatrix4x4 proj; proj.perspective(90, 1, 1, 40); useProgram(shaderProgram_); // Set projection matrix uniformMatrix4(pMatrixUniform_, proj); uniformMatrix4(cMatrixUniform_, jsMatrix_); // Draw the scene #if 0 bindBuffer(ARRAY_BUFFER, triangleVertexPositionBuffer_); vertexAttribPointer(vertexPositionAttribute_, 3, FLOAT, false, 0, 0); bindBuffer(ARRAY_BUFFER, triangleVertexColorBuffer_); vertexAttribPointer(vertexColorAttribute_, 4, FLOAT, false, 0, 0); WMatrix4x4 modelMatrix1( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, -2.0, 0, 0, 1 ); modelMatrix1.rotate(45, 0, 1, 0); uniformMatrix4fv(mvMatrixUniform_, false, modelMatrix1); drawArrays(TRIANGLES, 0, 3); #endif bindBuffer(ARRAY_BUFFER, squareVertexPositionBuffer_); vertexAttribPointer(vertexPositionAttribute_, 3, FLOAT, false, 0, 0); bindBuffer(ARRAY_BUFFER, squareVertexColorBuffer_); vertexAttribPointer(vertexColorAttribute_, 4, FLOAT, false, 0, 0); WMatrix4x4 modelMatrix2( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ); //modelMatrix2.rotate(45, 1, 0, 0); //modelMatrix2.translate(0, 0, -2); uniformMatrix4(mvMatrixUniform_, modelMatrix2); //drawArrays(TRIANGLE_STRIP, 0, 4); bindBuffer(ELEMENT_ARRAY_BUFFER, squareElementBuffer_); drawElements(TRIANGLE_STRIP, 4, DT_UNSIGNED_BYTE, 0); #if 0 // now draw something textured useProgram(texShaderProgram_); uniformMatrix4fv(texPMatrixUniform_, false, projectionMatrix); //WMatrix4x4 mm3( // 2, 0, 0, 0, // 0, 1, 0, -2.5, // 0, 0, 1, 0, // 0, 0, 0, 1 // ); WMatrix4x4 mm3; //mm3.scale(.5, 2, 1); mm3.rotate(45, 0, 0, 1); uniformMatrix4fv(texMvMatrixUniform_, false, mm3.data()); bindBuffer(ARRAY_BUFFER, textureCoordBuffer_); vertexAttribPointer(texCoordAttribute_, 2, FLOAT, false, 0, 0); activeTexture(TEXTURE0); bindTexture(TEXTURE_2D, texture_); uniform1i(texSamplerUniform_, 0); bindBuffer(ARRAY_BUFFER, squareVertexPositionBuffer_); vertexAttribPointer(texVertexPositionAttribute_, 3, FLOAT, false, 0, 0); drawArrays(TRIANGLE_STRIP, 0, 4); #endif }
// The initializeGL() captures all JS commands that are to be executed // before the scene is rendered for the first time. It is executed only // once. It is re-executed when the WebGL context is restored after it // was lost. // In general, it should be used to set up shaders, create VBOs, initialize // matrices, ... void PaintWidget::initializeGL() { // In order to know where to look at, calculate the centerpoint of the // scene double cx, cy, cz; centerpoint(cx, cy, cz); // Transform the world so that we look at the centerpoint of the scene WMatrix4x4 worldTransform; worldTransform.lookAt( cx, cy, cz + 10, // camera position cx, cy, cz, // looking at 0, 1, 0); // 'up' vector // We want to be able to change the camera position client-side. In // order to do so, the world transformation matrix must be stored in // a matrix that can be manipulated from JavaScript. if (!initialized_) { initJavaScriptMatrix4(jsMatrix_); setJavaScriptMatrix4(jsMatrix_, worldTransform); // This installs a client-side mouse handler that modifies the // world transformation matrix. Like WMatrix4x4::lookAt, this works // by specifying a center point and an up direction; mouse movements // will allow the camera to be moved around the center point. setClientSideLookAtHandler(jsMatrix_, // the name of the JS matrix cx, cy, cz, // the center point 0, 1, 0, // the up direction 0.005, 0.005); // 'speed' factors // Alternative: this installs a client-side mouse handler that allows // to 'walk' around: go forward, backward, turn left, turn right, ... //setClientSideWalkHandler(jsMatrix_, 0.05, 0.005); initialized_ = true; } // First, load a simple shader Shader fragmentShader = createShader(FRAGMENT_SHADER); shaderSource(fragmentShader, fragmentShader_); compileShader(fragmentShader); Shader vertexShader = createShader(VERTEX_SHADER); shaderSource(vertexShader, vertexShader_); compileShader(vertexShader); shaderProgram_ = createProgram(); attachShader(shaderProgram_, vertexShader); attachShader(shaderProgram_, fragmentShader); linkProgram(shaderProgram_); useProgram(shaderProgram_); // Extract the references to the attributes from the shader. vertexNormalAttribute_ = getAttribLocation(shaderProgram_, "aVertexNormal"); vertexPositionAttribute_ = getAttribLocation(shaderProgram_, "aVertexPosition"); enableVertexAttribArray(vertexPositionAttribute_); enableVertexAttribArray(vertexNormalAttribute_); // Extract the references the uniforms from the shader pMatrixUniform_ = getUniformLocation(shaderProgram_, "uPMatrix"); cMatrixUniform_ = getUniformLocation(shaderProgram_, "uCMatrix"); mvMatrixUniform_ = getUniformLocation(shaderProgram_, "uMVMatrix"); nMatrixUniform_ = getUniformLocation(shaderProgram_, "uNMatrix"); // Create a Vertex Buffer Object (VBO) and load all polygon's data // (points, normals) into it. In this case we use one VBO that contains // all data (6 per point: vx, vy, vz, nx, ny, nz); alternatively you // can use multiple VBO's (e.g. one VBO for normals, one for points, // one for texture coordinates). // Note that if you use indexed buffers, you cannot have indexes // larger than 65K, due to the limitations of WebGL. objBuffer_ = createBuffer(); bindBuffer(ARRAY_BUFFER, objBuffer_); if (!useBinaryBuffers_) { // embed the buffer directly in the JavaScript stream. bufferDatafv(ARRAY_BUFFER, data.begin(), data.end(), STATIC_DRAW); } else { //Alternatively uncomment the following lines to directly transfer the array //as a binary data resource. //The binary data is prepared as a downloadable resource which is requested //by an XHR of the javascript client WMemoryResource * mem = new WMemoryResource("application/octet", this); // cast the doubles to an unsigned char array to serve it by the memory resource mem->setData( reinterpret_cast<unsigned char*>(&(data[0])), data.size() * sizeof(float)); // create client side identifier for the buffer resource and set up for preloading ArrayBuffer clientBufferResource = createAndLoadArrayBuffer(mem->generateUrl()); bufferData(ARRAY_BUFFER, clientBufferResource, STATIC_DRAW); } // Set the clear color to a transparant background clearColor(0, 0, 0, 0); // Reset Z-buffer, enable Z-buffering clearDepth(1); enable(DEPTH_TEST); depthFunc(LEQUAL); }
void DrawGLWidget::paintGL() { clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT); // Reset Z-buffer, enable Z-buffering // Draw Cube // set perspective matrix WMatrix4x4 pMatrix; pMatrix.perspective(45,1,0.1,100.0); uniformMatrix4(pMatrixUniform_, pMatrix); //set model-view matrix WMatrix4x4 mvMatrix; mvMatrix.setToIdentity(); mvMatrix.translate(0.0,0.0,zDepth); //WMatrix4x4 rotMatrix; //rotMatrix.rotate(angleX,-1.0, 0.0, 0.0); //rotMatrix.rotate(angleY, 0.0, 1.0, 0.0); uniformMatrix4(cMatrixUniform_, rotMatrix); //set model-view matrix uniformMatrix4(mvMatrixUniform_, mvMatrix); // uniformMatrix4(nMatrixUniform_, rotMatrix.inverted().transposed()); activeTexture(TEXTURE0); bindTexture(TEXTURE_2D,texture); uniform1i(samplerUniform_,0); uniform1i(useLightingUniform_,useLighting); uniform3f(ambientColorUniform_,ambientColor.values[0],ambientColor.values[1],ambientColor.values[2]); uniform3f(lightingDirectionUniform_,lightDirection.values[0],lightDirection.values[1],lightDirection.values[2]); uniform3f(directionalColorUniform_,lightColor.values[0],lightColor.values[1],lightColor.values[2]); bindBuffer(ARRAY_BUFFER, cubeVertexPositionBuffer); vertexAttribPointer(vertexPositionAttribute_, cubeVertices.itemsize_, // size: Every vertex has an X, Y and Z component FLOAT, // type: They are floats false, // normalized: Please, do NOT normalize the vertices 0, // stride: The first byte of the next vertex is located this // amount of bytes further. The format of the VBO is // vx, vy, vz, nx, ny, nz and every element is a // Float32, hence 4 bytes large 0); // offset: The byte position of the first vertex in the buffer bindBuffer(ARRAY_BUFFER, cubeVertexNormalBuffer); vertexAttribPointer(vertexNormalAttribute_, cubeNormals.itemsize_, // size: Every vertex has an X, Y and Z component FLOAT, // type: They are floats false, // normalized: Please, do NOT normalize the vertices 0, // stride: The first byte of the next vertex is located this // amount of bytes further. The format of the VBO is // vx, vy, vz, nx, ny, nz and every element is a // Float32, hence 4 bytes large 0); // offset: The byte position of the first vertex in the buffer bindBuffer(ARRAY_BUFFER, cubeTextureCoordBuffer); vertexAttribPointer(textureCoordAttribute_, cubeTexCoord.itemsize_, // size: Every vertex has RGBA components FLOAT, // type: They are floats false, // normalized: Please, do NOT normalize the vertices 0, // stride: The first byte of the next vertex is located this // amount of bytes further. The format of the VBO is // vx, vy, vz, nx, ny, nz and every element is a // Float32, hence 4 bytes large 0); // offset: The byte position of the first vertex in the buffer*/ bindBuffer(ELEMENT_ARRAY_BUFFER, cubeVertexIndexBuffer); drawElements(TRIANGLES,cubeIndices.numel_,UNSIGNED_SHORT,0); }
void DrawGLWidget::paintGL() { clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT); // Reset Z-buffer, enable Z-buffering bindBuffer(ARRAY_BUFFER, triangleVertexPositionBuffer); // set perspective matrix WMatrix4x4 pMatrix; pMatrix.perspective(45,1,0.1,100.0); jsMatrix_ = createJavaScriptMatrix4(); setJavaScriptMatrix4(jsMatrix_, pMatrix); uniformMatrix4(pMatrixUniform_, jsMatrix_); //set model-view matrix WMatrix4x4 mvMatrix; mvMatrix.setToIdentity(); mvMatrix.translate(-1.5,0.0,-7.0); setJavaScriptMatrix4(jsMatrix_, mvMatrix); uniformMatrix4(mvMatrixUniform_, jsMatrix_); vertexAttribPointer(vertexPositionAttribute_, 3, // size: Every vertex has an X, Y and Z component FLOAT, // type: They are floats false, // normalized: Please, do NOT normalize the vertices 3*4, // stride: The first byte of the next vertex is located this // amount of bytes further. The format of the VBO is // vx, vy, vz, nx, ny, nz and every element is a // Float32, hence 4 bytes large 0); // offset: The byte position of the first vertex in the buffer bindBuffer(ARRAY_BUFFER, triangleVertexColorBuffer); vertexAttribPointer(vertexColorAttribute_, 4, // size: Every vertex has an X, Y and Z component FLOAT, // type: They are floats false, // normalized: Please, do NOT normalize the vertices 4*4, // stride: The first byte of the next vertex is located this // amount of bytes further. The format of the VBO is // vx, vy, vz, nx, ny, nz and every element is a // Float32, hence 4 bytes large 0); // offset: The byte position of the first vertex in the buffer drawArrays(TRIANGLES, 0, 3); bindBuffer(ARRAY_BUFFER, squareVertexPositionBuffer); // set perspective matrix setJavaScriptMatrix4(jsMatrix_, pMatrix); uniformMatrix4(pMatrixUniform_, jsMatrix_); //set model-view matrix mvMatrix.translate(3.0,0.0,0.0); setJavaScriptMatrix4(jsMatrix_, mvMatrix); uniformMatrix4(mvMatrixUniform_, jsMatrix_); vertexAttribPointer(vertexPositionAttribute_, 3, // size: Every vertex has an X, Y and Z component FLOAT, // type: They are floats false, // normalized: Please, do NOT normalize the vertices 3*4, // stride: The first byte of the next vertex is located this // amount of bytes further. The format of the VBO is // vx, vy, vz, nx, ny, nz and every element is a // Float32, hence 4 bytes large 0); // offset: The byte position of the first vertex in the buffer bindBuffer(ARRAY_BUFFER, squareVertexColorBuffer); vertexAttribPointer(vertexColorAttribute_, 4, // size: Every vertex has an X, Y and Z component FLOAT, // type: They are floats false, // normalized: Please, do NOT normalize the vertices 4*4, // stride: The first byte of the next vertex is located this // amount of bytes further. The format of the VBO is // vx, vy, vz, nx, ny, nz and every element is a // Float32, hence 4 bytes large 0); // offset: The byte position of the first vertex in the buffer drawArrays(TRIANGLE_STRIP, 0, 4); // What are you going to draw, Offset , Number of elements }