Java 类javax.vecmath.Point3i 实例源码

public void fillEllipsoid(Point3f center, Point3f[] points, int x, int y,
                            int z, int diameter, Matrix3f mToEllipsoidal,
                            double[] coef, Matrix4f mDeriv,
                            int selectedOctant, Point3i[] octantPoints) {
  switch (diameter) {
  case 1:
    plotPixelClipped(argbCurrent, x, y, z);
    return;
  case 0:
    return;
  }
  if (diameter <= (antialiasThisFrame ? Sphere3D.maxSphereDiameter2
      : Sphere3D.maxSphereDiameter))
    sphere3d.render(shadesCurrent, !addAllPixels, diameter, x, y, z,
        mToEllipsoidal, coef, mDeriv, selectedOctant, octantPoints);
}

public void drawTriangle(Point3i screenA, Point3i screenB, Point3i screenC,
                         int check) {
  // primary method for unmapped monochromatic Mesh
  if ((check & 1) == 1)
    line3d.plotLine(argbCurrent, !addAllPixels, argbCurrent, !addAllPixels,
        screenA.x, screenA.y, screenA.z, screenB.x, screenB.y, screenB.z,
        true);
  if ((check & 2) == 2)
    line3d.plotLine(argbCurrent, !addAllPixels, argbCurrent, !addAllPixels,
        screenB.x, screenB.y, screenB.z, screenC.x, screenC.y, screenC.z,
        true);
  if ((check & 4) == 4)
    line3d.plotLine(argbCurrent, !addAllPixels, argbCurrent, !addAllPixels,
        screenA.x, screenA.y, screenA.z, screenC.x, screenC.y, screenC.z,
        true);
}

public void fillTriangle(Point3i screenA, short colixA,
                                 short normixA, Point3i screenB,
                                 short colixB, short normixB,
                                 Point3i screenC, short colixC,
                                 short normixC, float factor) {
  // isosurface test showing triangles
  boolean useGouraud;
  if (!isPass2 && normixA == normixB && normixA == normixC && colixA == colixB
      && colixA == colixC) {
    setTriangleColixAndShadeIndex(colixA, normix3d.getShadeIndex(normixA));
    useGouraud = false;
  } else {
    if (!setTriangleTranslucency(colixA, colixB, colixC))
      return;
    triangle3d.setGouraud(getShades(colixA)[normix3d.getShadeIndex(normixA)],
        getShades(colixB)[normix3d.getShadeIndex(normixB)],
        getShades(colixC)[normix3d.getShadeIndex(normixC)]);
    useGouraud = true;
  }
  triangle3d.fillTriangle(screenA, screenB, screenC, factor,
      useGouraud);
}

public void fillTriangle(Point3i screenA, short colixA, short normixA,
                         Point3i screenB, short colixB, short normixB,
                         Point3i screenC, short colixC, short normixC) {
  // mesh, isosurface
  boolean useGouraud;
  if (!isPass2 && normixA == normixB && normixA == normixC &&
      colixA == colixB && colixA == colixC) {
    setTriangleColixAndShadeIndex(colixA, normix3d.getShadeIndex(normixA));
    useGouraud = false;
  } else {
    if (!setTriangleTranslucency(colixA, colixB, colixC))
      return;
    triangle3d.setGouraud(getShades(colixA)[normix3d.getShadeIndex(normixA)],
                          getShades(colixB)[normix3d.getShadeIndex(normixB)],
                          getShades(colixC)[normix3d.getShadeIndex(normixC)]);
    useGouraud = true;
  }
  triangle3d.fillTriangle(screenA, screenB, screenC, useGouraud);
}

/**
 *  used by CartoonRenderer (DNA surface) and GeoSurfaceRenderer (face) to
 *  assign a noisy shade to the surface it will render
 * @param screenA 
 * @param screenB 
 * @param screenC 
 */
public void setNoisySurfaceShade(Point3i screenA, Point3i screenB, Point3i screenC) {
  vectorAB.set(screenB.x - screenA.x, screenB.y - screenA.y, screenB.z
      - screenA.z);
  int shadeIndex;
  if (screenC == null) {
    shadeIndex = Shade3D.getShadeIndex(-vectorAB.x, -vectorAB.y, vectorAB.z);
  } else {
    vectorAC.set(screenC.x - screenA.x, screenC.y - screenA.y, screenC.z
        - screenA.z);
    vectorAB.cross(vectorAB, vectorAC);
    shadeIndex = vectorAB.z >= 0 ? Shade3D.getShadeIndex(-vectorAB.x,
        -vectorAB.y, vectorAB.z) : Shade3D.getShadeIndex(vectorAB.x,
        vectorAB.y, -vectorAB.z);
  }
  if (shadeIndex > Shade3D.shadeIndexNoisyLimit)
    shadeIndex = Shade3D.shadeIndexNoisyLimit;
  setColorNoisy(shadeIndex);
}

void fillTriangle(Point3i screenA, Point3i screenB, Point3i screenC,
                  float factor, boolean useGouraud) {
  ax[0] = screenA.x;
  ax[1] = screenB.x;
  ax[2] = screenC.x;
  ay[0] = screenA.y;
  ay[1] = screenB.y;
  ay[2] = screenC.y;
  az[0] = screenA.z;
  az[1] = screenB.z;
  az[2] = screenC.z;
  adjustVertex(ax, factor);
  adjustVertex(ay, factor);
  adjustVertex(az, factor);
  fillTriangle(useGouraud);
}

private String extractVectorInfo(String name) {
  // (nx ny nz)  where n is 1/12 of the edge. 
  // also allows for (nz), though that is not standard
  vector12ths = new Point3i();
  vectorCode = "";
  int i = name.indexOf("(");
  int j = name.indexOf(")", i);
  if (i > 0 && j > i) {
    String term = name.substring(i + 1, j);
    vectorCode = " (" + term + ")";
    name = name.substring(0, i).trim();
    i = term.indexOf(" ");
    if (i >= 0) {
      vector12ths.x = Integer.parseInt(term.substring(0, i));
      term = term.substring(i + 1).trim();
      i = term.indexOf(" ");
      if (i >= 0) {
        vector12ths.y = Integer.parseInt(term.substring(0, i));
        term = term.substring(i + 1).trim();
      }
    }
    vector12ths.z = Integer.parseInt(term);
  }
  return name;
}

void setMinMaxLatticeParameters(Point3i minXYZ, Point3i maxXYZ) {
  if (maxXYZ.x <= 555 && maxXYZ.y >= 555) {
    //alternative format for indicating a range of cells:
    //{111 666}
    //555 --> {0 0 0}
    minXYZ.x = (maxXYZ.x / 100) - 5;
    minXYZ.y = (maxXYZ.x % 100) / 10 - 5;
    minXYZ.z = (maxXYZ.x % 10) - 5;
    //555 --> {1 1 1}
    maxXYZ.x = (maxXYZ.y / 100) - 4;
    maxXYZ.z = (maxXYZ.y % 10) - 4;
    maxXYZ.y = (maxXYZ.y % 100) / 10 - 4;
  }
  switch (dimension) {
  case 1: // polymer
    minXYZ.y = 0;
    maxXYZ.y = 1;
    // fall through
  case 2: // slab
    minXYZ.z = 0;
    maxXYZ.z = 1;
  }
}

protected void renderLine(Point3f p0, Point3f p1, int diameter,
                          Point3i pt0, Point3i pt1, boolean drawTicks) {
  // used by Bbcage, Uccage, and axes
  pt0.set((int) p0.x, (int) p0.y, (int) p0.z);
  pt1.set((int) p1.x, (int) p1.y, (int) p1.z);
  if (diameter < 0)
    g3d.drawDottedLine(pt0, pt1);
  else
    g3d.fillCylinder(endcap, diameter, pt0, pt1);
  if (!drawTicks || tickInfo == null)
    return;
  // AtomA and AtomB molecular coordinates must be set previously
  atomA.screenX = pt0.x;
  atomA.screenY = pt0.y;
  atomA.screenZ = pt0.z;
  atomB.screenX = pt1.x;
  atomB.screenY = pt1.y;
  atomB.screenZ = pt1.z;
  drawTicks(atomA, atomB, diameter, true);
}

private Point3i transformScreenPoint(Point3f ptXyp) {
  // just does the processing for [x y] and [x y %]
  if (ptXyp.z == -Float.MAX_VALUE) {
    point3iScreenTemp.x = (int) (ptXyp.x / 100 * screenWidth);
    point3iScreenTemp.y = (int) ((1 - ptXyp.y / 100) * screenHeight);
  } else {
    point3iScreenTemp.x = (int) ptXyp.x;
    point3iScreenTemp.y = (screenHeight - (int) ptXyp.y);
  }
  if (antialias) {
    point3iScreenTemp.x <<= 1;
    point3iScreenTemp.y <<= 1;
  }
  matrixTransform.transform(fixedRotationCenter, pointTsp);
  point3iScreenTemp.z = (int) pointTsp.z;
  return point3iScreenTemp;
}

@SideOnly(Side.CLIENT)
public void tessellate(VertexBuffer vb){
    vb.begin(GL11.GL_TRIANGLES, DefaultVertexFormats.POSITION_TEX_NORMAL);
    for (Triple<Point3i, Point3i, Point3i> face : faces) {
        vb.pos(vertices.get(face.getLeft().x).x, vertices.get(face.getLeft().x).y, vertices.get(face.getLeft().x).z)
                .tex(uvs.get(face.getLeft().y).x, uvs.get(face.getLeft().y).y)
                .normal(normals.get(face.getLeft().z).x, normals.get(face.getLeft().z).y, normals.get(face.getLeft().z).z).endVertex();
        vb.pos(vertices.get(face.getMiddle().x).x, vertices.get(face.getMiddle().x).y, vertices.get(face.getMiddle().x).z)
                .tex(uvs.get(face.getMiddle().y).x, uvs.get(face.getMiddle().y).y)
                .normal(normals.get(face.getMiddle().z).x, normals.get(face.getMiddle().z).y, normals.get(face.getMiddle().z).z).endVertex();
        vb.pos(vertices.get(face.getRight().x).x, vertices.get(face.getRight().x).y, vertices.get(face.getRight().x).z)
                .tex(uvs.get(face.getRight().y).x, uvs.get(face.getRight().y).y)
                .normal(normals.get(face.getRight().z).x, normals.get(face.getRight().z).y, normals.get(face.getRight().z).z).endVertex();
    }
}

@Override
protected void render() {
  Polyhedra polyhedra = (Polyhedra) shape;
  Polyhedra.Polyhedron[] polyhedrons = polyhedra.polyhedrons;
  drawEdges = polyhedra.drawEdges;
  short[] colixes = polyhedra.colixes;
  Point3i[] screens = null;
  for (int i = polyhedra.polyhedronCount; --i >= 0;) {
    int iAtom = polyhedrons[i].centralAtom.getIndex();
    short colix = (colixes == null || iAtom >= colixes.length ? 
        Graphics3D.INHERIT_ALL : polyhedra.colixes[iAtom]);
    screens = render1(polyhedrons[i], colix, screens);
  }
}

private Point3i[] render1(Polyhedra.Polyhedron p, short colix, Point3i[] screens) {
  if (p.visibilityFlags == 0)
    return screens;
  colix = Graphics3D.getColixInherited(colix, p.centralAtom.getColix());
  Point3f[] vertices = p.vertices;
  byte[] planes;
  if (screens == null || screens.length < vertices.length) {
    screens = new Point3i[vertices.length];
    for (int i = vertices.length; --i >= 0;)
      screens[i] = new Point3i();
  }
  planes = p.planes;
  for (int i = vertices.length; --i >= 0;) {
    Atom atom = (vertices[i] instanceof Atom ? (Atom) vertices[i] : null);
    if (atom == null)
      viewer.transformPoint(vertices[i], screens[i]);
    else
      screens[i].set(atom.screenX, atom.screenY, atom.screenZ);
  }

  isAll = (drawEdges == Polyhedra.EDGES_ALL);
  frontOnly = (drawEdges == Polyhedra.EDGES_FRONT);

  // no edges to new points when not collapsed
  if (g3d.setColix(colix))
    for (int i = 0, j = 0; j < planes.length;)
      fillFace(p.normixes[i++], screens[planes[j++]], screens[planes[j++]],
          screens[planes[j++]]);
  if (g3d.setColix(Graphics3D.getColixTranslucent(colix, false, 0)))
  for (int i = 0, j = 0; j < planes.length;)
    drawFace(p.normixes[i++], screens[planes[j++]],
        screens[planes[j++]], screens[planes[j++]]);
  return screens;
}

public void drawTriangle(Point3i screenA, short colixA, Point3i screenB,
                         short colixB, Point3i screenC, short colixC,
                         int check) {
  // primary method for mapped Mesh
  if ((check & 1) == 1)
    drawLine(colixA, colixB, screenA.x, screenA.y, screenA.z, screenB.x,
        screenB.y, screenB.z);
  if ((check & 2) == 2)
    drawLine(colixB, colixC, screenB.x, screenB.y, screenB.z, screenC.x,
        screenC.y, screenC.z);
  if ((check & 4) == 4)
    drawLine(colixA, colixC, screenA.x, screenA.y, screenA.z, screenC.x,
        screenC.y, screenC.z);
}

public void fillTriangle(Point3i pointA, short colixA, short normixA,
                         Point3i pointB, short colixB, short normixB,
                         Point3i pointC, short colixC, short normixC) {
  // mesh, isosurface
  if (colixA != colixB || colixB != colixC) {
    // shouldn't be here, because that uses renderIsosurface
    return;
  }
  ptA.set(pointA.x, pointA.y, pointA.z);
  ptB.set(pointB.x, pointB.y, pointB.z);
  ptC.set(pointC.x, pointC.y, pointC.z);
  exporter.fillTriangle(colixA, ptA, ptB, ptC, false);
}

public void fillCylinder(byte endcaps, int diameter,
                         Point3i screenA, Point3i screenB) {
  //axes, bbcage, uccage, cartoon, dipoles, mesh
  cylinder3d.render(colixCurrent, colixCurrent, !addAllPixels, !addAllPixels, endcaps, diameter,
                    screenA.x, screenA.y, screenA.z,
                    screenB.x, screenB.y, screenB.z);
}

public void drawQuadrilateral(short colix, Point3i pointA, Point3i pointB,
                              Point3i pointC, Point3i screenD) {
  // mesh only -- translucency has been checked
  setColix(colix);
  drawLine(pointA, pointB);
  drawLine(pointB, pointC);
  drawLine(pointC, screenD);
  drawLine(screenD, pointA);
}

public void fillTriangle(Point3i pointA, short colixA, short normixA,
                         Point3i pointB, short colixB, short normixB,
                         Point3i pointC, short colixC, short normixC,
                         float factor) {
  fillTriangle(pointA, colixA, normixA, pointB, colixB, normixB, pointC,
      colixC, normixC);
}

public void drawTriangle(Point3i screenA, short colixA, Point3i screenB,
                         short colixB, Point3i screenC, short colixC,
                         int check) {
  // primary method for mapped Mesh
  if ((check & 1) == 1)
    drawLine(colixA, colixB, screenA.x, screenA.y, screenA.z, screenB.x,
        screenB.y, screenB.z);
  if ((check & 2) == 2)
    drawLine(colixB, colixC, screenB.x, screenB.y, screenB.z, screenC.x,
        screenC.y, screenC.z);
  if ((check & 4) == 4)
    drawLine(colixA, colixC, screenA.x, screenA.y, screenA.z, screenC.x,
        screenC.y, screenC.z);
}

public void drawQuadrilateral(short colix, Point3i screenA, Point3i screenB,
                              Point3i screenC, Point3i screenD) {
  //mesh only -- translucency has been checked
  setColix(colix);
  drawLine(screenA, screenB);
  drawLine(screenB, screenC);
  drawLine(screenC, screenD);
  drawLine(screenD, screenA);
}

public void fillQuadrilateral(Point3i screenA, short colixA, short normixA,
                              Point3i screenB, short colixB, short normixB,
                              Point3i screenC, short colixC, short normixC,
                              Point3i screenD, short colixD, short normixD) {
  // mesh
  fillTriangle(screenA, colixA, normixA,
               screenB, colixB, normixB,
               screenC, colixC, normixC);
  fillTriangle(screenA, colixA, normixA,
               screenC, colixC, normixC,
               screenD, colixD, normixD);
}

void fillTriangle(Point3i screenA, Point3i screenB, Point3i screenC,
                  boolean useGouraud) {
  //t = Thread.currentThread();
  ax[0] = screenA.x;
  ax[1] = screenB.x;
  ax[2] = screenC.x;
  ay[0] = screenA.y;
  ay[1] = screenB.y;
  ay[2] = screenC.y;
  az[0] = screenA.z;
  az[1] = screenB.z;
  az[2] = screenC.z;
  fillTriangle(useGouraud);
}

public void drawHermite(boolean fill, boolean border, int tension,
                        Point3i s0, Point3i s1, Point3i s2, Point3i s3,
                        Point3i s4, Point3i s5, Point3i s6, Point3i s7,
                        int aspectRatio) {
  hermite3d.renderHermiteRibbon(fill, border, tension, s0, s1, s2, s3, s4,
      s5, s6, s7, aspectRatio);
}

public void fillEllipsoid(Point3f center, Point3f[] points, int x, int y,
                          int z, int diameter, Matrix3f mToEllipsoidal,
                          double[] coef, Matrix4f mDeriv, int selectedOctant,
                          Point3i[] octantPoints) {
  exporter.fillEllipsoid(center, points, colix, x, y, z, diameter,
      mToEllipsoidal, coef, mDeriv, octantPoints);
}

public int getSurfacePointIndexAndFraction(float cutoff, boolean isCutoffAbsolute,
                                int x, int y, int z, Point3i offset, int vA,
                                int vB, float valueA, float valueB,
                                Point3f pointA, Vector3f edgeVector,
                                boolean isContourType, float[] fReturn) {
  float thisValue = getSurfacePointAndFraction(cutoff, isCutoffAbsolute, valueA,
      valueB, pointA, edgeVector, x, y, z, vA, vB, fReturn, ptTemp);
  /* 
   * from MarchingCubes
   * 
   * In the case of a setup for a Marching Squares calculation,
   * we are collecting just the desired type of intersection for the 2D marching
   * square contouring -- x, y, or z. In the case of a contoured f(x,y) surface, 
   * we take every point.
   * 
   */

  if (marchingSquares != null && params.isContoured)
    return marchingSquares.addContourVertex(x, y, z, offset,
        ptTemp, cutoff);
  int assocVertex = (assocCutoff > 0 ? (fReturn[0] < assocCutoff ? vA
      : fReturn[0] > 1 - assocCutoff ? vB : MarchingSquares.CONTOUR_POINT)
      : MarchingSquares.CONTOUR_POINT);
  if (assocVertex >= 0)
    assocVertex = marchingCubes.getLinearOffset(x, y, z, assocVertex);
  int n = addVertexCopy(ptTemp, thisValue, assocVertex);
  if (n >= 0 && params.iAddGridPoints) {
    marchingCubes.calcVertexPoint(x, y, z, vB, ptTemp);
    addVertexCopy(valueA < valueB ? pointA : ptTemp, Float.NaN,
        MarchingSquares.EDGE_POINT);
    addVertexCopy(valueA < valueB ? ptTemp : pointA, Float.NaN,
        MarchingSquares.EDGE_POINT);
  }
  return n;
}

private void setGridLimitsForAtom(Point3f ptA, float rA, Point3i pt0,
                                  Point3i pt1) {
  rA += volumeData.maxGrid * 1.8f; // to span corner-to-corner possibility
  volumeData.xyzToVoxelPt(ptA.x - rA, ptA.y - rA, ptA.z - rA, pt0);
  pt0.x = Math.max(pt0.x - 1, 0);
  pt0.y = Math.max(pt0.y - 1, 0);
  pt0.z = Math.max(pt0.z - 1, 0);
  volumeData.xyzToVoxelPt(ptA.x + rA, ptA.y + rA, ptA.z + rA, pt1);
  pt1.x = Math.min(pt1.x + 1, nPointsX);
  pt1.y = Math.min(pt1.y + 1, nPointsY);
  pt1.z = Math.min(pt1.z + 1, nPointsZ);
}

private static void mergeLimits(Point3i ptA, Point3i ptB, Point3i pt0,
                                Point3i pt1) {
  if (pt0 != null) {
    pt0.x = Math.min(ptA.x, ptB.x);
    pt0.y = Math.min(ptA.y, ptB.y);
    pt0.z = Math.min(ptA.z, ptB.z);
  }
  if (pt1 != null) {
    pt1.x = Math.max(ptA.x, ptB.x);
    pt1.y = Math.max(ptA.y, ptB.y);
    pt1.z = Math.max(ptA.z, ptB.z);
  }
}

public int addContourVertex(int x, int y, int z, Point3i offsets,
                            Point3f vertexXYZ, float value) {
  if (contourVertexCount == contourVertexes.length)
    contourVertexes = (ContourVertex[]) ArrayUtil
        .doubleLength(contourVertexes);
  if (offsets != null) {
    x += offsets.x;
    y += offsets.y;
    z += offsets.z;
  }
  int vPt = surfaceReader.addVertexCopy(vertexXYZ, value, VERTEX_POINT);
  contourVertexes[contourVertexCount++] = new ContourVertex(vertexXYZ);
  return vPt;
}

private Translation(char translationCode, 
    Point3i vectorShift12ths) {
  this.translationCode = translationCode;
  this.rotationOrder = 0;
  this.rotationShift12ths = 0;
  this.vectorShift12ths = vectorShift12ths;        
}

private Translation(char translationCode, int order, 
    int rotationShift12ths) {
  this.translationCode = translationCode;
  this.rotationOrder = order;
  this.rotationShift12ths = rotationShift12ths;
  this.vectorShift12ths = new Point3i();        
}

public void drawTriangle(Point3i screenA, Point3i screenB, Point3i screenC,
                         int check) {
  // primary method for mapped Mesh
  if ((check & 1) == 1)
    drawLine(colix, colix, screenA.x, screenA.y, screenA.z, screenB.x,
        screenB.y, screenB.z);
  if ((check & 2) == 2)
    drawLine(colix, colix, screenB.x, screenB.y, screenB.z, screenC.x,
        screenC.y, screenC.z);
  if ((check & 4) == 4)
    drawLine(colix, colix, screenA.x, screenA.y, screenA.z, screenC.x,
        screenC.y, screenC.z);
}

/**
 * calculate screen points based on control points and wing positions
 * (cartoon, strand, meshRibbon, and ribbon)
 * 
 * @param offsetFraction
 * @return Point3i array THAT MUST BE LATER FREED
 */
protected Point3i[] calcScreens(float offsetFraction) {
  int count = controlPoints.length;
  Point3i[] screens = viewer.allocTempScreens(count);
  if (offsetFraction == 0) {
    for (int i = count; --i >= 0;)
      viewer.transformPoint(controlPoints[i], screens[i]);
  } else {
    float offset_1000 = offsetFraction / 1000f;
    for (int i = count; --i >= 0;)
      calc1Screen(controlPoints[i], wingVectors[i], (mads[i] == 0 && i > 0 ? mads[i-1] : mads[i]), offset_1000,
          screens[i]);
  }
  return screens;
}

private void calc1Screen(Point3f center, Vector3f vector, short mad,
                         float offset_1000, Point3i screen) {
  pointT.set(vector);
  float scale = mad * offset_1000;
  pointT.scaleAdd(scale, center);
  viewer.transformPoint(pointT, screen);
}

protected void renderHermiteCylinder(Point3i[] screens, int i) {
  //strands
  colix = getLeadColix(i);
  if (!g3d.setColix(colix))
    return;
  setNeighbors(i);
  g3d.drawHermite(isNucleic ? 4 : 7, screens[iPrev],
      screens[i], screens[iNext], screens[iNext2]);
}

public void fillTriangle(Point3i pointA, Point3i pointB, Point3i pointC) {
  // cartoon only, for nucleic acid bases

  ptA.set(pointA.x, pointA.y, pointA.z);
  ptB.set(pointB.x, pointB.y, pointB.z);
  ptC.set(pointC.x, pointC.y, pointC.z);
  exporter.fillTriangle(colix, ptA, ptB, ptC, true);
}

public int getSurfacePointIndexAndFraction(float cutoff, boolean isCutoffAbsolute,
                                int x, int y, int z, Point3i offset, int vA,
                                int vB, float valueA, float valueB,
                                Point3f pointA, Vector3f edgeVector,
                                boolean isContourType, float[] fReturn) {
  return 0;
}

public boolean render1(Mesh mesh) { // used by mps renderer
  this.mesh = mesh;
  if (!setVariables())
    return false;
  if (!g3d.setColix(colix) && !mesh.showContourLines)
    return mesh.title != null;
  latticeOffset.set(0, 0, 0);
  for (int i = vertexCount; --i >= 0;)
    if (vertices[i] != null)
      viewer.transformPoint(vertices[i], screens[i]);
  if (mesh.lattice == null || mesh.modelIndex < 0) {
    render2(exportType != Graphics3D.EXPORT_NOT);
  } else {
    SymmetryInterface unitcell = viewer.getModelUnitCell(mesh.modelIndex);
    if (unitcell != null) {
      Point3f vTemp = new Point3f();
      Point3i minXYZ = new Point3i();
      Point3i maxXYZ = new Point3i((int) mesh.lattice.x,
          (int) mesh.lattice.y, (int) mesh.lattice.z);
      unitcell.setMinMaxLatticeParameters(minXYZ, maxXYZ);
      for (int tx = minXYZ.x; tx < maxXYZ.x; tx++)
        for (int ty = minXYZ.y; ty < maxXYZ.y; ty++)
          for (int tz = minXYZ.z; tz < maxXYZ.z; tz++) {
            latticeOffset.set(tx, ty, tz);
            unitcell.toCartesian(latticeOffset, false);
            for (int i = vertexCount; --i >= 0;) {
              vTemp.set(vertices[i]);
              vTemp.add(latticeOffset);
              viewer.transformPoint(vTemp, screens[i]);
            }
            render2(exportType != Graphics3D.EXPORT_NOT);
          }
    }
  }

  if (screens != null)
    viewer.freeTempScreens(screens);
  return true;
}

protected void drawLine(int iA, int iB, boolean fill, 
                        Point3f vA, Point3f vB, 
                        Point3i sA, Point3i sB) {
  byte endCap = (iA != iB  && !fill ? Graphics3D.ENDCAPS_NONE 
      : width < 0 || width == -0.0 || iA != iB && isTranslucent ? Graphics3D.ENDCAPS_FLAT
      : Graphics3D.ENDCAPS_SPHERICAL);
  if (width == 0) {
    if (diameter == 0)
      diameter = (mesh.diameter > 0 ? mesh.diameter : iA == iB ? 7 : 3);
    if (exportType == Graphics3D.EXPORT_CARTESIAN) {
      pt1f.set(vA);
      pt1f.add(vB);
      pt1f.scale(1f / 2f);
      viewer.transformPoint(pt1f, pt1i);
      diameter = (int) (viewer.unscaleToScreen(pt1i.z, diameter) * 1000);
    }
    if (iA == iB) {
      g3d.fillSphere(diameter, sA);
    } else {
      g3d.fillCylinder(endCap, diameter, sA, sB);
    }
  } else {
    pt1f.set(vA);
    pt1f.add(vB);
    pt1f.scale(1f / 2f);
    viewer.transformPoint(pt1f, pt1i);
    int mad = (int) (Math.abs(width) * 1000); 
    diameter = (exportType == Graphics3D.EXPORT_CARTESIAN ? mad 
        : viewer.scaleToScreen(pt1i.z, mad));
    if (diameter == 0)
      diameter = 1;
    viewer.transformPoint(vA, pt1f);
    viewer.transformPoint(vB, pt2f);
    g3d.fillCylinderBits(endCap, diameter, pt1f, pt2f);
  }
}

@Override
protected void render() {
  slabbing = viewer.getSlabEnabled();
  slabByAtom = viewer.getSlabByAtom();          
  endcaps = Graphics3D.ENDCAPS_SPHERICAL;
  multipleBondSpacing = viewer.getMultipleBondSpacing();
  multipleBondRadiusFactor = viewer.getMultipleBondRadiusFactor();
  if (multipleBondSpacing > 0) {
    z = new Vector3f();
    x = new Vector3f();
    y = new Vector3f();
    p1 = new Point3f();
    p2 = new Point3f();
    s1 = new Point3i();
    s2 = new Point3i();
  }
  showMultipleBonds = multipleBondSpacing != 0 && viewer.getShowMultipleBonds();
  modeMultipleBond = viewer.getModeMultipleBond();
  renderWireframe = viewer.getInMotion() && viewer.getWireframeRotation();
  ssbondsBackbone = viewer.getSsbondsBackbone();
  hbondsBackbone = viewer.getHbondsBackbone();
  bondsBackbone = hbondsBackbone | ssbondsBackbone;
  hbondsSolid = viewer.getHbondsSolid();
  isAntialiased = g3d.isAntialiased();
  Bond[] bonds = modelSet.getBonds();
  for (int i = modelSet.getBondCount(); --i >= 0; ) {
    bond = bonds[i];
    if ((bond.getShapeVisibilityFlags() & myVisibilityFlag) != 0) 
      renderBond();
  }
}

public void hoverOn(int x, int y, String text) {
  if (!isHoverEnabled())
    return;
  // from draw for drawhover on
  if (eval != null && isScriptExecuting())
    return;
  loadShape(JmolConstants.SHAPE_HOVER);
  setShapeProperty(JmolConstants.SHAPE_HOVER, "xy", new Point3i(x, y, 0));
  setShapeProperty(JmolConstants.SHAPE_HOVER, "target", null);
  setShapeProperty(JmolConstants.SHAPE_HOVER, "specialLabel", null);
  setShapeProperty(JmolConstants.SHAPE_HOVER, "text", text);
  hoverAtomIndex = -1;
  hoverText = text;
  refresh(3, "hover on point");
}