Java PShape.resetMatrix方法代码示例

import processing.core.PShape; //导入方法依赖的package包/类
public PShape createParticleShape(DwParticle3D particle){
   
    PShape shp_particle = papplet.createShape(PShape.GEOMETRY);
    
    shp_particle.resetMatrix();
    shp_particle.translate(particle.cx, particle.cy, particle.cz);
    shp_particle.rotateX(papplet.random(PConstants.TWO_PI));
    shp_particle.rotateY(papplet.random(PConstants.TWO_PI));
    shp_particle.rotateZ(papplet.random(PConstants.TWO_PI));
    shp_particle.setStroke(false);
//    shp_particle.setFill(papplet.color(160));
    
    if(ifs == null) ifs = new DwIcosahedron(1);
//    if(ifs == null) ifs = new DwCube(1);
    DwMeshUtils.createPolyhedronShape(shp_particle, ifs, 1, 3, true);

    return shp_particle;
  }
 

import processing.core.PShape; //导入方法依赖的package包/类
protected void updateShapesData(){
    
    if(particle_num == 0){
      return;
    }
  
    final PMatrix2D mat = new PMatrix2D();
    
    for (int i = 0, ipos = 0, icol = 0; i < particle_num; i++) {
      // position
      float pos_x = buf_pos[ipos++];
      float pos_y = buf_pos[ipos++];
      // velocity
//      float vel_x = buf_vel[ivel++];
//      float vel_y = buf_vel[ivel++];
      // tint
      int tint = DwUtils.createColorARGB(buf_col, icol); icol += 4;
      
      mat.reset();
      mat.translate(pos_x, pos_y);
      mat.scale(particle_rad_world);
//      mat.rotate((float)Math.atan2(vel_y, vel_x));
      
      PShape shp = shp_particles.getChild(i);
      shp.resetMatrix();
//      mat.translate(pos_x, pos_y);
//      mat.scale(particle_rad_world);
      shp.applyMatrix(mat);

      shp.setTint(tint);
    }
    
  }
 

import processing.core.PShape; //导入方法依赖的package包/类
protected void updateLineShape(PShape shp, Vec2 p0, Vec2 p1){
  Vec2 AB = p1.sub(p0);
  
  // https://github.com/processing/processing/blob/master/core/src/processing/opengl/PShapeOpenGL.java#L1348
  float ab_len = AB.length() + 0.0000001f; 
  
  shp.resetMatrix();
  shp.scale(ab_len, 1);
  shp.rotate((float) Math.atan2(AB.y, AB.x));
  shp.translate(p0.x, p0.y);
}
 

import processing.core.PShape; //导入方法依赖的package包/类
void addShape(MyPoissonSample sample){
    PShape shp_point = createShape(POINT, sample.x(), sample.y(), sample.z());
    shp_point.setStroke(color(255));
    shp_point.setStrokeWeight(3);
    shp_samples_points.addChild(shp_point);
    

    if(ifs == null){
      ifs = new DwIcosahedron(2); verts_per_face = 3;
//      ifs = new DwCube(2); verts_per_face = 4;
    }
    PShape shp_sphere = createShape(PShape.GEOMETRY);
    shp_sphere.setStroke(false);
    shp_sphere.setFill(color(255));
    shp_sphere.resetMatrix();
    shp_sphere.translate(sample.x(), sample.y(), sample.z());
   
    DwMeshUtils.createPolyhedronShape(shp_sphere, ifs, sample.rad(), verts_per_face, true);
    
    shp_samples_spheres.addChild(shp_sphere);
    
    
//    PShape shp_sphere_normals = createShape(PShape.GEOMETRY);
//    shp_sphere_normals.setStroke(false);
//    shp_sphere_normals.setFill(color(255));
//    shp_sphere_normals.resetMatrix();
//    shp_sphere_normals.translate(sample.x(), sample.y(), sample.z());
//   
//    DwMeshUtils.createPolyhedronShapeNormals(shp_sphere_normals, ifs, sample.rad(), 10);
//    
//    shp_samples_spheres.addChild(shp_sphere_normals);
  }
 

import processing.core.PShape; //导入方法依赖的package包/类
public void updateSpheres(){
  PShape[] shp_spheres = shp_samples_spheres.getChildren();
  for(int i = 0; i < shp_spheres.length; i++){
    PShape shp_sphere = shp_spheres[i];
    MyPoissonSample sample = pds.samples.get(i);
    sample.updateAnimation();
    shp_sphere.resetMatrix();
    shp_sphere.scale(sample.anim_rad);
    shp_sphere.translate(sample.x(), sample.y(), sample.z());
  }
}
 

import processing.core.PShape; //导入方法依赖的package包/类
void addShape(MyPoissonSample sample){
    PShape shp_point = createShape(POINT, sample.x(), sample.y(), sample.z());
    shp_point.setStroke(color(255));
    shp_point.setStrokeWeight(3);
    shp_samples_points.addChild(shp_point);
    

    if(ifs == null){
      ifs = new DwIcosahedron(2); verts_per_face = 3;
//      ifs = new DwCube(3); verts_per_face = 4;
    }
    PShape shp_sphere = createShape(PShape.GEOMETRY);
    shp_sphere.setStroke(false);
    shp_sphere.setFill(color(255));
    
    colorMode(HSB, 360, 1, 1);
    float hsb_h = 15 + (float)(Math.random() - 0.5f) * 45 ;
    float hsb_s = (float) Math.random() * 0.99f + 0.01f;
    float hsb_b = hsb_s*3;
    
    shp_sphere.setFill(color(hsb_h, hsb_s, hsb_b));
    colorMode(RGB);
    
    shp_sphere.resetMatrix();
    shp_sphere.translate(sample.x(), sample.y(), sample.z());
    
    boolean flat_shading = random(1) > 0.5f;
   
    DwMeshUtils.createPolyhedronShape(shp_sphere, ifs, sample.rad(), verts_per_face, flat_shading);
    
    shp_samples_spheres.addChild(shp_sphere);
  }
 

import processing.core.PShape; //导入方法依赖的package包/类
public void updateAnim(){
    
    float scene_dimx = bounds[3] - bounds[0];
    float scene_dimy = bounds[4] - bounds[1];
    float scene_dimz = bounds[5] - bounds[2];
    
    float bounds_off = 100;
    
    float dimx = (scene_dimx - bounds_off*2) / num_x;
    float dimy = (scene_dimy - bounds_off*2) / num_y;
    
    float dim = min(dimx, dimy);

    float tx = -dim * num_x * 0.5f;
    float ty = -dim * num_y * 0.5f;
    
    anim_counter += 0.003f;
    
    float anim_frequency = 2;
    
    for(int y = 0; y < num_y; y++){
      for(int x = 0; x < num_x; x++){
        int idx = y * num_x + x;
        PShape shp_cube = shp_cubes[idx];
        
        float nval = noise(anim_counter + anim_frequency*x/(float)num_x, anim_counter + anim_frequency*y/(float)num_y);
        float dim_z = scene_dimz * nval * nval;
        
        float rgb_r = 255;
        float rgb_g = 255*nval;
        float rgb_b = 255*nval*nval;
        
        
        shp_cube.setFill(color(rgb_r, rgb_g, rgb_b));

        shp_cube.resetMatrix();
//        shp_cube.rotateY(nval*PI);
//        shp_cube.rotateX(nval*PI);
//        shp_cube.rotateZ(nval*PI);
        shp_cube.translate(tx + x * dim, ty + y * dim, dim_z);
//        shp_cube.rotateY(nval*PI/4f);
//        shp_cube.rotateX(nval*PI);
//        shp_cube.rotateZ(nval*PI);
        shp_cube.rotateZ(cos(nval*10));
//        shp_cube.rotateY(nval*PI/4f);
//        shp_cube.rotateZ(nval*PI);
//        shp_cube.rotateX(nval*PI);
//        shp_cube.rotateY(nval*PI);
      }
    }
  }
 

import processing.core.PShape; //导入方法依赖的package包/类
public void updateAnim(){
  
  if(pg_src_small == null){
    return;
  }
  
  int num_x = pg_src_small.width;
  int num_y = pg_src_small.height;
  
  DwFilter.get(context).gaussblur.apply(pg_src, pg_src, pg_src_tmp, 5);
  
  pg_src_small.beginDraw();
  pg_src_small.image(pg_src, 0, 0, num_x, num_y);
  pg_src_small.endDraw();
  
  opticalflow.update(pg_src);
  DwFilter.get(context).copy.apply(opticalflow.frameCurr.velocity, tex_vel_small);
  flow = tex_vel_small.getFloatTextureData(flow);

  DwFilter.get(context).gaussblur.apply(pg_src_small, pg_src_small, pg_src_small_tmp, 3);
  
  pg_src_small.loadPixels();
  



  float scene_dimx = bounds[3] - bounds[0];
  float scene_dimy = bounds[4] - bounds[1];
  float scene_dimz = bounds[5] - bounds[2];
  float bounds_off = 100;

  float dimx = (scene_dimx - bounds_off*2) / num_x;
  float dimy = (scene_dimy - bounds_off*2) / num_y;
  
  float dim = min(dimx, dimy);

  float tx = -dim * num_x * 0.5f;
  float ty = -dim * num_y * 0.5f;
  float tz = 0;

  for(int y = 0; y < num_y; y++){
    for(int x = 0; x < num_x; x++){
      int idx = y * num_x + x;

      int rgb = pg_src_small.pixels[idx];
      int r = (rgb >> 16) & 0xFF;
      int g = (rgb >>  8) & 0xFF;
      int b = (rgb >>  0) & 0xFF;
      
      int flow_idx = (num_y - y - 1) * num_x + x;
      float flows = 5;
      float flowx = flow[flow_idx * 2 + 0] * +flows;
      float flowy = flow[flow_idx * 2 + 1] * -flows;
      

      float gray = (r + g + b) / (3f * 255f);
      
      float px = tx + x * dim + flowx;
      float py = ty + y * dim + flowy;
      float pz = tz + scene_dimz * gray * 0.35f;
      
      PShape cube = shp_cubes[idx];

      cube.resetMatrix();
      cube.scale(dim);
      cube.translate(px, py, pz);
 
      cube.setFill(rgb);
    }
  }
}
 

import processing.core.PShape; //导入方法依赖的package包/类
public void updateAnim(){
    
    float scene_dimx = bounds[3] - bounds[0];
    float scene_dimy = bounds[4] - bounds[1];
    float scene_dimz = bounds[5] - bounds[2];
    
    float bounds_off = 100;
    
    float dimx = (scene_dimx - bounds_off*2) / num_x;
    float dimy = (scene_dimy - bounds_off*2) / num_y;
    
    float dim = min(dimx, dimy);

    float tx = -dim * num_x * 0.5f;
    float ty = -dim * num_y * 0.5f;
    
    anim_counter += 0.003f;
    
    float anim_frequency = 2;
    
    for(int y = 0; y < num_y; y++){
      for(int x = 0; x < num_x; x++){
        int idx = y * num_x + x;
        PShape shp_cube = shp_cubes[idx];
        
        float nval = noise(anim_counter + anim_frequency*x/(float)num_x, anim_counter + anim_frequency*y/(float)num_y);
        float dim_z = scene_dimz * nval * nval;
        
//        float rgb_r = 255;
//        float rgb_g = 255*nval;
//        float rgb_b = 255*nval*nval;
        
        
//        shp_cube.setFill(color(rgb_r, rgb_g, rgb_b));

        shp_cube.resetMatrix();
//        shp_cube.rotateY(nval*PI);
//        shp_cube.rotateX(nval*PI);
//        shp_cube.rotateZ(nval*PI);
        shp_cube.translate(tx + x * dim, ty + y * dim, dim_z);
//        shp_cube.rotateY(nval*PI/4f);
//        shp_cube.rotateX(nval*PI);
//        shp_cube.rotateZ(nval*PI);
//        shp_cube.rotateZ(cos(nval*10));
//        shp_cube.rotateY(nval*PI/4f);
//        shp_cube.rotateZ(nval*PI);
//        shp_cube.rotateX(nval*PI);
//        shp_cube.rotateY(nval*PI);
      }
    }
  }
 

import processing.core.PShape; //导入方法依赖的package包/类
public void updateAnim(){
  
  if(pg_src_small == null){
    createScene();
  }
  
  int num_x = pg_src_small.width;
  int num_y = pg_src_small.height;
  
  DwFilter.get(context).gaussblur.apply(pg_src, pg_src, pg_src_tmp, 3);
  
  pg_src_small.beginDraw();
  pg_src_small.image(pg_src, 0, 0, num_x, num_y);
  pg_src_small.endDraw();
  
  opticalflow.update(pg_src);
  DwFilter.get(context).copy.apply(opticalflow.frameCurr.velocity, tex_vel_small);
  flow = tex_vel_small.getFloatTextureData(flow);

  DwFilter.get(context).gaussblur.apply(pg_src_small, pg_src_small, pg_src_small_tmp, 3);
  
  pg_src_small.loadPixels();
  



  float scene_dimx = bounds[3] - bounds[0];
  float scene_dimy = bounds[4] - bounds[1];
  float scene_dimz = bounds[5] - bounds[2];
  float bounds_off = 100;

  float dimx = (scene_dimx - bounds_off*2) / num_x;
  float dimy = (scene_dimy - bounds_off*2) / num_y;
  
  float dim = min(dimx, dimy);

  float tx = -dim * num_x * 0.5f;
  float ty = -dim * num_y * 0.5f;
  float tz = 10;

  for(int y = 0; y < num_y; y++){
    for(int x = 0; x < num_x; x++){
      int idx = y * num_x + x;

      int rgb = pg_src_small.pixels[idx];
      int r = (rgb >> 16) & 0xFF;
      int g = (rgb >>  8) & 0xFF;
      int b = (rgb >>  0) & 0xFF;
      
      int flow_idx = (num_y - y - 1) * num_x + x;
      float flows = 3;
      float flowx = flow[flow_idx * 2 + 0] * +flows;
      float flowy = flow[flow_idx * 2 + 1] * -flows;
      
      float flow_mm = flowx*flowx + flowy*flowy;
      float flow_m = (float) Math.pow(flow_mm, 0.5f);
      

      float gray = (r + g + b) / (3f * 255f);
      
      float px = x * dim;
      float py = y * dim;
      float pz = scene_dimz * gray * 0.25f + +flow_m;
      
      pz = max(pz, 0);

      
      PShape cube = shp_cubes[idx];

      cube.resetMatrix();
      cube.scale(dim);
      cube.translate(tx+px, ty+py, tz+pz);
 
      cube.setFill(rgb);
    }
  }
}