Java Code Examples for processing.core.PShape#noStroke()

public static PShape createStrip(float width, float height, int detail) {
	P.p.textureMode(P.NORMAL); 
	PShape sh = P.p.createShape();
	sh.beginShape(P.QUAD_STRIP);
	sh.noStroke();
	float xStart = -width / 2f;
	float yStart = -height / 2f;
	float xSegment = width / (float) detail;
	for (int i = 0; i <= detail; i++) {
		float x = xStart + i * xSegment;
		float u = (float)i / (float)detail; // x progress
		sh.vertex(x, yStart, 		  0, u, 0);
		sh.vertex(x, yStart + height, 0, u, 1);
	}
	sh.endShape();
	P.p.textureMode(P.IMAGE); 	// reset 
	return sh;
}
 

public static PShape createIcosahedron(PGraphics pg, int level, PImage img) {
	// the icosahedron is created with positions, normals and texture coordinates in the above class
	Icosahedron ico = new Icosahedron(level);
	pg.textureMode(P.NORMAL); // set textureMode to normalized (range 0 to 1);
	PShape mesh = pg.createShape(); // create the initial PShape
	mesh.beginShape(P.TRIANGLES); // define the PShape type: TRIANGLES
	mesh.noStroke();
	if(img != null) mesh.texture(img);

	// put all the vertices, uv texture coordinates and normals into the PShape
	for (int i=0; i<ico.positions.size(); i++) {
		PVector pos = ico.positions.get(i);
		PVector t = ico.texCoords.get(i);
		PVector n = ico.normals.get(i);
		mesh.normal(n.x, n.y, n.z);
		mesh.vertex(pos.x, pos.y, pos.z, t.x, t.y);
	}
	mesh.endShape();
	return mesh;
}
 

public static PShape createCan(float radius, float height, int detail) {
	P.p.textureMode(P.NORMAL); 
	PShape sh = P.p.createShape();
	sh.beginShape(P.QUAD_STRIP);
	sh.noStroke();
	for (int i = 0; i <= detail; i++) {
		float angle = P.TWO_PI / detail;
		float x = P.sin(i * angle);
		float z = P.cos(i * angle);
		float u = (float)i / detail;
		sh.normal(x, 0, z);
		sh.vertex(x * radius, -height/2, z * radius, u, 0);
		sh.vertex(x * radius, +height/2, z * radius, u, 1);
	}
	sh.endShape();
	P.p.textureMode(P.IMAGE); 	// reset 
	return sh;
}
 

public void addFillToShape(PShape shape, float oscMult) {
	for (int i = 0; i < shape.getVertexCount(); i++) {
		PVector vertex = shape.getVertex(i);
		float zFade = P.map(vertex.z, 50, -50, 1, 0);
		int fillReplace = P.p.color(
			(127 + 127f * P.sin(vertex.x * oscMult)) * zFade,
			(127 + 127f * P.sin(vertex.y * oscMult)) * zFade,
			(127 + 127f * P.sin(vertex.z * oscMult)) * zFade
		);
		shape.setFill(i, fillReplace);
		shape.noStroke();
	}
	for (int j = 0; j < shape.getChildCount(); j++) {
		addFillToShape(shape.getChild(j), oscMult);
	}
}
 

public PShape drawCurlyStrip(float radius, float height, int detail, float rotations, float thickness) {
		P.p.textureMode(P.NORMAL); 
		PShape sh = P.p.createShape();
		sh.beginShape(P.QUAD_STRIP);
		sh.noStroke();
		for (int i = 0; i <= detail; i++) {
			float progress = (float) i / (float) detail;
			float angle = P.TWO_PI / detail * rotations;
			float x = P.sin(i * angle);
			float z = P.cos(i * angle);
			float y = height * 0.5f - progress * height;
			float u = (float)i / detail;
//			sh.normal(x, 0, z);
			sh.vertex(x * radius, y - thickness/2, z * radius, u, 0);
			sh.vertex(x * radius, y + thickness/2, z * radius, u, 1);
		}
		sh.endShape();
		P.p.textureMode(P.IMAGE); 	// reset 
		return sh;
	}
 

PShape createIcosahedron(int level, String imagePath) {
	// the icosahedron is created with positions, normals and texture coordinates in the above class
	Icosahedron ico = new Icosahedron(level);

	textureMode(NORMAL); // set textureMode to normalized (range 0 to 1);
	PImage tex = loadImage(imagePath); // load the texture

	PShape mesh = createShape(); // create the initial PShape
	mesh.beginShape(TRIANGLES); // define the PShape type: TRIANGLES
	mesh.noStroke();
	mesh.texture(tex); // set the texture
	// put all the vertices, uv texture coordinates and normals into the PShape
	for (int i=0; i<ico.positions.size(); i++) {
		PVector p = ico.positions.get(i);
		PVector t = ico.texCoords.get(i);
		PVector n = ico.normals.get(i);
		mesh.normal(n.x, n.y, n.z);
		mesh.vertex(p.x, p.y, p.z, t.x, t.y);
	}
	mesh.endShape();

	return mesh; // our work is done here, return DA MESH! ;-)
}
 

PShape createCylinder(float r, float h, int detail, PImage tex) {
	textureMode(NORMAL);
	PShape sh = createShape();
	sh.beginShape(QUAD_STRIP);
	sh.noStroke();
	sh.texture(tex);
	for (int i = 0; i <= detail; i++) {
		float angle = TWO_PI / detail;
		float x = sin(i * angle);
		float z = cos(i * angle);
		float u = (float)i / detail;
		sh.normal(x, 0, z);
		sh.vertex(x * r, -h/2, z * r, u, 0);
		sh.vertex(x * r, +h/2, z * r, u, 1);    
	}
	sh.endShape(); 
	return sh;
}
 

PShape createSheet(int detail, PImage tex) {
	p.textureMode(NORMAL);
	PShape sh = p.createShape();
	sh.beginShape(QUADS);
	sh.noStroke();
	sh.noFill();
	sh.texture(tex);
	float cellW = tex.width / detail;
	float cellH = tex.height / detail;
	int numVertices = 0;
	for (int col = 0; col < tex.width; col += cellW) {
		for (int row = 0; row < tex.height; row += cellH) {
			float xU = col;
			float yV = row;
			float x = -tex.width/2f + xU;
			float y = -tex.height/2f + yV;
			float z = 0;
			sh.normal(x, y, z);
			sh.vertex(x, y, z, 					P.map(xU, 0, tex.width, 0, 1f), P.map(yV, 0, tex.height, 0, 1f));
			sh.vertex(x, y + cellH, z, 			P.map(xU, 0, tex.width, 0, 1f), P.map(yV + cellH, 0, tex.height, 0, 1f));    
			sh.vertex(x + cellW, y + cellH, z,	P.map(xU + cellW, 0, tex.width, 0, 1f), P.map(yV + cellH, 0, tex.height, 0, 1f));    
			sh.vertex(x + cellW, y, z, 			P.map(xU + cellW, 0, tex.width, 0, 1f), P.map(yV, 0, tex.height, 0, 1f));
			numVertices++;
		}
	}
	P.println(numVertices, "vertices");
	sh.endShape(); 
	return sh;
}
 

public static PShape createSheet(int detail, PImage tex) {
	P.p.textureMode(P.NORMAL); 
	// P.println("Shapes.createSheet() setting textureMode is weird to do here... Maybe should be PAppletHax default?");
	PShape sh = P.p.createShape();
	sh.beginShape(P.QUADS);
	sh.noStroke();
	sh.texture(tex);
	float cellW = tex.width / detail;
	float cellH = tex.height / detail;
	// int numVertices = 0;
	for (int col = 0; col < detail; col++) {
		for (int row = 0; row < detail; row++) {
			float xU = col * cellW;
			float yV = row * cellH;
			float x = -tex.width/2f + col * cellW;
			float y = -tex.height/2f + row * cellH;
			float z = 0;
			sh.normal(x, y, z);
			sh.vertex(x, y, z, P.map(xU, 0, tex.width, 0, 1), P.map(yV, 0, tex.height, 0, 1));
			sh.vertex(x, y + cellH, z, P.map(xU, 0, tex.width, 0, 1), P.map(yV + cellH, 0, tex.height, 0, 1));    
			sh.vertex(x + cellW, y + cellH, z, P.map(xU + cellW, 0, tex.width, 0, 1), P.map(yV + cellH, 0, tex.height, 0, 1));    
			sh.vertex(x + cellW, y, z, P.map(xU + cellW, 0, tex.width, 0, 1), P.map(yV, 0, tex.height, 0, 1));
			// numVertices++;
		}
	}
	// P.println("createSheet() vertices:", numVertices);
	sh.endShape(); 
	P.p.textureMode(P.IMAGE); 	// reset 
	return sh;
}
 

public PShape stringToShape2d(String text, String fontFile) {
	// if letter is in the cache, just send it back
	if(textShape2d.get(text) != null) return textShape2d.get(text);

	// geomerative builds a mesh from text & cached font
	if(fontsCache.get(fontFile) == null) fontsCache.put(fontFile, new RFont(fontFile, 100, RFont.CENTER)); // 
	RFont font = fontsCache.get(fontFile);
	RGroup grp = font.toGroup(text);
	RMesh rMesh = grp.toMesh();
	
	// convert to triangle strips from geomerative strips
	PShape newShape = P.p.createShape(P.GROUP);
	newShape.setName(text);
	for ( int i = 0; i < rMesh.strips.length; i++ ) {
		
		RPoint[] meshPoints = rMesh.strips[i].getPoints();
		PShape triangle = P.p.createShape();
		triangle.beginShape(P.TRIANGLE_STRIP);
		triangle.fill(255);
		triangle.noStroke();
		for ( int ii = 0; ii < meshPoints.length; ii++ ) {
			triangle.vertex(meshPoints[ii].x, meshPoints[ii].y, 0);
		}
		triangle.endShape();
		newShape.addChild(triangle);
	}
	
	// center it
	PShapeUtil.centerShape(newShape);
	
	// cache & return
	textShape2d.put(text, newShape);
	return newShape;
}
 

public static PShape createSheet(int detail, float width, float height) {
		P.p.textureMode(P.NORMAL); 
		// P.println("Shapes.createSheet() setting textureMode is weird to do here... Maybe should be PAppletHax default?");
		PShape sh = P.p.createShape();
		sh.beginShape(P.QUADS);
		sh.noStroke();
//		sh.texture(tex);
		float cellW = width / detail;
		float cellH = height / detail;
		// int numVertices = 0;
		for (int col = 0; col < detail; col++) {
			for (int row = 0; row < detail; row++) {
				float xU = col * cellW;
				float yV = row * cellH;
				float x = -width/2f + col * cellW;
				float y = -height/2f + row * cellH;
				float z = 0;
				sh.normal(x, y, z);
				sh.vertex(x, y, z, P.map(xU, 0, width, 0, 1), P.map(yV, 0, height, 0, 1));
				sh.vertex(x, y + cellH, z, P.map(xU, 0, width, 0, 1), P.map(yV + cellH, 0, height, 0, 1));    
				sh.vertex(x + cellW, y + cellH, z, P.map(xU + cellW, 0, width, 0, 1), P.map(yV + cellH, 0, height, 0, 1));    
				sh.vertex(x + cellW, y, z, P.map(xU + cellW, 0, width, 0, 1), P.map(yV, 0, height, 0, 1));
				// numVertices += 4;
			}
		}
		// P.println("createSheet() vertices:", numVertices);
		sh.endShape(); 
		P.p.textureMode(P.IMAGE); 	// reset 
		return sh;
	}
 

public static void repairMissingSVGVertex(PShape shape) {
	PVector v1 = shape.getVertex(0);
	PVector v2 = shape.getVertex(0);
	PVector v3 = shape.getVertex(shape.getVertexCount() - 1);
	
	shape.beginShape();
	shape.fill(255, 255, 255);
	shape.noStroke();
	shape.vertex(v1.x, v1.y, v1.z);
	shape.vertex(v2.x, v2.y, v2.z);
	shape.vertex(v3.x, v3.y, v3.z);
	shape.endShape();
}
 

public void displayMesh(PShape pg, DwIndexedFaceSet ifs){
//  pg.beginShape(PConstants.TRIANGLES);
  pg.textureMode(PConstants.NORMAL);
  pg.texture(DEF.style.texture);
  pg.noStroke();
  int     s0,s1,s2;
  int     i0,i1,i2;
  float[] t0,t1,t2;
  float[] v0,v1,v2;
  for(int i = 0; i < DEF.FACES_COUNT; i++){
    i0 = faces[i][0];  v0 = ifs.verts[i0];
    i1 = faces[i][1];  v1 = ifs.verts[i1];
    i2 = faces[i][2];  v2 = ifs.verts[i2];
    
    i0 = DEF.FACES[i][0]; s0 = DEF.HILO[i0];  t0 = DEF.TEX_COORDS[i0];
    i1 = DEF.FACES[i][1]; s1 = DEF.HILO[i1];  t1 = DEF.TEX_COORDS[i1];
    i2 = DEF.FACES[i][2]; s2 = DEF.HILO[i2];  t2 = DEF.TEX_COORDS[i2];
    
    int ci = DEF.FACES_COL[i];
    
    if(DEF.style.texture != null){
      DwDisplayUtils.vertex(pg, v0, t0); 
      DwDisplayUtils.vertex(pg, v1, t1); 
      DwDisplayUtils.vertex(pg, v2, t2); 
    } else {
//      pg.fill(DEF.style.COL[s0]); DwDisplayUtils.vertex(pg, v0);
//      pg.fill(DEF.style.COL[s1]); DwDisplayUtils.vertex(pg, v1);
//      pg.fill(DEF.style.COL[s2]); DwDisplayUtils.vertex(pg, v2);
      pg.fill(DEF.style.RGBS[ci][s0]); DwDisplayUtils.vertex(pg, v0);
      pg.fill(DEF.style.RGBS[ci][s1]); DwDisplayUtils.vertex(pg, v1);
      pg.fill(DEF.style.RGBS[ci][s2]); DwDisplayUtils.vertex(pg, v2);
    }
  }
//  pg.endShape();
}
 

public static void addTestFillToShape(PShape shape, float oscMult) {
	for (int i = 0; i < shape.getVertexCount(); i++) {
		PVector vertex = shape.getVertex(i);
		int fillReplace = P.p.color(
			127 + 127f * P.sin(vertex.x * oscMult),
			127 + 127f * P.sin(vertex.y * oscMult),
			127 + 127f * P.sin(vertex.z * oscMult)
		);
		shape.setFill(i, fillReplace);
		shape.noStroke();
	}
	for (int j = 0; j < shape.getChildCount(); j++) {
		addTestFillToShape(shape.getChild(j), oscMult);
	}
}
 

private PShape createShape(PGraphics pg){
  int     faces_count = mesh.ifs.getFacesCount();
  int[][] faces       = mesh.ifs.getFaces();
  
  float[] n = new float[3]; // normal buffer
  
  PShape shp = pg.createShape();
  shp.beginShape(PConstants.TRIANGLES);
  shp.noStroke();
  shp.fill(material_color);
  for(int i = 0; i < faces_count; i++){
    int v0 = faces[i][0];
    int v1 = faces[i][1];
    int v2 = faces[i][2];
    DwParticle3D p0 = particles[v0]; if(p0.all_springs_deactivated) continue;
    DwParticle3D p1 = particles[v1]; if(p1.all_springs_deactivated) continue;
    DwParticle3D p2 = particles[v2]; if(p2.all_springs_deactivated) continue;
    
    if(FLAT_SHADING){
      n[0] = n[1] = n[2] = 0;
      DwParticle3D.crossAccum(p0, p1, p2, n);
      shp.normal(n[0], n[1], n[2]); 
      shp.vertex(p0.cx, p0.cy, p0.cz);
      shp.vertex(p1.cx, p1.cy, p1.cz);
      shp.vertex(p2.cx, p2.cy, p2.cz);
    } else {
      n = normals[v0];  shp.normal(n[0], n[1], n[2]);  shp.vertex(p0.cx, p0.cy, p0.cz);
      n = normals[v1];  shp.normal(n[0], n[1], n[2]);  shp.vertex(p1.cx, p1.cy, p1.cz);
      n = normals[v2];  shp.normal(n[0], n[1], n[2]);  shp.vertex(p2.cx, p2.cy, p2.cz);
    }
  }
  shp.endShape();
  return shp;
}
 

public PShape createParticleShape(DwParticle2D particle, PImage pimg_sprite){
  
  final float rad = 2;

  PShape shp_sprite = papplet.createShape();
  shp_sprite.beginShape(PConstants.QUADS);
  shp_sprite.noStroke();
  shp_sprite.noFill();
  shp_sprite.tint(255,10,10);
  if(particle.idx == IDX_MOUSE_PARTICLE){
    shp_sprite.tint(200,100,100);
  } else {
    float r = 0 + papplet.random(-30, 30);
    float g = 100;
    float b = 100;
    shp_sprite.tint(r,g,b);
  }
  shp_sprite.textureMode(PConstants.NORMAL);
  shp_sprite.texture(pimg_sprite);
  shp_sprite.normal(0, 0, 1);
  shp_sprite.vertex(-rad, -rad, 0, 0);
  shp_sprite.vertex(+rad, -rad, 1, 0);
  shp_sprite.vertex(+rad, +rad, 1, 1);
  shp_sprite.vertex(-rad, +rad, 0, 1);
  shp_sprite.endShape();
  
  return shp_sprite;
}
 

public PShape createParticleShape(DwParticle2D particle, PImage sprite_img){
    
    final float rad = particle.rad;

    PShape shp_particle = papplet.createShape(PShape.GROUP);
    
    if( PARTICLE_SHAPE_IDX >= 0 && PARTICLE_SHAPE_IDX < 4){
      
      PShape sprite = papplet.createShape(PShape.GEOMETRY);
      sprite.beginShape(PConstants.QUAD);
      sprite.noStroke();
      sprite.noFill();
      sprite.textureMode(PConstants.NORMAL);
      sprite.texture(sprite_img);
      sprite.normal(0, 0, 1);
      sprite.vertex(-rad, -rad, 0, 0);
      sprite.vertex(+rad, -rad, 1, 0);
      sprite.vertex(+rad, +rad, 1, 1);
      sprite.vertex(-rad, +rad, 0, 1);
      sprite.endShape();
      
      shp_particle.addChild(sprite);
    }
    else if( PARTICLE_SHAPE_IDX == 4){   
      
      float threshold1 = 1;   // radius shortening for arc segments
      float threshold2 = 140; // arc between segments
      
      double arc1 = Math.acos(Math.max((rad-threshold1), 0) / rad);
      double arc2 = (180 - threshold2) * Math.PI / 180;
      double arc = Math.min(arc1, arc2);
      
      int num_vtx = (int)Math.ceil(2*Math.PI/arc);
      
//      System.out.println(num_vtx);

      PShape circle = papplet.createShape(PShape.GEOMETRY);
      circle.beginShape();
      circle.noStroke();
      circle.fill(200,100);
      for(int i = 0; i < num_vtx; i++){
        float vx = (float) Math.cos(i * 2*Math.PI/num_vtx) * rad;
        float vy = (float) Math.sin(i * 2*Math.PI/num_vtx) * rad;
        circle.vertex(vx, vy);
      }
      circle.endShape(PConstants.CLOSE);

      PShape line = papplet.createShape(PShape.GEOMETRY);
      line.beginShape(PConstants.LINES);
      line.stroke(0, 100);
      line.strokeWeight(1);
      line.vertex(0, 0);
      line.vertex(-(rad-1), 0);
      line.endShape();
      
//      PShape circle = papplet.createShape(PConstants.ELLIPSE, 0, 0, rad*2, rad*2);
//      circle.setStroke(false);
//      circle.setFill(papplet.color(200,100));
//
//      PShape line = papplet.createShape(PConstants.LINE, 0, 0, -(rad-1), 0);
//      line.setStroke(papplet.color(0,200));
//      line.setStrokeWeight(1); 
      
      shp_particle.addChild(circle);
      shp_particle.addChild(line);
    }
    
    return shp_particle;
    
  }
 

public PShape stringToShape3d(String text, float depth, String fontFile) {
	// if letter is in the cache, just send it back
	if(textShape3d.get(text) != null) return textShape3d.get(text);

	// geomerative builds a mesh from text & cached font
	if(fontsCache.get(fontFile) == null) fontsCache.put(fontFile, new RFont(fontFile, 100, RFont.CENTER)); // 
	RFont font = fontsCache.get(fontFile);
	RGroup grp = font.toGroup(text);
	RMesh rMesh = grp.toMesh();
	
	// 3d measurements
	float halfDepth = depth / 2f;
	
	// convert to triangle strips from geomerative strips
	PShape newShape = P.p.createShape(P.GROUP);
	newShape.setName(text);
	for ( int i = 0; i < rMesh.strips.length; i++ ) {
		RPoint[] meshPoints = rMesh.strips[i].getPoints();
		PShape triangle = P.p.createShape();
		
		// back
		triangle.beginShape(P.TRIANGLE_STRIP);
		triangle.fill(255);
		triangle.noStroke();
		for ( int ii = 0; ii < meshPoints.length; ii++ ) {
			triangle.vertex(meshPoints[ii].x, meshPoints[ii].y, -halfDepth);
		}
		triangle.endShape();
		newShape.addChild(triangle);

		// front
		triangle = P.p.createShape();
		triangle.beginShape(P.TRIANGLE_STRIP);
		triangle.fill(255);
		triangle.noStroke();
		for ( int ii = 0; ii < meshPoints.length; ii++ ) {
			triangle.vertex(meshPoints[ii].x, meshPoints[ii].y, halfDepth);
		}
		triangle.endShape();
		newShape.addChild(triangle);
		
		// wall (drawing quads across strip points, which is weird)
		triangle = P.p.createShape();
		triangle.beginShape(P.QUADS);
		triangle.fill(255);
		triangle.noStroke();
		for ( int ii = 0; ii < meshPoints.length - 2; ii++ ) {
			triangle.vertex(meshPoints[ii].x, meshPoints[ii].y, -halfDepth);
			triangle.vertex(meshPoints[ii].x, meshPoints[ii].y, halfDepth);
			triangle.vertex(meshPoints[ii+1].x, meshPoints[ii+1].y, halfDepth);
			triangle.vertex(meshPoints[ii+1].x, meshPoints[ii+1].y, -halfDepth);

			triangle.vertex(meshPoints[ii+2].x, meshPoints[ii+2].y, -halfDepth);
			triangle.vertex(meshPoints[ii+2].x, meshPoints[ii+2].y, halfDepth);
			triangle.vertex(meshPoints[ii+1].x, meshPoints[ii+1].y, halfDepth);
			triangle.vertex(meshPoints[ii+1].x, meshPoints[ii+1].y, -halfDepth);
			
			triangle.vertex(meshPoints[ii+2].x, meshPoints[ii+2].y, -halfDepth);
			triangle.vertex(meshPoints[ii+2].x, meshPoints[ii+2].y, halfDepth);
			triangle.vertex(meshPoints[ii].x, meshPoints[ii].y, halfDepth);
			triangle.vertex(meshPoints[ii].x, meshPoints[ii].y, -halfDepth);
		}
		triangle.endShape();
		newShape.addChild(triangle);
	}
	
	// center it
	PShapeUtil.centerShape(newShape);
	
	// cache & return
	textShape3d.put(text, newShape);
	return newShape;
}
 

public PShape createParticleShape(DwParticle2D particle){
  
  final float rad = particle.rad;

  PShape shp_particle = papplet.createShape(PShape.GROUP);
  
  // compute circle resolution, depending on the radius we reduce/increase
  // the number of vertices we need to render
  float threshold1 = 1;   // radius shortening for arc segments
  float threshold2 = 140; // arc between segments
  
  double arc1 = Math.acos(Math.max((rad-threshold1), 0) / rad);
  double arc2 = (180 - threshold2) * Math.PI / 180;
  double arc = Math.min(arc1, arc2);
  
  int num_vtx = (int)Math.ceil(2*Math.PI/arc);
  
  // actual circle
  PShape circle = papplet.createShape(PShape.GEOMETRY);
  circle.beginShape();
  circle.noStroke();
  circle.fill(200,100);
  for(int i = 0; i < num_vtx; i++){
    float vx = (float) Math.cos(i * 2*Math.PI/num_vtx) * 1;
    float vy = (float) Math.sin(i * 2*Math.PI/num_vtx) * 1;
    circle.vertex(vx, vy);
  }
  circle.endShape(PConstants.CLOSE);

  // line, to indicate the velocity-direction of the particle
  PShape line = papplet.createShape(PShape.GEOMETRY);
  line.beginShape(PConstants.LINES);
  line.stroke(255, 100);
  line.strokeWeight(1f/rad);
  line.vertex(0, 0);
  line.vertex(-1, 0);
  line.endShape();
  
  shp_particle.addChild(circle);
  shp_particle.addChild(line);
  
  return shp_particle;
}
 

public PShape createParticleShape(DwParticle2D particle, PImage sprite_img){
    
    final float rad = particle.rad;

    PShape shp_particle = papplet.createShape(PShape.GROUP);
    
    if( PARTICLE_SHAPE_IDX >= 0 && PARTICLE_SHAPE_IDX < 4){
      
      PShape sprite = papplet.createShape(PShape.GEOMETRY);
      sprite.beginShape(PConstants.QUAD);
      sprite.noStroke();
      sprite.noFill();
      sprite.textureMode(PConstants.NORMAL);
      sprite.texture(sprite_img);
      sprite.normal(0, 0, 1);
      sprite.vertex(-rad, -rad, 0, 0);
      sprite.vertex(+rad, -rad, 1, 0);
      sprite.vertex(+rad, +rad, 1, 1);
      sprite.vertex(-rad, +rad, 0, 1);
      sprite.endShape();
      
      shp_particle.addChild(sprite);
    }
    else if( PARTICLE_SHAPE_IDX == 4){   
      
      float threshold1 = 1;   // radius shortening for arc segments
      float threshold2 = 140; // arc between segments
      
      double arc1 = Math.acos(Math.max((rad-threshold1), 0) / rad);
      double arc2 = (180 - threshold2) * Math.PI / 180;
      double arc = Math.min(arc1, arc2);
      
      int num_vtx = (int)Math.ceil(2*Math.PI/arc);
      
//      System.out.println(num_vtx);

      PShape circle = papplet.createShape(PShape.GEOMETRY);
      circle.beginShape();
      circle.noStroke();
      circle.fill(200,100);
      for(int i = 0; i < num_vtx; i++){
        float vx = (float) Math.cos(i * 2*Math.PI/num_vtx) * rad;
        float vy = (float) Math.sin(i * 2*Math.PI/num_vtx) * rad;
        circle.vertex(vx, vy);
      }
      circle.endShape(PConstants.CLOSE);

      PShape line = papplet.createShape(PShape.GEOMETRY);
      line.beginShape(PConstants.LINES);
      line.stroke(0, 100);
      line.strokeWeight(1);
      line.vertex(0, 0);
      line.vertex(-(rad-1), 0);
      line.endShape();
      
//      PShape circle = papplet.createShape(PConstants.ELLIPSE, 0, 0, rad*2, rad*2);
//      circle.setStroke(false);
//      circle.setFill(papplet.color(200,100));
//
//      PShape line = papplet.createShape(PConstants.LINE, 0, 0, -(rad-1), 0);
//      line.setStroke(papplet.color(0,200));
//      line.setStrokeWeight(1); 
      
      shp_particle.addChild(circle);
      shp_particle.addChild(line);
    }
    
    return shp_particle;
    
  }