Beispiel #1
0
void Radiosity::Reset() {
  delete [] area;
  delete [] undistributed;
  delete [] absorbed;
  delete [] radiance;

  // create and fill the data structures
  num_faces = mesh->numFaces();
  area = new float[num_faces];
  undistributed = new glm::vec3[num_faces];
  absorbed = new glm::vec3[num_faces];
  radiance = new glm::vec3[num_faces];
  for (int i = 0; i < num_faces; i++) {
    Face *f = mesh->getFace(i);
    f->setRadiosityPatchIndex(i);
    setArea(i,f->getArea());
    glm::vec3 emit = f->getMaterial()->getEmittedColor();
    setUndistributed(i,emit);
    setAbsorbed(i,glm::vec3(0,0,0));
    setRadiance(i,emit);
  }

  // find the patch with the most undistributed energy
  findMaxUndistributed();
}
Beispiel #2
0
double Radiosity::Iterate() {
    if (formfactors == NULL) 
        ComputeFormFactors();
    assert (formfactors != NULL);
    
    
    
    // ==========================================
    // ASSIGNMENT:  IMPLEMENT RADIOSITY ALGORITHM
    // ==========================================
    
    for (int i = 0; i < num_faces; ++i) {
        Face *f1 = mesh->getFace(i);
        Material *m = f1->getMaterial();
        Vec3f p_i = m->getDiffuseColor();
        
        int j = max_undistributed_patch;
        
        if (i == j) {
            continue;
        }
        
        Vec3f ff = formfactors[i * num_faces + j] * getUndistributed(j);
        
        setRadiance(i, getRadiance(i) + ff * p_i);
        setUndistributed(i, getUndistributed(i) + ff * p_i);
        setAbsorbed(i, getAbsorbed(i) + (Vec3f(1,1,1)-p_i) * ff);
    }
    
    setUndistributed(max_undistributed_patch, Vec3f(0,0,0));
    
    // return the total light yet undistributed
    // (so we can decide when the solution has sufficiently converged)
    findMaxUndistributed();
    return total_undistributed;    
}
float Radiosity::Iterate() {
  if (formfactors == NULL) 
    ComputeFormFactors();
  assert (formfactors != NULL);




  // ==========================================
  // ASSIGNMENT:  IMPLEMENT RADIOSITY ALGORITHM
  // ==========================================

    //printf("\n\n");
    
    //take the thing with the most undistributed radiosity
    findMaxUndistributed();
    
    float totalUnd = 0;
    
    for(int j = 0; j<num_faces; j++)
    {
        if (j == max_undistributed_patch)
        {
            continue;
        }
        //use max_undistributed_patch for the thing giving away radience
        
        //the j panel absorbs some of the light and reflects the rest
        
        /*printf("MaxUndist: (%f %f %f)\tJDiffuseColor: (%f %f %f)\tAbsorbed: (%f %f %f)\tRadiance: (%f %f %f)\tUndistributed: (%f %f %f)\t\n\n", getUndistributed(max_undistributed_patch).x, getUndistributed(max_undistributed_patch).y, getUndistributed(max_undistributed_patch).z,
               mesh->getFace(j)->getMaterial()->getDiffuseColor().x, mesh->getFace(j)->getMaterial()->getDiffuseColor().y, mesh->getFace(j)->getMaterial()->getDiffuseColor().z,
               getAbsorbed(j).x, getAbsorbed(j).y, getAbsorbed(j).z,
               getRadiance(j).x, getRadiance(j).y, getRadiance(j).x,
               getUndistributed(j).x, getUndistributed(j).y, getUndistributed(j).z);//*/
        
        
        //give it to everyone else based on form factor
        setRadiance(j, getUndistributed(max_undistributed_patch)*(getFormFactor(max_undistributed_patch, j)/
                       totalFormFactori[max_undistributed_patch])*mesh->getFace(j)->getMaterial()->getDiffuseColor() +//- getAbsorbed(j) + *******INSTEAD OF GET ABSORBED THIS SHOULD BE PANEL COLOR)
                        getRadiance(j));//*/
        
        setAbsorbed(j,  (getUndistributed(max_undistributed_patch)*(1.0f-mesh->getFace(j)->getMaterial()->getDiffuseColor()))*
                    (getFormFactor(max_undistributed_patch, j)/totalFormFactori[max_undistributed_patch]) +
                    (getAbsorbed(j)));//*/
        
        setUndistributed(j, getUndistributed(max_undistributed_patch)*(getFormFactor(max_undistributed_patch, j)/
                            totalFormFactori[max_undistributed_patch])*mesh->getFace(j)->getMaterial()->getDiffuseColor() +
                         getUndistributed(j));//*/
        
        totalUnd += glm::length(getUndistributed(j));
        
        /*printf("MaxUndist: (%f %f %f)\tJDiffuseColor: (%f %f %f)\tAbsorbed: (%f %f %f)\tRadiance: (%f %f %f)\tUndistributed: (%f %f %f)\t\n", getUndistributed(max_undistributed_patch).x, getUndistributed(max_undistributed_patch).y, getUndistributed(max_undistributed_patch).z,
               mesh->getFace(j)->getMaterial()->getDiffuseColor().x, mesh->getFace(j)->getMaterial()->getDiffuseColor().y, mesh->getFace(j)->getMaterial()->getDiffuseColor().z,
               getAbsorbed(j).x, getAbsorbed(j).y, getAbsorbed(j).z,
               getRadiance(j).x, getRadiance(j).y, getRadiance(j).x,
               getUndistributed(j).x, getUndistributed(j).y, getUndistributed(j).z);
        
        printf("***************************************************************************************\n");//*/
        
        
        
    }
    //setRadiance(max_undistributed_patch, glm::vec3(0,0,0));
    setUndistributed(max_undistributed_patch, glm::vec3(0, 0, 0));
    
    
    
  //==============================================
  // return the total light yet undistributed
  //==============================================
    
  // (so we can decide when the solution has sufficiently converged)

    //printf("TotalUndistributed: %f", totalUnd);
    
  return totalUnd;




}