////////////////// CLASSES //////////////////
480436
function Animation(envMap) {
  var rangeX = 300;
  var rangeY = 200;
  var prefabCount = 6;
  var size = rangeY / prefabCount;

  //var prefabGeometry = new THREE.TorusKnotGeometry(size * 0.25, 2.0);
  var prefabGeometry = new THREE.TorusGeometry(size * 0.25, 4.0, 32, 16);
  var geometry = new BAS.PrefabBufferGeometry(prefabGeometry, prefabCount);

  var i;
  var prefabDataArray = [];

  var aDelayDuration = geometry.createAttribute('aDelayDuration', 2);
  var duration = 1.0;
  var maxPrefabDelay = 0.5;

  this.totalDuration = duration + maxPrefabDelay;

  for (i = 0; i < prefabCount; i++) {
    var delay = THREE.Math.mapLinear(i, 0, prefabCount, 0.0, maxPrefabDelay);

    geometry.setPrefabData(aDelayDuration, i, [delay, duration]);
  }

  var aStartPosition = geometry.createAttribute('aStartPosition', 3);
  var aEndPosition = geometry.createAttribute('aEndPosition', 3);
  var startPosition = new THREE.Vector3();
  var endPosition = new THREE.Vector3();

  for (i = 0; i < prefabCount; i++) {
    startPosition.x = -rangeX * 0.5;
    startPosition.y = THREE.Math.mapLinear(i, 0, prefabCount, -rangeY * 0.5, rangeY * 0.5) + size * 0.5;
    startPosition.z = 0;

    endPosition.x = rangeX * 0.5;
    endPosition.y = startPosition.y;
    endPosition.z = 0;

    geometry.setPrefabData(aStartPosition, i, startPosition.toArray(prefabDataArray));
    geometry.setPrefabData(aEndPosition, i, endPosition.toArray(prefabDataArray));
  }

  var aAxisAngle = geometry.createAttribute('aAxisAngle', 4);
  var axis = new THREE.Vector3();
  var angle;

  for (i = 0; i < prefabCount; i++) {
    axis.x = THREE.Math.randFloatSpread(2);
    axis.y = THREE.Math.randFloatSpread(2);
    axis.z = THREE.Math.randFloatSpread(2);
    axis.normalize();
    angle = Math.PI * 2;

    axis.toArray(prefabDataArray);
    prefabDataArray[3] = angle;

    geometry.setPrefabData(aAxisAngle, i, axis.toArray(prefabDataArray));
  }

  var material = new BAS.PhongAnimationMaterial({
    transparent: true,
    uniforms: {
      uTime: {value: 0},
      uBezierCurve: {value: new THREE.Vector4(.42,0,.58,1)},
      uMap2: {value: null}
    },
    uniformValues: {
      map: new THREE.TextureLoader().load('../_tex/UV_Grid.jpg'),
      envMap: envMap,
      //combine: THREE.MultiplyOperation,
      reflectivity: 0.75,
      //refractionRatio: 0.98
    },
    // functions for the vertex shader (cannot be used in the fragment shader)
    vertexFunctions: [
      BAS.ShaderChunk['ease_bezier'],
      BAS.ShaderChunk['quaternion_rotation']
    ],
    // parameters for the vertex shader
    vertexParameters: [
      'uniform float uTime;',
      'uniform vec4 uBezierCurve;',
      'attribute vec2 aDelayDuration;',
      'attribute vec3 aStartPosition;',
      'attribute vec3 aEndPosition;',
      'attribute vec4 aAxisAngle;'
    ],
    // varying parameters get injected into both the vertex and the fragment shader
    varyingParameters: [
      'varying float vAlpha;',
      'varying vec3 vEmissive;',
      'varying vec3 vSpecular;',
      'varying float vShininess;',
      'varying float vProgress;'
    ],
    // this chunk gets injected at the top of main() of the vertex shader
    vertexInit: [
      'float tProgress = clamp(uTime - aDelayDuration.x, 0.0, aDelayDuration.y) / aDelayDuration.y;',
      'tProgress = easeBezier(tProgress, uBezierCurve);',
      'vProgress = tProgress;',

      'vec4 tQuat = quatFromAxisAngle(aAxisAngle.xyz, aAxisAngle.w * tProgress);'
    ],
    // this chunk gets injected after <beginnormal_vertex> (before any other normal calculations)
    // objectNormal (transformed normal) is used throughout the vertex shader
    vertexNormal: [
      'objectNormal = rotateVector(tQuat, objectNormal);'
    ],
    // this chunk gets injected after <begin_vertex> (before any other normal calculations)
    // transformed (transformed position) is used throughout the vertex shader
    vertexPosition: [
      'transformed = rotateVector(tQuat, transformed);',
      'transformed += mix(aStartPosition, aEndPosition, tProgress);'
    ],
    // this chunk gets injected after vertexPosition
    vertexColor: [
      // these don't make any sense - it's just to test if it works
      'vAlpha = abs(transformed.x) / 150.0 * 0.9 + 0.1;', // based on rangeX = 300
      'vEmissive = abs(normalize(transformed));',
      'vSpecular = abs(normalize(transformed));',
      'vShininess = abs(transformed.z * 100.0);'
    ],
    // functions for the fragment shader (cannot be used in vertex shader)
    fragmentFunctions: [

    ],
    // parameters for the fragment shader
    fragmentParameters: [
      'uniform sampler2D uMap2;'
    ],
    // this chunk overrides <map_fragment>
    // see https://github.com/mrdoob/three.js/blob/master/src/renderers/shaders/ShaderChunk/map_fragment.glsl
    fragmentMap: [
      'vec4 texelColor1 = texture2D(map, vUv);',
      'vec4 texelColor2 = texture2D(uMap2, vUv);',
      'vec4 texelColor = mapTexelToLinear(mix(texelColor1, texelColor2, vProgress));',
      'diffuseColor *= texelColor;'
    ],
    // this chunk gets injected after 'diffuseColor' is defined
    // changes to diffuse color (outside of vertex colors) and alpha should go here
    // diffuseColor is used throughout the fragment shader
    fragmentDiffuse: [
      'diffuseColor.a *= vAlpha;'
    ],
    // this chunk gets injected before <emissivemap_fragment>
    // totalEmissiveRadiance is modulated by the emissive map color
    fragmentEmissive: [
      'totalEmissiveRadiance = vEmissive;' // default emissive = (0, 0, 0)
    ],
    // this chunk gets injected after <fragmentSpecular>
    fragmentSpecular: [
      'material.specularStrength = 0.25;',
      'material.specularShininess = vShininess;',
      'material.specularColor = vSpecular;'
    ]
  });

  // for some reason setting the value inside the constructor does not work :'(
  material.uniforms.uMap2.value = new THREE.TextureLoader().load('../_tex/brick_diffuse.jpg');

  geometry.computeVertexNormals();
  geometry.bufferUvs();

  THREE.Mesh.call(this, geometry, material);

  this.frustumCulled = false;
}
725219
public void generateClasses() throws IOException {
		for (PrefsEntity item : model.getEntities()) {
			BindSharedPreferencesBuilder.generate(elementUtils, filer, item);
		}
	}
643970
public boolean hasClass(String className) {
        for (Element element : this) {
            if (element.hasClass(className))
                return true;
        }
        return false;
    }
127798
@Override
    public Class<?> loadClass(String classname) throws ClassNotFoundException {
        return getClass().getClassLoader().loadClass(classname);
    }
657057
function (classes) {
            var extensions = this.props.extensions;

            if (extensions && extensions.get("addClass")) {
                var data = this.getDataForExtension();
                classes = classes + " " + extensions.get("addClass").map(function (callback) {
                    try {
                        return callback(data);
                    } catch (e) {
                        console.error("Exception thrown in FileTreeView addClass provider: " + e, e.stack);
                    }
                }).filter(isDefined).toArray().join(" ");
            }

            return classes;
        }
1006645
def checkAndCreateClasses(self, classes):
        
        actual_classes = self['puppetclasses'].keys()
        for i in classes:
            if i not in actual_classes:
                self['puppetclasses'].append(i)
        self.reload()
        return set(classes).issubset(set((self['puppetclasses'].keys())))
253375
function addClass() {
      Components.Html.root.classList.add(Glide.settings.classes.direction[this.value]);
    }
986551
public Class<?> findClass(String className) throws ClassNotFoundException {
        for (String skip : SKIP_CLASSES) {
            if (skip.equals(className)) {
                return null;
            }
        }

        for (ClassLoader classLoader : getClassLoaders()) {
            try {
                return classLoader.loadClass(className);
            } catch (ClassNotFoundException e) {
                // ignore
            }
        }
        return Class.forName(className);
    }
704912
@Override
    public void visitInnerClasses(InnerClasses obj) {
        super.visitInnerClasses(obj);
        InnerClass[] inner_classes = obj.getInnerClasses();
        for (InnerClass inner_class : inner_classes) {
            inner_class.accept(this);
        }
    }
786100
@Override
    public Void visitClass(ClassTree node, Set<String> p) {
        scan(node.getModifiers(), p);
        scan(node.getTypeParameters(), p);
        scan(node.getExtendsClause(), p);
        scan(node.getImplementsClause(), p);
        scan(node.getMembers(), body);
        return null;
    }
1048764
@Override
    @SuppressFBWarnings("DM_EXIT")
    public void reportMissingClass(ClassDescriptor classDescriptor) {
        System.out.println("Missing class: " + classDescriptor);
        System.exit(1);
    }
990211
function createFinalClass(params, constructor) {
        var def = Class.$create(params, constructor);
        def[$class].finalClass = true;

        return def;
    }
1109791
public function classes()
    {
        if (is_null($this->classRequests)) {
            $this->classRequests = new ClassRequests($this->client);
        }

        return $this->classRequests;
    }
1301939
public function getClass()
    {
        if (is_null($this->_class)) {
            $this->_class = $this->_getClassName();
        }
        return $this->_class;
    }
857159
function _class(_ref) {
    var args = _ref.args;
    var config = _ref.config;

    _classCallCheck(this, _class);

    var on = null;
    var from = '*';
    var cbOn = null;
    var cbOff = null;
    var alwaysTrigger = false;

    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = args[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var arg = _step.value;

        switch (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) {
          case 'string':
            if (on === null) {
              on = arg;
            } else {
              from = arg;
            }
            break;
          case 'function':
            if (cbOn === null) {
              cbOn = arg;
            } else {
              cbOff = arg;
            }
            break;
          case 'boolean':
            alwaysTrigger = arg;
        }
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    _extends(this, {
      isActive: null,
      matchesOn: parseMatchInputString(on, config.inversePrefix),
      matchesFrom: parseMatchInputString(from, config.inversePrefix),
      cbOn: cbOn, cbOff: cbOff, alwaysTrigger: alwaysTrigger
    });
  }
1194017
<T> Class<T> loadClass(String name) throws ClassNotFoundException {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        if (null == cl) {
            cl = ToHelper.class.getClassLoader();
        }
        return (Class<T>) cl.loadClass(name);
    }
927770
public Class<?> getClass(int id) throws IOException {
      if (id < 0 || id > internalIdToClass.length) {
         throw new IOException("Unknown class id " + id);
      }
      Class<?> clazz = internalIdToClass[id];
      if (clazz == null) {
         throw new IOException("Unknown class id " + id);
      }
      return clazz;
   }