/*
  dracoLoader.load( 'models/putin_2.drc', function ( geometry ) {

    geometry.computeVertexNormals();

    var material = new THREE.MeshBasicMaterial( { vertexColors: THREE.VertexColors } );
    var mesh = new THREE.Mesh( geometry, material );
    mesh.castShadow = true;
    mesh.receiveShadow = true;
    scene.add( mesh );

    // Release the cached decoder module.
    THREE.DRACOLoader.releaseDecoderModule();

  } );
*/

function load() {
  // Enable logging to console output.
  dracoLoader.setVerbosity(1);

  // To use triangle strips use:
  //   dracoLoader.setDrawMode(THREE.TriangleStripDrawMode);
  dracoLoader.setDrawMode(THREE.TrianglesDrawMode);

  // Skip dequantization of the position attribute. It will be done on the GPU.
  dracoLoader.setSkipDequantization('position', true);
  dracoLoader.decodeDracoFile(reader.result, function(bufferGeometry) {
    if (dracoLoader.decode_time !== undefined) {
      fileDisplayArea.innerText = 'Decode time = ' + dracoLoader.decode_time + '\n' +
                                  'Import time = ' + dracoLoader.import_time;
    }
    var material = new THREE.MeshBasicMaterial({vertexColors: THREE.VertexColors});
    material.wireframe = true
    // If the position attribute is quantized, modify the material to perform
    // dequantization on the GPU.
    if (bufferGeometry.attributes['position'].isQuantized) {
      setDequantizationForMaterial(material, bufferGeometry);
    }

    var geometry;
    // Point cloud does not have face indices.
    if (bufferGeometry.index == null) {
      geometry = new THREE.Points(bufferGeometry, material);
    } else {
      if (bufferGeometry.attributes.normal === undefined) {
        var geometryHelper = new GeometryHelper();
        geometryHelper.computeVertexNormals(bufferGeometry);
      }
      geometry = new THREE.Mesh(bufferGeometry, material);
      geometry.drawMode = dracoLoader.drawMode;
    }

    // Compute range of the geometry coordinates for proper rendering.
    bufferGeometry.computeBoundingBox();
    if (bufferGeometry.attributes['position'].isQuantized) {
      // If the geometry is quantized, transform the bounding box to the dequantized
      // coordinates.
      var posAttribute = bufferGeometry.attributes['position'];
      var normConstant =
          posAttribute.maxRange / (1 << posAttribute.numQuantizationBits);
      var minPos = posAttribute.minValues;
      bufferGeometry.boundingBox.max.x =
          minPos[0] + bufferGeometry.boundingBox.max.x * normConstant;
      bufferGeometry.boundingBox.max.y =
          minPos[1] + bufferGeometry.boundingBox.max.y * normConstant;
      bufferGeometry.boundingBox.max.z =
          minPos[2] + bufferGeometry.boundingBox.max.z * normConstant;
      bufferGeometry.boundingBox.min.x =
          minPos[0] + bufferGeometry.boundingBox.min.x * normConstant;
      bufferGeometry.boundingBox.min.y =
          minPos[1] + bufferGeometry.boundingBox.min.y * normConstant;
      bufferGeometry.boundingBox.min.z =
          minPos[2] + bufferGeometry.boundingBox.min.z * normConstant;
    }
    var sizeX = bufferGeometry.boundingBox.max.x - bufferGeometry.boundingBox.min.x;
    var sizeY = bufferGeometry.boundingBox.max.y - bufferGeometry.boundingBox.min.y;
    var sizeZ = bufferGeometry.boundingBox.max.z - bufferGeometry.boundingBox.min.z;
    var diagonalSize = Math.sqrt(sizeX * sizeX + sizeY * sizeY + sizeZ * sizeZ);
    var scale = 1.0 / diagonalSize;
    var midX =
      (bufferGeometry.boundingBox.min.x + bufferGeometry.boundingBox.max.x) / 2;
    var midY =
      (bufferGeometry.boundingBox.min.y + bufferGeometry.boundingBox.max.y) / 2;
    var midZ =
      (bufferGeometry.boundingBox.min.z + bufferGeometry.boundingBox.max.z) / 2;

    geometry.scale.multiplyScalar(scale);
    geometry.position.x = -midX * scale;
    geometry.position.y = -midY * scale;
    geometry.position.z = -midZ * scale;
    // geometry.castShadow = true;
    // geometry.receiveShadow = true;

    var selectedObject = scene.getObjectByName("my_mesh");
    scene.remove(selectedObject);
    geometry.name = "my_mesh";
    scene.add(geometry);
  });
}

function setDequantizationForMaterial(material, bufferGeometry) {
  material.onBeforeCompile = function(shader) {
    // Add uniform variables needed for dequantization.
    var posAttribute = bufferGeometry.attributes['position'];
    shader.uniforms.normConstant =
      { value: posAttribute.maxRange / (1 << posAttribute.numQuantizationBits) };
    shader.uniforms.minPos = { value: posAttribute.minValues };

    shader.vertexShader = 'uniform float maxRange;\n' +
                          'uniform float normConstant;\n' +
                          'uniform vec3 minPos;\n' +
                          shader.vertexShader;
    shader.vertexShader = shader.vertexShader.replace(
        '#include <begin_vertex>',
        'vec3 transformed = minPos + position * normConstant;'
    );
  }
}