Example #1
0
 glm::vec3 Transform::position(){
     if (!mParent){
         return mLocalPosition;
     }
     if (mDirty.globalPos){
         auto pos = globalMatrix() * vec4(0,0,0,1);
         mGlobalPosition = vec3(pos);
     }
     return mGlobalPosition;
 }
Example #2
0
void BillboardNode::draw(const glm::mat4  & view_matrix, const glm::mat4  & projection_matrix)
{
  // inherited draw - draws all children
  SceneNode::draw(view_matrix, projection_matrix);

  glm::mat4 matrix;
  if( m_type == WORLD_ALIGNED )
    matrix = projection_matrix * view_matrix * globalMatrix();
  else 
  {
    glm::mat4 screen_aligned_matrix = glm::mat4(1.0f);  // identity
    screen_aligned_matrix[3] = view_matrix[3];          // with translation

    matrix = projection_matrix * screen_aligned_matrix * globalMatrix();
  }

  glUseProgram(m_program);
  glUniformMatrix4fv(m_PVMmatrixLoc, 1, GL_FALSE, glm::value_ptr(matrix) );
  glUniform2fv(m_texCoordOffsetLoc, 1, glm::value_ptr(m_texture_offset) );

  glEnable(GL_BLEND);
  glBlendFunc( m_sfactor, m_dfactor );

  glBindVertexArray( m_vertexArrayObject );

  glUniform1i(m_texSamplerID,   0);  // texturing unit 0 -> samplerID   [for the GPU linker]
  glActiveTexture(GL_TEXTURE0 + 0);  // texturing unit 0 -> to be bound [for OpenGL BindTexture]

  // =============================== BEGIN OF SOLUTION - TASK 2b ======================================
  // based on m_time and m_textureIDs.size();,display all the frames in a loop
  unsigned frameNumber = (((int)(m_time*10))%m_textureIDs.size()); // compute the frame here
  glBindTexture(GL_TEXTURE_2D,  m_textureIDs[frameNumber] );
  // =============================== END OF SOLUTION - TASK 2b ======================================
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrap_s);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrap_t);

  glDrawArrays(GL_TRIANGLE_STRIP,  0, 4);  // just one quad

  glBindVertexArray( 0 );

  glDisable(GL_BLEND);

}
Example #3
0
void SplineSegmentNode::draw(const glm::mat4 & view_matrix, const glm::mat4 & projection_matrix)
{
  // inherited draw - draws all children
  SceneNode::draw(view_matrix, projection_matrix);

  glm::mat4 matrix = projection_matrix * view_matrix * globalMatrix();

  glUseProgram(m_program);
  glUniformMatrix4fv(m_PVMmatrixLoc, 1, GL_FALSE, glm::value_ptr(matrix) );

  glBindVertexArray( m_vertexArrayObject );
   
    // Draw envelope
    glUniform4fv( m_colLoc, 1, glm::value_ptr(vec4(1.0, 1.0, 1.0, 1.0) )); 
    glDrawArrays(GL_LINE_STRIP, 0, curveTestSize ); 

    // draw the spline curve
    glLineWidth( 3.0f);
    glUniform4fv( m_colLoc, 1, glm::value_ptr(vec4(1.0, 1.0, 0.0, 1.0) )); 
    glDrawArrays(GL_LINE_STRIP, curveTestSize, m_numberOfCurveSamples ); 
    glLineWidth( 1.0f);

    // draw control points
    // set OpenGL
    glDisable(GL_DEPTH_TEST);
    glEnable(GL_POINT_SMOOTH);
    glPointSize(5.0f);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glUniform4fv( m_colLoc, 1, glm::value_ptr(vec4(1.0, 0.0, 0.0, 1.0) )); 
    
    glDrawArrays(GL_POINTS, 0, 1); 
    glDrawArrays(GL_POINTS, 1, 1); 
    glDrawArrays(GL_POINTS, 2, 1); 
    glDrawArrays(GL_POINTS, 3, 1); 
    
    glDisable(GL_POINT_SMOOTH);

    // tangents
    glUniform4fv( m_colLoc, 1, glm::value_ptr(vec4(0.0, 0.0, 1.0, 1.0) )); // blue 
    glDrawArrays( GL_LINES, curveTestSize + m_numberOfCurveSamples, 4);

    // Draw envelope plananars
    glDisable(GL_CULL_FACE );
    glUniform4fv( m_colLoc, 1, glm::value_ptr(vec4(0.5, 1.0, 0.5, 0.1) )); 
    glDrawArrays( GL_TRIANGLES, 0, 3);
    glDrawArrays( GL_TRIANGLES, 1, 3);

    glEnable(GL_CULL_FACE );
    glEnable(GL_DEPTH_TEST);
    
  glBindVertexArray( 0 );
}
void dgCollisionInstance::CalculateBuoyancyAcceleration (const dgMatrix& matrix, const dgVector& origin, const dgVector& gravity, const dgVector& fluidPlane, dgFloat32 fluidDensity, dgFloat32 fluidViscosity, dgVector& unitForce, dgVector& unitTorque)
{
	dgMatrix globalMatrix (m_localMatrix * matrix);

	unitForce = dgVector (dgFloat32 (0.0f));
	unitTorque = dgVector (dgFloat32 (0.0f));
	dgVector volumeIntegral (m_childShape->CalculateVolumeIntegral (globalMatrix, fluidPlane, *this));
	if (volumeIntegral.m_w > dgFloat32 (0.0f)) {
		dgVector buoyanceCenter (volumeIntegral - origin);

		dgVector force (gravity.Scale (-fluidDensity * volumeIntegral.m_w));
		dgVector torque (buoyanceCenter.CrossProduct(force));

		unitForce += force;
		unitTorque += torque;
	}
}
Example #5
0
    void Canvas::updateVertexBuffer(std::vector<Sprite*> &sprites) {
        vector<vec3> position;
        vector<vec2> textureCoords;
        vector<vec4> colors;
        vector<GLushort> indices;
        sort(sprites.begin(), sprites.end(), [](Sprite* s1, Sprite* s2){
            return s1->order() < s2->order();
        });
        unsigned short index = 0;
        for (unsigned short i=0;i<sprites.size();i++){
            auto sprite = sprites[i];
            auto transform = sprite->transform();

            vec2 size = (vec2) sprite->textureAtlas()->textureSize();
            mat4 toWorld = transform->globalMatrix();
            vec2 scale = sprite->scale();


            TextureAtlasEntry entry = sprite->entry();
            Bounds2 bounds = sprite->trimmedBounds();
            vec4 color = sprite->color();

            if (sprite->type() == SpriteType::Simple) {
                position.push_back((vec3) (toWorld * vec4{bounds.lowLeft(), 0, 1}));
                position.push_back((vec3) (toWorld * vec4{bounds.lowRight(), 0, 1}));
                position.push_back((vec3) (toWorld * vec4{bounds.upperRight(), 0, 1}));
                position.push_back((vec3) (toWorld * vec4{bounds.upperLeft(), 0, 1}));

                vec2 min{entry.frame.x / size.x, 1.0 - (entry.frame.y + entry.frame.w) / size.y};
                vec2 max{(entry.frame.x + entry.frame.z) / size.x, 1.0 - entry.frame.y / size.y};
                textureCoords.push_back(vec2{min.x, min.y});
                textureCoords.push_back(vec2{max.x, min.y});
                textureCoords.push_back(vec2{max.x, max.y});
                textureCoords.push_back(vec2{min.x, max.y});

                colors.push_back(color);
                colors.push_back(color);
                colors.push_back(color);
                colors.push_back(color);

                // push two triangles
                indices.push_back(index);
                indices.push_back(index + 1);
                indices.push_back(index + 2);
                indices.push_back(index + 2);
                indices.push_back(index + 3);
                indices.push_back(index);
                index+=4;
            }
            else if (sprite->type() == SpriteType::Sliced) {
                vec2 dim {entry.frame.z,entry.frame.w};
                vec4 sliceX = vec4{bounds.min.x, bounds.min.x + dim.x * sprite->sliceX()[0],bounds.max.x - dim.x * (1.0- sprite->sliceX()[1]), bounds.max.x};
                vec4 sliceY = vec4{bounds.min.y, bounds.min.y + dim.y * sprite->sliceY()[0],bounds.max.y - dim.y * (1.0- sprite->sliceY()[1]), bounds.max.y};

                vec2 min{entry.frame.x / size.x, 1.0 - (entry.frame.y + entry.frame.w) / size.y};
                vec2 max{(entry.frame.x + entry.frame.z) / size.x, 1.0 - entry.frame.y / size.y};
                vec4 uvX{min.x, lerp(min.x, max.x, sprite->sliceX()[0]),lerp(min.x, max.x, sprite->sliceX()[1]),max.x};
                vec4 uvY{min.y, lerp(min.y, max.y, sprite->sliceY()[0]),lerp(min.y, max.y, sprite->sliceY()[1]),max.y};

                for (int x=0;x<3;x++){
                    for (int y=0;y<3;y++){
                        position.push_back((vec3) (toWorld * vec4{sliceX[x], sliceY[y], 0, 1}));
                        position.push_back((vec3) (toWorld * vec4{sliceX[x+1], sliceY[y], 0, 1}));
                        position.push_back((vec3) (toWorld * vec4{sliceX[x+1], sliceY[y+1], 0, 1}));
                        position.push_back((vec3) (toWorld * vec4{sliceX[x], sliceY[y+1], 0, 1}));

                        textureCoords.push_back(vec2{uvX[x], uvY[y]});
                        textureCoords.push_back(vec2{uvX[x+1], uvY[y]});
                        textureCoords.push_back(vec2{uvX[x+1], uvY[y+1]});
                        textureCoords.push_back(vec2{uvX[x], uvY[y+1]});

                        colors.push_back(color);
                        colors.push_back(color);
                        colors.push_back(color);
                        colors.push_back(color);

                        // push two triangles
                        indices.push_back(index);
                        indices.push_back(index + 1);
                        indices.push_back(index + 2);
                        indices.push_back(index + 2);
                        indices.push_back(index + 3);
                        indices.push_back(index);
                        index+=4;
                    }
                }
            }
        }
        mMeshData->setPosition(position);
        mMeshData->setColor(colors);
        mMeshData->setTexCoord0(textureCoords);
        mMeshData->setSubmesh(0,indices, MeshType::Triangles);
        mMesh->setMeshData(mMeshData);
    }