private final void computeArray(
      final double[] vd, final int[] vertices, final double[] nd, final int[] normals) {
    if (2 * vertices.length + 6 >= (vertexData.length - vertexCount) / Polygon.VERTEX_LENGTH)
      increaseVertexCapacity(vertices.length / 3);

    int vc = vertexCount;
    for (int i = 0; i < vertices.length; i++) {
      int vi = vertices[i];
      VecMat.transform(matrix, vd[vi++], vd[vi++], vd[vi], vertexData, vc + Polygon.SX);
      vertexData[vc + Polygon.SW] = 1;
      int ni = normals[i];
      VecMat.transformNormal(
          inverseTransposeMatrix, nd[ni++], nd[ni++], nd[ni], vertexData, vc + Polygon.NX);
      vc += Polygon.VERTEX_LENGTH;
      if (vertexColors) {
        DoubleArray color = vertexColor.item(vi / 3).toDoubleArray();
        vertexData[vc + Polygon.R] = color.getValueAt(0);
        vertexData[vc + Polygon.G] = color.getValueAt(1);
        vertexData[vc + Polygon.B] = color.getValueAt(2);
        vertexData[vc + Polygon.A] =
            (vertexColorLength == 4 || (vertexColorLength == -1 && color.getLength() > 3))
                ? color.getValueAt(3)
                : 1.;
      }
    }
    compute(vertices.length);
  }
Ejemplo n.º 2
0
  public ToolEvent process(VirtualDeviceContext context) throws MissingSlotException {
    if (context.getEvent().getInputSlot() == cameraToWorld) return null;
    DoubleArray pointer = context.getTransformationMatrix(pointerNDC);
    if (pointer == null) throw new MissingSlotException(pointerNDC);
    if (oldX == Integer.MAX_VALUE) {
      oldX = pointer.getValueAt(3);
      oldY = pointer.getValueAt(7);
      return null;
    }
    double x = pointer.getValueAt(3);
    double y = pointer.getValueAt(7);
    double dist = x * x + y * y;
    double z = 2 > dist ? Math.sqrt(2 - dist) : 0;
    Rn.setToValue(mouseCoords, x, y, z);

    mouseCoords = Rn.normalize(mouseCoords, mouseCoords);
    double[] cross = Rn.crossProduct(null, mouseCoordsOld, mouseCoords);
    double angle = gain * Math.asin(Rn.euclideanNorm(cross));
    double[] cross4 = {cross[0], cross[1], cross[2], 0};
    cross = new Matrix(context.getTransformationMatrix(cameraToWorld)).multiplyVector(cross4);
    result.assignFrom(P3.makeRotationMatrix(null, cross, angle));
    Rn.setToValue(mouseCoordsOld, x, y, z);
    return new ToolEvent(this, context.getEvent().getTimeStamp(), out, da);
  }
  public final void processPseudoTube(DoubleArray from, DoubleArray to) {
    if (lineShader == null) return;
    shader = lineShader.getPolygonShader();
    double w = 1;
    if (from.size() == 4) w = from.getValueAt(3);
    VecMat.transform(
        matrix, from.getValueAt(0), from.getValueAt(1), from.getValueAt(2), w, point0, 0);

    VecMat.transformUnNormalized(matrix, 0, 0, lineWidth, normal0, 0);
    w = 1;
    if (to.size() == 4) w = to.getValueAt(3);
    VecMat.transform(matrix, to.getValueAt(0), to.getValueAt(1), to.getValueAt(2), w, point1, 0);

    double[] mat = matrix;
    double[] tmat = inverseTransposeMatrix;
    matrix = identity;
    inverseTransposeMatrix = identity;

    direction[0] = point1[0] - point0[0];
    direction[1] = point1[1] - point0[1];
    direction[2] = point1[2] - point0[2];

    // TODO: decide: better but slower:
    zzNormal[0] = point1[0] + point0[0];
    zzNormal[1] = point1[1] + point0[1];
    zzNormal[2] = point1[2] + point0[2];
    VecMat.normalize(zzNormal);

    // TODO make only one call to norm...
    if (VecMat.norm(direction) == 0) {
      matrix = mat;
      inverseTransposeMatrix = tmat;

      return;
    }
    VecMat.normalize(direction);
    double length = VecMat.norm(normal0);
    VecMat.cross(direction, zzNormal, normal0);
    VecMat.normalize(normal0);
    VecMat.cross(normal0, direction, normal1);

    normal0[0] *= length;
    normal0[1] *= length;
    // allways zero:
    normal0[2] *= length;

    VecMat.normalize(normal1);

    if (VecMat.dot(normal1, zzNormal) < 0) {
      normal1[0] *= -1;
      normal1[1] *= -1;
      normal1[2] *= -1;
      System.out.println("flip");
    }

    line[0] = point0[0] - normal0[0];
    line[1] = point0[1] - normal0[1];
    line[2] = point0[2];

    line[3] = point0[0];
    line[4] = point0[1];
    line[5] = point0[2] + length;

    line[6] = point1[0];
    line[7] = point1[1];
    line[8] = point1[2] + length;

    line[9] = point1[0] - normal0[0];
    line[10] = point1[1] - normal0[1];
    line[11] = point1[2];

    normal2[0] = +cs / length * normal0[0] + ss * normal1[0];
    normal2[1] = +cs / length * normal0[1] + ss * normal1[1];
    normal2[2] = ss * normal1[2];

    normal2[3] = normal1[0];
    normal2[4] = normal1[1];
    normal2[5] = normal1[2];

    computeArrayNoTransform(line, lineIndices, normal2, nIndices);

    /////

    line[0] = point0[0];
    line[1] = point0[1];
    line[2] = point0[2] + length;

    line[3] = point0[0] + normal0[0];
    line[4] = point0[1] + normal0[1];
    line[5] = point0[2];

    line[6] = point1[0] + normal0[0];
    line[7] = point1[1] + normal0[1];
    line[8] = point1[2];

    line[9] = point1[0];
    line[10] = point1[1];
    line[11] = point1[2] + length;

    normal2[0] = normal1[0];
    normal2[1] = normal1[1];
    normal2[2] = normal1[2];

    normal2[3] = -cs / length * normal0[0] + ss * normal1[0];
    normal2[4] = -cs / length * normal0[1] + ss * normal1[1];
    normal2[5] = ss * normal1[2];

    computeArrayNoTransform(line, lineIndices, normal2, nIndices);

    /*
    test1[0] = point1[0];
    test1[1] = point1[1];
    test1[2] = point1[2];
    test2[0] = point1[0]+normal1[0];
    test2[1] = point1[1]+normal1[1];
    test2[2] = point1[2]+normal1[2];




    test3[0] = point0[0];
    test3[1] = point0[1];
    test3[2] = point0[2];
    test4[0] = point0[0]+normal1[0];
    test4[1] = point0[1]+normal1[1];
    test4[2] = point0[2]+normal1[2];

    processLine(tda1,tda2);
    processLine(tda3,tda4);

    */

    matrix = mat;
    inverseTransposeMatrix = tmat;
  }
  /* (non-Javadoc)
   * @see de.jreality.soft.LineProcessor#processLine(double[], int, int)
   */
  public final void processLine(DoubleArray from, DoubleArray to) {
    if (lineShader == null) return;
    shader = lineShader.getPolygonShader();
    double w = 1;
    if (from.size() == 4) w = from.getValueAt(3);
    VecMat.transform(
        matrix, from.getValueAt(0), from.getValueAt(1), from.getValueAt(2), 1, point0, 0);

    VecMat.transformUnNormalized(matrix, 0, 0, lineWidth, normal0, 0);

    w = 1;
    if (to.size() == 4) w = from.getValueAt(3);
    VecMat.transform(matrix, to.getValueAt(0), to.getValueAt(1), to.getValueAt(2), 1, point1, 0);
    // VecMat.transformUnNormalized(matrix,0,0,.2,normal0,0);

    double[] mat = matrix;
    double[] tmat = inverseTransposeMatrix;
    matrix = identity;
    inverseTransposeMatrix = identity;
    // VecMat.assignIdentity(matrix);

    direction[0] = point1[0] - point0[0];
    direction[1] = point1[1] - point0[1];
    direction[2] = point1[2] - point0[2];
    // TODO make only one call to norm...
    if (VecMat.norm(direction) == 0) {
      matrix = mat;
      inverseTransposeMatrix = tmat;
      return;
    }
    VecMat.normalize(direction);
    double length = VecMat.norm(normal0);
    VecMat.cross(direction, zNormal, normal0);
    VecMat.normalize(normal0);
    normal0[0] *= length;
    normal0[1] *= length;
    normal0[2] *= length;

    VecMat.cross(normal0, direction, normal1);
    VecMat.normalize(normal1);

    line[0] = point0[0] - normal0[0];
    line[1] = point0[1] - normal0[1];
    line[2] = point0[2] + length; // - normal0[2];	

    line[3] = point0[0] + normal0[0];
    line[4] = point0[1] + normal0[1];
    line[5] = point0[2] + length; // + normal0[2];

    line[6] = point1[0] + normal0[0];
    line[7] = point1[1] + normal0[1];
    line[8] = point1[2] + length; // + normal0[2];

    line[9] = point1[0] - normal0[0];
    line[10] = point1[1] - normal0[1];
    line[11] = point1[2] + length; // + normal0[2];

    computeArray(line, lineIndices, normal1, pointNormals);
    matrix = mat;
    inverseTransposeMatrix = tmat;
  }
 public final void processPoint(final DoubleArrayArray data, int index) {
   DoubleArray da = data.item(index).toDoubleArray();
   double w = 1;
   if (da.size() == 4) w = da.getValueAt(3);
   if (vertexColors) {
     DoubleArray color = vertexColor.item(index).toDoubleArray();
     for (int i = 0; i < 16; i++) {
       pointColors[i][0] = color.getValueAt(0);
       pointColors[i][1] = color.getValueAt(1);
       pointColors[i][2] = color.getValueAt(2);
       pointColors[i][3] =
           (vertexColorLength == 4 || (vertexColorLength == -1 && color.getLength() > 3))
               ? color.getValueAt(3)
               : 1.;
     }
     vertexColor = pointColorDataList;
   }
   processPoint(da.getValueAt(0), da.getValueAt(1), da.getValueAt(2), w);
 }
  private final void computeArray(
      final DoubleArrayArray vd,
      final IntArray vertices,
      final DoubleArrayArray nd,
      final IntArray normals,
      DataList texCoords) {
    if (2 * vertices.getLength() + 6 >= (vertexData.length - vertexCount) / Polygon.VERTEX_LENGTH)
      increaseVertexCapacity(vertices.getLength() / 3);

    int vc = vertexCount;
    if (vd.getLengthAt(0) == 3)
      for (int i = 0; i < vertices.getLength(); i++) {
        int vi = vertices.getValueAt(i);
        DoubleArray vertex = vd.item(vi).toDoubleArray();
        VecMat.transform(
            matrix,
            vertex.getValueAt(0),
            vertex.getValueAt(1),
            vertex.getValueAt(2),
            vertexData,
            vc + Polygon.SX);
        vertexData[vc + Polygon.SW] = 1;
        int ni = normals.getValueAt(i);
        DoubleArray normal = nd.item(ni).toDoubleArray();
        VecMat.transformNormal(
            inverseTransposeMatrix,
            normal.getValueAt(0),
            normal.getValueAt(1),
            normal.getValueAt(2),
            vertexData,
            vc + Polygon.NX);
        if (vertexColors) {
          DoubleArray color = vertexColor.item(vi).toDoubleArray();
          vertexData[vc + Polygon.R] = color.getValueAt(0);
          vertexData[vc + Polygon.G] = color.getValueAt(1);
          vertexData[vc + Polygon.B] = color.getValueAt(2);
          vertexData[vc + Polygon.A] =
              (vertexColorLength == 4 || (vertexColorLength == -1 && color.getLength() > 3))
                  ? color.getValueAt(3)
                  : 1.;
        }
        if (useTexCoords && texCoords != null) {
          DoubleArray tc = texCoords.item(vi).toDoubleArray();
          vertexData[vc + Polygon.U] = tc.getValueAt(0);
          vertexData[vc + Polygon.V] = tc.getValueAt(1);
        }
        vc += Polygon.VERTEX_LENGTH;
      }
    else // vertices are 4 tupel
    for (int i = 0; i < vertices.getLength(); i++) {
        int vi = vertices.getValueAt(i);
        DoubleArray vertex = vd.item(vi).toDoubleArray();
        VecMat.transform(
            matrix,
            vertex.getValueAt(0),
            vertex.getValueAt(1),
            vertex.getValueAt(2),
            vertex.getValueAt(3),
            vertexData,
            vc + Polygon.SX);
        if (vertexData[vc + Polygon.SW] != 0) {
          final double d = vertexData[vc + Polygon.SW];
          vertexData[vc + Polygon.SX] /= d;
          vertexData[vc + Polygon.SY] /= d;
          vertexData[vc + Polygon.SZ] /= d;
          vertexData[vc + Polygon.SW] = 1;
        }
        int ni = normals.getValueAt(i);
        DoubleArray normal = nd.item(ni).toDoubleArray();
        VecMat.transformNormal(
            inverseTransposeMatrix,
            normal.getValueAt(0),
            normal.getValueAt(1),
            normal.getValueAt(2),
            // normal.getValueAt(3),
            vertexData,
            vc + Polygon.NX);
        if (vertexColors) {
          DoubleArray color = vertexColor.item(vi).toDoubleArray();
          vertexData[vc + Polygon.R] = color.getValueAt(0);
          vertexData[vc + Polygon.G] = color.getValueAt(1);
          vertexData[vc + Polygon.B] = color.getValueAt(2);
          vertexData[vc + Polygon.A] =
              (vertexColorLength == 4 || (vertexColorLength == -1 && color.getLength() > 3))
                  ? color.getValueAt(3)
                  : 1.;
        }
        if (useTexCoords && texCoords != null) {
          DoubleArray tc = texCoords.item(vi).toDoubleArray();
          vertexData[vc + Polygon.U] = tc.getValueAt(0);
          vertexData[vc + Polygon.V] = tc.getValueAt(1);
        }
        vc += Polygon.VERTEX_LENGTH;
      }
    compute(vertices.getLength());
  }