Property getter THREE.SpriteMaterial
772798
function getter_THREE_SpriteMaterial(inst) {
	return [
		inst.name,
		inst.side,
		inst.opacity,
		inst.blending,
		inst.blendSrc,
		inst.blendDst,
		inst.blendEquation,
		inst.depthFunc,
		inst.polygonOffsetFactor,
		inst.polygonOffsetUnits,
		inst.alphaTest,
		inst.overdraw,
		inst.blendSrcAlpha,
		inst.blendDstAlpha,
		inst.blendEquationAlpha,
		inst.transparent,
		inst.depthTest,
		inst.depthWrite,
		inst.colorWrite,
		inst.polygonOffset,
		inst.visible,
		inst.precision,
		inst.color,
		inst.map,
		inst.rotation,
		inst.fog];
}
200726
function (src, data, cb) {
    var texture;
    texture = new THREE.CanvasTexture(src);
    setTextureProperties(texture, data);
    cb(texture);
  }
456372
function(config,callback){
        spritesmith(config,function(error,result){
            if(error){
                gutil.log("[Error]",new gutil.PluginError(PLUGIN_NAME, error))
            }else{
                if(callback !== undefined){
                    var _resultPosition = result.coordinates;
                    fs.writeFileSync(_outSpriteName,result.image,"binary");
                    fs.move(_outSpriteName,_outSpritePath +"/"+ _outSpriteName,{clobber: true},function(err){
                        if(err){
                            gutil.log(gutil.colors.red("[Error]"),new gutil.PluginError(PLUGIN_NAME, err))
                        }else{
                            gutil.log(gutil.colors.green("[Successful]"),gutil.colors.yellow("[Done]:"+ _outSpriteName +" Create Successful"))
                        }
                    });
                    callback(_resultPosition);
                }else{
                    gutil.log("[Error] Create Sprite callback is required!");
                }
            }
        })
    }
393918
function getPropertyPathValue(obj, propertyPath) {
  var properties = Array.isArray(propertyPath) ? propertyPath : propertyPath.split(".");
  if (properties.length === 1) {
    return obj.getProperty(propertyPath);
  } else {
    var nextValue = obj;
    // hack use of some to perform mapFirst operation.
    properties.some(function (prop) {
      nextValue = nextValue.getProperty(prop);
      return nextValue == null;
    });
    return nextValue;
  }
}
535532
function LGraphFXGeneric() {
            this.addInput("Texture", "Texture");
            this.addInput("value1", "number");
            this.addInput("value2", "number");
            this.addOutput("Texture", "Texture");
            this.properties = {
                fx: "halftone",
                value1: 1,
                value2: 1,
                precision: LGraphTexture.DEFAULT
            };
        }
898354
function ( deformers, geometryMap, materialMap ) {

			sceneGraph = new THREE.Group();

			var modelMap = this.parseModels( deformers.skeletons, geometryMap, materialMap );

			var modelNodes = fbxTree.Objects.Model;

			var self = this;
			modelMap.forEach( function ( model ) {

				var modelNode = modelNodes[ model.ID ];
				self.setLookAtProperties( model, modelNode );

				var parentConnections = connections.get( model.ID ).parents;

				parentConnections.forEach( function ( connection ) {

					var parent = modelMap.get( connection.ID );
					if ( parent !== undefined ) parent.add( model );

				} );

				if ( model.parent === null ) {

					sceneGraph.add( model );

				}


			} );

			this.bindSkeleton( deformers.skeletons, geometryMap, modelMap );

			this.createAmbientLight();

			this.setupMorphMaterials();

			var animations = new AnimationParser().parse();

			// if all the models where already combined in a single group, just return that
			if ( sceneGraph.children.length === 1 && sceneGraph.children[ 0 ].isGroup ) {

				sceneGraph.children[ 0 ].animations = animations;
				sceneGraph = sceneGraph.children[ 0 ];

			}

			sceneGraph.animations = animations;

		}
909040
function getWorldPosition(obj) {
	obj.updateMatrixWorld();
	var vec = new THREE.Vector3();
	vec.setFromMatrixPosition(obj.matrixWorld);
	return vec;
}
605096
function processMaterial(material) {
      if (cachedData.materials.has(material)) {
        return cachedData.materials.get(material);
      }

      if (!outputJSON.materials) {
        outputJSON.materials = [];
      }

      if (material.isShaderMaterial) {
        console.warn('GLTFExporter: THREE.ShaderMaterial not supported.');
        return null;
      }

      // @QUESTION Should we avoid including any attribute that has the default value?
      var gltfMaterial = {
        pbrMetallicRoughness: {}
      };

      if (material.isMeshBasicMaterial) {
        gltfMaterial.extensions = { KHR_materials_unlit: {} };

        extensionsUsed['KHR_materials_unlit'] = true;
      } else if (!material.isMeshStandardMaterial) {
        console.warn(
          'GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.'
        );
      }

      // pbrMetallicRoughness.baseColorFactor
      var color = material.color.toArray().concat([material.opacity]);

      if (!equalArray(color, [1, 1, 1, 1])) {
        gltfMaterial.pbrMetallicRoughness.baseColorFactor = color;
      }

      if (material.isMeshStandardMaterial) {
        gltfMaterial.pbrMetallicRoughness.metallicFactor = material.metalness;
        gltfMaterial.pbrMetallicRoughness.roughnessFactor = material.roughness;
      } else if (material.isMeshBasicMaterial) {
        gltfMaterial.pbrMetallicRoughness.metallicFactor = 0.0;
        gltfMaterial.pbrMetallicRoughness.roughnessFactor = 0.9;
      } else {
        gltfMaterial.pbrMetallicRoughness.metallicFactor = 0.5;
        gltfMaterial.pbrMetallicRoughness.roughnessFactor = 0.5;
      }

      // pbrMetallicRoughness.metallicRoughnessTexture
      if (material.metalnessMap || material.roughnessMap) {
        if (material.metalnessMap === material.roughnessMap) {
          gltfMaterial.pbrMetallicRoughness.metallicRoughnessTexture = {
            index: processTexture(material.metalnessMap)
          };
        } else {
          console.warn(
            'THREE.GLTFExporter: Ignoring metalnessMap and roughnessMap because they are not the same Texture.'
          );
        }
      }

      // pbrMetallicRoughness.baseColorTexture
      if (material.map) {
        gltfMaterial.pbrMetallicRoughness.baseColorTexture = {
          index: processTexture(material.map)
        };
      }

      if (
        material.isMeshBasicMaterial ||
        material.isLineBasicMaterial ||
        material.isPointsMaterial
      ) {
      } else {
        // emissiveFactor
        var emissive = material.emissive
          .clone()
          .multiplyScalar(material.emissiveIntensity)
          .toArray();

        if (!equalArray(emissive, [0, 0, 0])) {
          gltfMaterial.emissiveFactor = emissive;
        }

        // emissiveTexture
        if (material.emissiveMap) {
          gltfMaterial.emissiveTexture = {
            index: processTexture(material.emissiveMap)
          };
        }
      }

      // normalTexture
      if (material.normalMap) {
        gltfMaterial.normalTexture = {
          index: processTexture(material.normalMap)
        };

        if (material.normalScale.x !== -1) {
          if (material.normalScale.x !== material.normalScale.y) {
            console.warn(
              'THREE.GLTFExporter: Normal scale components are different, ignoring Y and exporting X.'
            );
          }

          gltfMaterial.normalTexture.scale = material.normalScale.x;
        }
      }

      // occlusionTexture
      if (material.aoMap) {
        gltfMaterial.occlusionTexture = {
          index: processTexture(material.aoMap)
        };

        if (material.aoMapIntensity !== 1.0) {
          gltfMaterial.occlusionTexture.strength = material.aoMapIntensity;
        }
      }

      // alphaMode
      if (material.transparent || material.alphaTest > 0.0) {
        gltfMaterial.alphaMode = material.opacity < 1.0 ? 'BLEND' : 'MASK';

        // Write alphaCutoff if it's non-zero and different from the default (0.5).
        if (material.alphaTest > 0.0 && material.alphaTest !== 0.5) {
          gltfMaterial.alphaCutoff = material.alphaTest;
        }
      }

      // doubleSided
      if (material.side === THREE.DoubleSide) {
        gltfMaterial.doubleSided = true;
      }

      if (material.name !== '') {
        gltfMaterial.name = material.name;
      }

      if (Object.keys(material.userData).length > 0) {
        gltfMaterial.extras = serializeUserData(material);
      }

      outputJSON.materials.push(gltfMaterial);

      var index = outputJSON.materials.length - 1;
      cachedData.materials.set(material, index);

      return index;
    }
769701
function() {
		var sprites = this.sprites,
		    background = this.background;

		if ( this.inRenderScanline ) {
			if ( this.enabled ) {
				background.evaluate();
				sprites.evaluate();
			}

			if ( this.pixelInRange ) {
				if ( 
					this.pixelInRange &&
					sprites.sprite0InRange &&
					sprites.scanlineSprite0[ this.lineCycle - 1 ] &&
					!this.sprite0Hit
				) {
					this.sprite0Hit = !!background.scanlineColors[ this.lineCycle - 1 ];
				}
			}

			this.incrementRenderCycle();
		} else {
			this.incrementIdleCycle();
		}
	}
1161426
def attribute_result(cls, sprites):
        """"""
        retval = dict((x, True) for x in cls.ATTRIBUTES)
        for properties in sprites.values():
            for attribute, state in properties.items():
                retval[attribute] &= state != cls.STATE_MODIFIED
        return retval
283485
def _sprite(map, sprite, offset_x=None, offset_y=None):
    
    map = StringValue(map).value
    sprite_name = StringValue(sprite).value
    sprite_map = sprite_maps.get(map)
    sprite = sprite_map and sprite_map.get(sprite_name)
    if not sprite_map:
        log.error("No sprite map found: %s", map)
    elif not sprite:
        log.error("No sprite found: %s in %s", sprite_name, sprite_map['*n*'])
    if sprite:
        url = '%s%s?_=%s' % (ASSETS_URL, sprite_map['*f*'], sprite_map['*t*'])
        x = NumberValue(offset_x or 0, 'px')
        y = NumberValue(offset_y or 0, 'px')
        if not x or (x <= -1 or x >= 1) and x.unit != '%':
            x -= sprite[2]
        if not y or (y <= -1 or y >= 1) and y.unit != '%':
            y -= sprite[3]
        pos = "url(%s) %s %s" % (escape(url), x, y)
        return StringValue(pos)
    return StringValue('0 0')
311796
def sprite(map, sprite, offset_x=None, offset_y=None, cache_buster=True):
    
    map = map.render()
    sprite_maps = _get_cache('sprite_maps')
    sprite_map = sprite_maps.get(map)
    sprite_name = String.unquoted(sprite).value
    sprite = sprite_map and sprite_map.get(sprite_name)
    if not sprite_map:
        log.error("No sprite map found: %s", map, extra={'stack': True})
    elif not sprite:
        log.error("No sprite found: %s in %s", sprite_name, sprite_map['*n*'], extra={'stack': True})
    if sprite:
        url = '%s%s' % (config.ASSETS_URL, sprite_map['*f*'])
        if cache_buster:
            url += '?_=%s' % sprite_map['*t*']
        x = Number(offset_x or 0, 'px')
        y = Number(offset_y or 0, 'px')
        if not x.value or (x.value <= -1 or x.value >= 1) and not x.is_simple_unit('%'):
            x -= Number(sprite[2], 'px')
        if not y.value or (y.value <= -1 or y.value >= 1) and not y.is_simple_unit('%'):
            y -= Number(sprite[3], 'px')
        url = "url(%s)" % escape(url)
        return List([String.unquoted(url), x, y])
    return List([Number(0), Number(0)])
1149958
function (i, next) {
    // @todo We should add a property to define if the collisionEntity is dynamic or static
    // If static we should do the map just once, otherwise we're recreating the array in every
    // loop when aiming.
    var meshes;
    if (!this.data.collisionEntities) {
      meshes = this.defaultCollisionMeshes;
    } else {
      meshes = this.collisionEntities.map(function (entity) {
        return entity.getObject3D('mesh');
      }).filter(function (n) { return n; });
      meshes = meshes.length ? meshes : this.defaultCollisionMeshes;
    }

    var intersects = this.raycaster.intersectObjects(meshes, true);
    if (intersects.length > 0 && !this.hit &&
        this.isValidNormalsAngle(intersects[0].face.normal)) {
      var point = intersects[0].point;

      this.line.material.color.set(this.curveHitColor);
      this.line.material.opacity = this.data.hitOpacity;
      this.line.material.transparent= this.data.hitOpacity < 1;
      this.hitEntity.setAttribute('position', point);
      this.hitEntity.setAttribute('visible', true);

      this.hit = true;
      this.hitPoint.copy(intersects[0].point);

      // If hit, just fill the rest of the points with the hit point and break the loop
      for (var j = i; j < this.line.numPoints; j++) {
        this.line.setPoint(j, this.hitPoint);
      }
      return true;
    } else {
      this.line.setPoint(i, next);
      return false;
    }
  }
859394
function getter_THREE_Mesh(inst) {
	return [
		inst.name,
		inst.up,
		inst.position,
		inst.quaternion,
		inst.scale,
		inst.rotationAutoUpdate,
		inst.matrix,
		inst.matrixWorld,
		inst.matrixAutoUpdate,
		inst.visible,
		inst.castShadow,
		inst.receiveShadow,
		inst.frustumCulled,
		inst.renderOrder,
		inst.userData,
		inst.children,
		inst.geometry,
		inst.material,
		inst.materialTexture,
		inst.materialWireframe];
}
205021
function () {
    var config = this.config;
    var data = this.data;
    var el = this.el;
    var key;
    var from;
    var to;

    // Parse coordinates.
    from = data.from !== ''
      ? utils.coordinates.parse(data.from)  // If data.from defined, use that.
      : getComponentProperty(el, data.property);  // If data.from not defined, get on the fly.
    to = utils.coordinates.parse(data.to);

    if (data.property === PROP_ROTATION) {
      toRadians(from);
      toRadians(to);
    }

    // Set to and from.
    this.targetsArray.length = 0;
    this.targetsArray.push(from);
    config.targets = this.targetsArray;
    for (key in to) { config[key] = to[key]; }

    // If animating object3D transformation, run more optimized updater.
    if (data.property === PROP_POSITION || data.property === PROP_ROTATION ||
        data.property === PROP_SCALE) {
      config.update = (function () {
        var lastValue = {};
        return function (anim) {
          var value = anim.animatables[0].target;

          if (data.property === PROP_SCALE) {
            value.x = Math.max(0.0001, value.x);
            value.y = Math.max(0.0001, value.y);
            value.z = Math.max(0.0001, value.z);
          }

          // For animation timeline.
          if (value.x === lastValue.x &&
              value.y === lastValue.y &&
              value.z === lastValue.z) { return; }

          lastValue.x = value.x;
          lastValue.y = value.y;
          lastValue.z = value.z;

          el.object3D[data.property].set(value.x, value.y, value.z);
        };
      })();
      return;
    }

    // Animating some vector.
    config.update = (function () {
      var lastValue = {};
      return function (anim) {
        var value = anim.animatables[0].target;

        // Animate rotation through radians.
        // For animation timeline.
        if (value.x === lastValue.x &&
            value.y === lastValue.y &&
            value.z === lastValue.z) { return; }
        lastValue.x = value.x;
        lastValue.y = value.y;
        lastValue.z = value.z;
        setComponentProperty(el, data.property, value);
      };
    })();
  }
946151
function(elem) {
		// is this already initialized?
		if ($(elem).data('spriteanim')) return $(elem).data('spriteanim');
		var spriteanim = new SpriteAnim(elem);
		$(elem).data('spriteanim', spriteanim);

		return spriteanim;
	}
213385
function PBRSpecularGlossinessMaterial(name, scene) {
            var _this = _super.call(this, name, scene) || this;
            _this._useMicroSurfaceFromReflectivityMapAlpha = true;
            return _this;
        }