コード例 #1
0
ファイル: FrustumBinner.hpp プロジェクト: tunabrain/tungsten
    void binPlane1D(Vec3f center, Vec3f a, Vec3f b, Vec3f c, Intersector intersector) const
    {
        center = _invT*center;
        a = _invT.transformVector(a);
        b = _invT.transformVector(b);
        c = _invT.transformVector(c);

        std::array<QuadSetup, 6> quads{{
            setupQuad(center + c - a - b, center + c - a + b, center + c + a + b, center + c + a - b),
            setupQuad(center - c - a - b, center - c - a + b, center - c + a + b, center - c + a - b),
            setupQuad(center + b - a - c, center + b - a + c, center + b + a + c, center + b + a - c),
            setupQuad(center - b - a - c, center - b - a + c, center - b + a + c, center - b + a - c),
            setupQuad(center + a - b - c, center + a - b + c, center + a + b + c, center + a + b - c),
            setupQuad(center - a - b - c, center - a - b + c, center - a + b + c, center - a + b - c)
        }};

        iterateTiles(quads, intersector);
    }
コード例 #2
0
ファイル: rectangle.cpp プロジェクト: daniel86/regen
void Rectangle::updateAttributes(Config cfg)
{
  std::vector<TriangleFace> *faces; {
    TriangleVertex level0[4];
    level0[0] = TriangleVertex(Vec3f(0.0,0.0,0.0),0);
    level0[1] = TriangleVertex(Vec3f(1.0,0.0,0.0),1);
    level0[2] = TriangleVertex(Vec3f(1.0,0.0,1.0),2);
    level0[3] = TriangleVertex(Vec3f(0.0,0.0,1.0),3);

    std::vector<TriangleFace> facesLevel0(2);
    facesLevel0[0] = TriangleFace( level0[0], level0[1], level0[3] );
    facesLevel0[1] = TriangleFace( level0[1], level0[2], level0[3] );
    faces = tessellate(cfg.levelOfDetail, facesLevel0);
  }
  Mat4f rotMat = Mat4f::rotationMatrix(cfg.rotation.x, cfg.rotation.y, cfg.rotation.z);
  GLboolean useIndexBuffer = (cfg.levelOfDetail>1);

  GLuint numVertices;
  std::map<GLuint,GLuint> indexMap;
  std::set<GLuint> processedIndices;

  ref_ptr<ShaderInput1ui> indices;
  if(useIndexBuffer) {
    // Allocate RAM for indices
    GLuint numIndices = faces->size()*3;
    indices = ref_ptr<ShaderInput1ui>::alloc("i");
    indices->setVertexData(numIndices);
    GLuint *indicesPtr = (GLuint*)indices->clientDataPtr();

    // Set index data and compute vertex count
    GLuint currIndex = 0;
    for(GLuint faceIndex=0; faceIndex<faces->size(); ++faceIndex) {
      TriangleFace &face = (*faces)[faceIndex];
      TriangleVertex *vertices = (TriangleVertex*)&face;

      for(GLuint i=0; i<3; ++i) {
        TriangleVertex &vertex = vertices[i];
        // Find vertex index
        if(indexMap.count(vertex.i)==0) {
          indexMap[vertex.i] = currIndex;
          currIndex += 1;
        }
        // Add to indices attribute
        *indicesPtr = indexMap[vertex.i];
        indicesPtr += 1;
      }
    }
    numVertices = indexMap.size();
  }
  else {
    numVertices = faces->size()*3;
  }

  if(cfg.isTangentRequired) {
    cfg.isNormalRequired = GL_TRUE;
    cfg.isTexcoRequired = GL_TRUE;
  }
  Vec3f startPos;
  if(cfg.centerAtOrigin) {
    startPos = Vec3f(-cfg.posScale.x*0.5f, 0.0f, -cfg.posScale.z*0.5f);
  } else {
    startPos = Vec3f(0.0f, 0.0f, 0.0f);
  }

  // allocate attributes
  pos_->setVertexData(numVertices);
  if(cfg.isNormalRequired) {
    nor_->setVertexData(numVertices);
  }
  if(cfg.isTexcoRequired) {
    texco_->setVertexData(numVertices);
  }
  if(cfg.isTangentRequired) {
    tan_->setVertexData(numVertices);
  }

  GLuint triIndices[3];
  Vec3f triVertices[3];
  Vec2f triTexco[3];
  Vec3f normal = rotMat.transformVector(Vec3f(0.0,-1.0,0.0));

  for(GLuint faceIndex=0; faceIndex<faces->size(); ++faceIndex) {
    TriangleFace &face = (*faces)[faceIndex];
    TriangleVertex *vertices = (TriangleVertex*)&face;

    for(GLuint i=0; i<3; ++i) {
      GLuint vertexIndex;
      if(useIndexBuffer) {
        vertexIndex = indexMap[vertices[i].i];
      }
      else {
        vertexIndex = faceIndex*3+i;
      }
      triIndices[i] = vertexIndex;

      if(processedIndices.count(vertexIndex)>0) {
        if(cfg.isTangentRequired) {
          triVertices[i] = pos_->getVertex(vertexIndex);
          triTexco[i]    = texco_->getVertex(vertexIndex);
        }
        continue;
      }
      processedIndices.insert(vertexIndex);

      pos_->setVertex(vertexIndex, rotMat.transformVector(
          cfg.posScale*vertices[i].p + startPos) + cfg.translation);
      if(cfg.isNormalRequired) {
        nor_->setVertex(vertexIndex, normal);
      }
      if(cfg.isTexcoRequired) {
        texco_->setVertex(vertexIndex, cfg.texcoScale -
            (cfg.texcoScale*Vec2f(vertices[i].p.x,vertices[i].p.z)));
      }
      if(cfg.isTangentRequired) {
        triVertices[i] = pos_->getVertex(vertexIndex);
        triTexco[i] = texco_->getVertex(vertexIndex);
      }
    }

    if(cfg.isTangentRequired) {
      Vec4f tangent = calculateTangent(triVertices, triTexco, normal);
      for(GLuint i=0; i<3; ++i) {
        tan_->setVertex(triIndices[i], tangent);
      }
    }
  }
  delete faces;

  begin(ShaderInputContainer::INTERLEAVED);
  if(useIndexBuffer) setIndices(indices, numVertices);
  setInput(pos_);
  if(cfg.isNormalRequired)
    setInput(nor_);
  if(cfg.isTexcoRequired)
    setInput(texco_);
  if(cfg.isTangentRequired)
    setInput(tan_);
  end();

  minPosition_ = -cfg.posScale;
  maxPosition_ = cfg.posScale;
}