TypeScript VertexBuffer.set_size方法代码示例

 protected _set_data(nvertices: number): void {
   const n = nvertices * 4;  // in bytes
   // Set buffer size
   this.vbo_x.set_size(n)
   this.vbo_y.set_size(n)
   this.vbo_a.set_size(n)
   this.vbo_s.set_size(n)
   // Upload data for x and y, apply a baked-in offset for float32 precision (issue #3795)
   // The exact value for the baked_offset does not matter, as long as it brings the data to less extreme values
   const xx = new Float64Array(this.glyph._x)
   const yy = new Float64Array(this.glyph._y)
   for (let i = 0, end = nvertices; i < end; i++) {
      xx[i] += this._baked_offset[0]
      yy[i] += this._baked_offset[1]
   }
   this.vbo_x.set_data(0, new Float32Array(xx))
   this.vbo_y.set_data(0, new Float32Array(yy))
   // Angle if available; circle does not have angle. If we don't set data, angle is default 0 in glsl
   if (this.glyph._angle != null) {
     this.vbo_a.set_data(0, new Float32Array(this.glyph._angle))
   }
   // Radius is special; some markes allow radius in data-coords instead of screen coords
   // @radius tells us that radius is in units, sradius is the pre-calculated screen radius
   if (this.glyph instanceof CircleView && this.glyph._radius != null)
     this.vbo_s.set_data(0, new Float32Array(map(this.glyph.sradius, (s) => s*2)))
   else
     this.vbo_s.set_data(0, new Float32Array(this.glyph._size))
 }

    _set_data() {
      this._bake();

      this.vbo_position.set_size(this.V_position.length*4);
      this.vbo_position.set_data(0, this.V_position);

      this.vbo_tangents.set_size(this.V_tangents.length*4);
      this.vbo_tangents.set_data(0, this.V_tangents);

      this.vbo_angles.set_size(this.V_angles.length*4);
      this.vbo_angles.set_data(0, this.V_angles);

      this.vbo_texcoord.set_size(this.V_texcoord.length*4);
      return this.vbo_texcoord.set_data(0, this.V_texcoord);
    }

    _update_scale(sx, sy) {
      // Update segment data and cumsum so the length along the line has the
      // scale aspect ratio in it. In the vertex shader we multiply with the
      // "isotropic part" of the scale.

      let V_segment2;
      const n = this.nvertices;
      const m = (4 * n) - 4;
      // Prepare arrays
      const T = this.tangents;
      const N = new Float32Array(n-1);
      const V_segment = new Float32Array(n*2);  // Elements are initialized with 0
      this.V_segment = (V_segment2 = new Float32Array(m*2));
      // Calculate vector lengths - with scale aspect ratio taken into account
      for (let i = 0, end = n-1; i < end; i++) {
        N[i] = Math.sqrt(Math.pow(T[(i*2)+0] * sx, 2) + Math.pow(T[(i*2)+1] * sy, 2));
      }
      // Calculate Segments
      let cumsum = 0;
      for (let i = 0, end = n-1; i < end; i++) {
        cumsum += N[i];
        V_segment[((i+1)*2)+0] = cumsum;
        V_segment[(i*2)+1] = cumsum;
      }
      // Upscale (same loop as in _bake())
      for (let i = 0, end = n; i < end; i++) {
         for (let j = 0; j < 4; j++) {
            for (let k = 0; k < 2; k++) {
              V_segment2[(((i*4)+j)*2)+k] = V_segment[(i*2)+k];
          }
        }
      }
      // Update
      this.cumsum = cumsum;  // L[-1] in Nico's code
      this.vbo_segment.set_size(this.V_segment.length*4);
      return this.vbo_segment.set_data(0, this.V_segment);
    }