Example #1
0
 protected void setFromRGB(Color4f c, int argb) {
   c.set(
       ((argb >> 16) & 0xff) * r255,
       ((argb >> 8) & 0xff) * r255,
       (argb & 0xff) * r255,
       ((argb >> 24) & 0xff) * r255);
 }
Example #2
0
 /**
  * Prepare the light for rendering.
  *
  * @param width the output image width
  * @param height the output image height
  */
 public void prepare(int width, int height) {
   float lx = (float) (Math.cos(azimuth) * Math.cos(elevation));
   float ly = (float) (Math.sin(azimuth) * Math.cos(elevation));
   float lz = (float) Math.sin(elevation);
   direction = new Vector3f(lx, ly, lz);
   direction.normalize();
   if (type != DISTANT) {
     lx *= distance;
     ly *= distance;
     lz *= distance;
     lx += width * centreX;
     ly += height * centreY;
   }
   position = new Vector3f(lx, ly, lz);
   realColor.set(new Color(color));
   realColor.scale(intensity);
   cosConeAngle = (float) Math.cos(coneAngle);
 }
Example #3
0
  protected Color4f phongShade(
      Vector3f position,
      Vector3f viewpoint,
      Vector3f normal,
      Color4f diffuseColor,
      Color4f specularColor,
      Material material,
      Light[] lightsArray) {
    shadedColor.set(diffuseColor);
    shadedColor.scale(material.ambientIntensity);

    for (int i = 0; i < lightsArray.length; i++) {
      Light light = lightsArray[i];
      n.set(normal);
      l.set(light.position);
      if (light.type != DISTANT) l.sub(position);
      l.normalize();
      float nDotL = n.dot(l);
      if (nDotL >= 0.0) {
        float dDotL = 0;

        v.set(viewpoint);
        v.sub(position);
        v.normalize();

        // Spotlight
        if (light.type == SPOT) {
          dDotL = light.direction.dot(l);
          if (dDotL < light.cosConeAngle) continue;
        }

        n.scale(2.0f * nDotL);
        n.sub(l);
        float rDotV = n.dot(v);

        float rv;
        if (rDotV < 0.0) rv = 0.0f;
        else
          //					rv = (float)Math.pow(rDotV, material.highlight);
          rv =
              rDotV
                  / (material.highlight
                      - material.highlight * rDotV
                      + rDotV); // Fast approximation to pow

        // Spotlight
        if (light.type == SPOT) {
          dDotL = light.cosConeAngle / dDotL;
          float e = dDotL;
          e *= e;
          e *= e;
          e *= e;
          e = (float) Math.pow(dDotL, light.focus * 10) * (1 - e);
          rv *= e;
          nDotL *= e;
        }

        diffuse_color.set(diffuseColor);
        diffuse_color.scale(material.diffuseReflectivity);
        diffuse_color.x *= light.realColor.x * nDotL;
        diffuse_color.y *= light.realColor.y * nDotL;
        diffuse_color.z *= light.realColor.z * nDotL;
        specular_color.set(specularColor);
        specular_color.scale(material.specularReflectivity);
        specular_color.x *= light.realColor.x * rv;
        specular_color.y *= light.realColor.y * rv;
        specular_color.z *= light.realColor.z * rv;
        diffuse_color.add(specular_color);
        diffuse_color.clamp(0, 1);
        shadedColor.add(diffuse_color);
      }
    }
    shadedColor.clamp(0, 1);
    return shadedColor;
  }
Example #4
0
  protected int[] filterPixels(int width, int height, int[] inPixels, Rectangle transformedSpace) {
    int index = 0;
    int[] outPixels = new int[width * height];
    float width45 = Math.abs(6.0f * bumpHeight);
    boolean invertBumps = bumpHeight < 0;
    Vector3f position = new Vector3f(0.0f, 0.0f, 0.0f);
    Vector3f viewpoint = new Vector3f((float) width / 2.0f, (float) height / 2.0f, viewDistance);
    Vector3f normal = new Vector3f();
    Color4f envColor = new Color4f();
    Color4f diffuseColor = new Color4f(new Color(material.diffuseColor));
    Color4f specularColor = new Color4f(new Color(material.specularColor));
    Function2D bump = bumpFunction;

    // Apply the bump softness
    if (bumpSource == BUMPS_FROM_IMAGE
        || bumpSource == BUMPS_FROM_IMAGE_ALPHA
        || bumpSource == BUMPS_FROM_MAP
        || bump == null) {
      if (bumpSoftness != 0) {
        int bumpWidth = width;
        int bumpHeight = height;
        int[] bumpPixels = inPixels;
        if (bumpSource == BUMPS_FROM_MAP && bumpFunction instanceof ImageFunction2D) {
          ImageFunction2D if2d = (ImageFunction2D) bumpFunction;
          bumpWidth = if2d.getWidth();
          bumpHeight = if2d.getHeight();
          bumpPixels = if2d.getPixels();
        }
        int[] tmpPixels = new int[bumpWidth * bumpHeight];
        int[] softPixels = new int[bumpWidth * bumpHeight];
        /*
        				for (int i = 0; i < 3; i++ ) {
        					BoxBlurFilter.blur( bumpPixels, tmpPixels, bumpWidth, bumpHeight, (int)bumpSoftness );
        					BoxBlurFilter.blur( tmpPixels, softPixels, bumpHeight, bumpWidth, (int)bumpSoftness );
        				}
        */
        Kernel kernel = GaussianFilter.makeKernel(bumpSoftness);
        GaussianFilter.convolveAndTranspose(
            kernel,
            bumpPixels,
            tmpPixels,
            bumpWidth,
            bumpHeight,
            true,
            false,
            false,
            GaussianFilter.WRAP_EDGES);
        GaussianFilter.convolveAndTranspose(
            kernel,
            tmpPixels,
            softPixels,
            bumpHeight,
            bumpWidth,
            true,
            false,
            false,
            GaussianFilter.WRAP_EDGES);
        bump =
            new ImageFunction2D(
                softPixels,
                bumpWidth,
                bumpHeight,
                ImageFunction2D.CLAMP,
                bumpSource == BUMPS_FROM_IMAGE_ALPHA);
        final Function2D bbump = bump;
        if (bumpShape != 0) {
          bump =
              new Function2D() {
                private Function2D original = bbump;

                public float evaluate(float x, float y) {
                  float v = original.evaluate(x, y);
                  switch (bumpShape) {
                    case 1:
                      //				v = v > 0.5f ? 0.5f : v;
                      v *= ImageMath.smoothStep(0.45f, 0.55f, v);
                      break;
                    case 2:
                      v = v < 0.5f ? 0.5f : v;
                      break;
                    case 3:
                      v = ImageMath.triangle(v);
                      break;
                    case 4:
                      v = ImageMath.circleDown(v);
                      break;
                    case 5:
                      v = ImageMath.gain(v, 0.75f);
                      break;
                  }
                  return v;
                }
              };
        }
      } else if (bumpSource != BUMPS_FROM_MAP)
        bump =
            new ImageFunction2D(
                inPixels,
                width,
                height,
                ImageFunction2D.CLAMP,
                bumpSource == BUMPS_FROM_IMAGE_ALPHA);
    }

    float reflectivity = material.reflectivity;
    float areflectivity = (1 - reflectivity);
    Vector3f v1 = new Vector3f();
    Vector3f v2 = new Vector3f();
    Vector3f n = new Vector3f();
    Light[] lightsArray = new Light[lights.size()];
    lights.copyInto(lightsArray);
    for (int i = 0; i < lightsArray.length; i++) lightsArray[i].prepare(width, height);

    float[][] heightWindow = new float[3][width];
    for (int x = 0; x < width; x++) heightWindow[1][x] = width45 * bump.evaluate(x, 0);

    // Loop through each source pixel
    for (int y = 0; y < height; y++) {
      boolean y0 = y > 0;
      boolean y1 = y < height - 1;
      position.y = y;
      for (int x = 0; x < width; x++) heightWindow[2][x] = width45 * bump.evaluate(x, y + 1);
      for (int x = 0; x < width; x++) {
        boolean x0 = x > 0;
        boolean x1 = x < width - 1;

        // Calculate the normal at this point
        if (bumpSource != BUMPS_FROM_BEVEL) {
          // Complicated and slower method
          // Calculate four normals using the gradients in +/- X/Y directions
          int count = 0;
          normal.x = normal.y = normal.z = 0;
          float m0 = heightWindow[1][x];
          float m1 = x0 ? heightWindow[1][x - 1] - m0 : 0;
          float m2 = y0 ? heightWindow[0][x] - m0 : 0;
          float m3 = x1 ? heightWindow[1][x + 1] - m0 : 0;
          float m4 = y1 ? heightWindow[2][x] - m0 : 0;

          if (x0 && y1) {
            v1.x = -1.0f;
            v1.y = 0.0f;
            v1.z = m1;
            v2.x = 0.0f;
            v2.y = 1.0f;
            v2.z = m4;
            n.cross(v1, v2);
            n.normalize();
            if (n.z < 0.0) n.z = -n.z;
            normal.add(n);
            count++;
          }

          if (x0 && y0) {
            v1.x = -1.0f;
            v1.y = 0.0f;
            v1.z = m1;
            v2.x = 0.0f;
            v2.y = -1.0f;
            v2.z = m2;
            n.cross(v1, v2);
            n.normalize();
            if (n.z < 0.0) n.z = -n.z;
            normal.add(n);
            count++;
          }

          if (y0 && x1) {
            v1.x = 0.0f;
            v1.y = -1.0f;
            v1.z = m2;
            v2.x = 1.0f;
            v2.y = 0.0f;
            v2.z = m3;
            n.cross(v1, v2);
            n.normalize();
            if (n.z < 0.0) n.z = -n.z;
            normal.add(n);
            count++;
          }

          if (x1 && y1) {
            v1.x = 1.0f;
            v1.y = 0.0f;
            v1.z = m3;
            v2.x = 0.0f;
            v2.y = 1.0f;
            v2.z = m4;
            n.cross(v1, v2);
            n.normalize();
            if (n.z < 0.0) n.z = -n.z;
            normal.add(n);
            count++;
          }

          // Average the four normals
          normal.x /= count;
          normal.y /= count;
          normal.z /= count;
        }
        if (invertBumps) {
          normal.x = -normal.x;
          normal.y = -normal.y;
        }
        position.x = x;

        if (normal.z >= 0) {
          // Get the material colour at this point
          if (colorSource == COLORS_FROM_IMAGE) setFromRGB(diffuseColor, inPixels[index]);
          else setFromRGB(diffuseColor, material.diffuseColor);
          if (reflectivity != 0 && environmentMap != null) {
            // FIXME-too much normalizing going on here
            tmpv2.set(viewpoint);
            tmpv2.sub(position);
            tmpv2.normalize();
            tmpv.set(normal);
            tmpv.normalize();

            // Reflect
            tmpv.scale(2.0f * tmpv.dot(tmpv2));
            tmpv.sub(v);

            tmpv.normalize();
            setFromRGB(
                envColor, getEnvironmentMap(tmpv, inPixels, width, height)); // FIXME-interpolate()
            diffuseColor.x = reflectivity * envColor.x + areflectivity * diffuseColor.x;
            diffuseColor.y = reflectivity * envColor.y + areflectivity * diffuseColor.y;
            diffuseColor.z = reflectivity * envColor.z + areflectivity * diffuseColor.z;
          }
          // Shade the pixel
          Color4f c =
              phongShade(
                  position, viewpoint, normal, diffuseColor, specularColor, material, lightsArray);
          int alpha = inPixels[index] & 0xff000000;
          int rgb = ((int) (c.x * 255) << 16) | ((int) (c.y * 255) << 8) | (int) (c.z * 255);
          outPixels[index++] = alpha | rgb;
        } else outPixels[index++] = 0;
      }
      float[] t = heightWindow[0];
      heightWindow[0] = heightWindow[1];
      heightWindow[1] = heightWindow[2];
      heightWindow[2] = t;
    }
    return outPixels;
  }