public Color getIrradiance(ShadingState state, Color diffuseReflectance) {
   OrthoNormalBasis onb = state.getBasis();
   Vector3 w = new Vector3();
   Color result = Color.black();
   for (int i = 0; i < samples; i++) {
     float xi = (float) state.getRandom(i, 0, samples);
     float xj = (float) state.getRandom(i, 1, samples);
     float phi = (float) (2 * Math.PI * xi);
     float cosPhi = (float) Math.cos(phi);
     float sinPhi = (float) Math.sin(phi);
     float sinTheta = (float) Math.sqrt(xj);
     float cosTheta = (float) Math.sqrt(1.0f - xj);
     w.x = cosPhi * sinTheta;
     w.y = sinPhi * sinTheta;
     w.z = cosTheta;
     onb.transform(w);
     Ray r = new Ray(state.getPoint(), w);
     r.setMax(maxDist);
     result.add(Color.blend(bright, dark, state.traceShadow(r)));
   }
   return result.mul((float) Math.PI / samples);
 }
Exemple #2
0
 public void prepareShadingState(ShadingState state) {
   state.init();
   state.getRay().getPoint(state.getPoint());
   Instance parent = state.getInstance();
   Point3 p = parent.transformWorldToObject(state.getPoint());
   float deriv = p.x * p.x + p.y * p.y + p.z * p.z - ri2 - ro2;
   state.getNormal().set(p.x * deriv, p.y * deriv, p.z * deriv + 2 * ro2 * p.z);
   state.getNormal().normalize();
   double phi = Math.asin(MathUtils.clamp(p.z / ri, -1, 1));
   double theta = Math.atan2(p.y, p.x);
   if (theta < 0) theta += 2 * Math.PI;
   state.getUV().x = (float) (theta / (2 * Math.PI));
   state.getUV().y = (float) ((phi + Math.PI / 2) / Math.PI);
   state.setShader(parent.getShader(0));
   state.setModifier(parent.getModifier(0));
   Vector3 worldNormal = parent.transformNormalObjectToWorld(state.getNormal());
   state.getNormal().set(worldNormal);
   state.getNormal().normalize();
   state.getGeoNormal().set(state.getNormal());
   state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
 }
Exemple #3
0
  public void prepareShadingState(ShadingState state) {
    state.init();
    Instance parent = state.getInstance();
    int primID = state.getPrimitiveID();
    float u = state.getU();
    float v = state.getV();
    state.getRay().getPoint(state.getPoint());
    int quad = 4 * primID;
    int index0 = quads[quad + 0];
    int index1 = quads[quad + 1];
    int index2 = quads[quad + 2];
    int index3 = quads[quad + 3];
    Point3 v0p = getPoint(index0);
    Point3 v1p = getPoint(index1);
    Point3 v2p = getPoint(index2);
    Point3 v3p = getPoint(index2);
    float tanux = (1 - v) * (v1p.x - v0p.x) + v * (v2p.x - v3p.x);
    float tanuy = (1 - v) * (v1p.y - v0p.y) + v * (v2p.y - v3p.y);
    float tanuz = (1 - v) * (v1p.z - v0p.z) + v * (v2p.z - v3p.z);

    float tanvx = (1 - u) * (v3p.x - v0p.x) + u * (v2p.x - v1p.x);
    float tanvy = (1 - u) * (v3p.y - v0p.y) + u * (v2p.y - v1p.y);
    float tanvz = (1 - u) * (v3p.z - v0p.z) + u * (v2p.z - v1p.z);

    float nx = tanuy * tanvz - tanuz * tanvy;
    float ny = tanuz * tanvx - tanux * tanvz;
    float nz = tanux * tanvy - tanuy * tanvx;

    Vector3 ng = new Vector3(nx, ny, nz);
    ng = state.transformNormalObjectToWorld(ng);
    ng.normalize();
    state.getGeoNormal().set(ng);

    float k00 = (1 - u) * (1 - v);
    float k10 = u * (1 - v);
    float k01 = (1 - u) * v;
    float k11 = u * v;

    switch (normals.interp) {
      case NONE:
      case FACE:
        {
          state.getNormal().set(ng);
          break;
        }
      case VERTEX:
        {
          int i30 = 3 * index0;
          int i31 = 3 * index1;
          int i32 = 3 * index2;
          int i33 = 3 * index3;
          float[] normals = this.normals.data;
          state.getNormal().x =
              k00 * normals[i30 + 0]
                  + k10 * normals[i31 + 0]
                  + k11 * normals[i32 + 0]
                  + k01 * normals[i33 + 0];
          state.getNormal().y =
              k00 * normals[i30 + 1]
                  + k10 * normals[i31 + 1]
                  + k11 * normals[i32 + 1]
                  + k01 * normals[i33 + 1];
          state.getNormal().z =
              k00 * normals[i30 + 2]
                  + k10 * normals[i31 + 2]
                  + k11 * normals[i32 + 2]
                  + k01 * normals[i33 + 2];
          state.getNormal().set(state.transformNormalObjectToWorld(state.getNormal()));
          state.getNormal().normalize();
          break;
        }
      case FACEVARYING:
        {
          int idx = 3 * quad;
          float[] normals = this.normals.data;
          state.getNormal().x =
              k00 * normals[idx + 0]
                  + k10 * normals[idx + 3]
                  + k11 * normals[idx + 6]
                  + k01 * normals[idx + 9];
          state.getNormal().y =
              k00 * normals[idx + 1]
                  + k10 * normals[idx + 4]
                  + k11 * normals[idx + 7]
                  + k01 * normals[idx + 10];
          state.getNormal().z =
              k00 * normals[idx + 2]
                  + k10 * normals[idx + 5]
                  + k11 * normals[idx + 8]
                  + k01 * normals[idx + 11];
          state.getNormal().set(state.transformNormalObjectToWorld(state.getNormal()));
          state.getNormal().normalize();
          break;
        }
    }
    float uv00 = 0, uv01 = 0, uv10 = 0, uv11 = 0, uv20 = 0, uv21 = 0, uv30 = 0, uv31 = 0;
    switch (uvs.interp) {
      case NONE:
      case FACE:
        {
          state.getUV().x = 0;
          state.getUV().y = 0;
          break;
        }
      case VERTEX:
        {
          int i20 = 2 * index0;
          int i21 = 2 * index1;
          int i22 = 2 * index2;
          int i23 = 2 * index3;
          float[] uvs = this.uvs.data;
          uv00 = uvs[i20 + 0];
          uv01 = uvs[i20 + 1];
          uv10 = uvs[i21 + 0];
          uv11 = uvs[i21 + 1];
          uv20 = uvs[i22 + 0];
          uv21 = uvs[i22 + 1];
          uv20 = uvs[i23 + 0];
          uv21 = uvs[i23 + 1];
          break;
        }
      case FACEVARYING:
        {
          int idx = quad << 1;
          float[] uvs = this.uvs.data;
          uv00 = uvs[idx + 0];
          uv01 = uvs[idx + 1];
          uv10 = uvs[idx + 2];
          uv11 = uvs[idx + 3];
          uv20 = uvs[idx + 4];
          uv21 = uvs[idx + 5];
          uv30 = uvs[idx + 6];
          uv31 = uvs[idx + 7];
          break;
        }
    }
    if (uvs.interp != InterpolationType.NONE) {
      // get exact uv coords and compute tangent vectors
      state.getUV().x = k00 * uv00 + k10 * uv10 + k11 * uv20 + k01 * uv30;
      state.getUV().y = k00 * uv01 + k10 * uv11 + k11 * uv21 + k01 * uv31;
      float du1 = uv00 - uv20;
      float du2 = uv10 - uv20;
      float dv1 = uv01 - uv21;
      float dv2 = uv11 - uv21;
      Vector3 dp1 = Point3.sub(v0p, v2p, new Vector3()), dp2 = Point3.sub(v1p, v2p, new Vector3());
      float determinant = du1 * dv2 - dv1 * du2;
      if (determinant == 0.0f) {
        // create basis in world space
        state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
      } else {
        float invdet = 1.f / determinant;
        // Vector3 dpdu = new Vector3();
        // dpdu.x = (dv2 * dp1.x - dv1 * dp2.x) * invdet;
        // dpdu.y = (dv2 * dp1.y - dv1 * dp2.y) * invdet;
        // dpdu.z = (dv2 * dp1.z - dv1 * dp2.z) * invdet;
        Vector3 dpdv = new Vector3();
        dpdv.x = (-du2 * dp1.x + du1 * dp2.x) * invdet;
        dpdv.y = (-du2 * dp1.y + du1 * dp2.y) * invdet;
        dpdv.z = (-du2 * dp1.z + du1 * dp2.z) * invdet;
        dpdv = state.transformVectorObjectToWorld(dpdv);
        // create basis in world space
        state.setBasis(OrthoNormalBasis.makeFromWV(state.getNormal(), dpdv));
      }
    } else state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
    int shaderIndex = faceShaders == null ? 0 : (faceShaders[primID] & 0xFF);
    state.setShader(parent.getShader(shaderIndex));
    state.setModifier(parent.getModifier(shaderIndex));
  }