add some new tutorial JS files

Andrew Meadows committed 10 years ago

Commit 50117e21 parent 3a2cb3713 files · +1613 −0Browse files

Showing the changes to scripts/tutorials/entity_scripts (4 of 13 files). Show all

Unified · Split

4 files

scripts/tutorials/entity_scripts/flashlight.js +268 −0
scripts/tutorials/entity_scripts/golfClub.js +150 −0
scripts/tutorials/entity_scripts/pingPongGun.js +177 −0
scripts/tutorials/entity_scripts/soundMaker.js +28 −0

scripts/tutorials/entity_scripts/flashlight.js+268−0

@@ -0,0 +1,268 @@
	1	//
	2	// flashlight.js
	3	//
	4	// Script Type: Entity
	5	//
	6	// Created by Sam Gateau on 9/9/15.
	7	// Additions by James B. Pollack @imgntn on 9/21/2015
	8	// Copyright 2015 High Fidelity, Inc.
	9	//
	10	// This is a toy script that can be added to the Flashlight model entity:
	11	// "https://hifi-public.s3.amazonaws.com/models/props/flashlight.fbx"
	12	// that creates a spotlight attached with the flashlight model while the entity is grabbed
	13	//
	14	// Distributed under the Apache License, Version 2.0.
	15	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	16	//
	17
	18	(function() {
	19
	20	var ON_SOUND_URL = 'http://hifi-public.s3.amazonaws.com/sounds/Switches%20and%20sliders/flashlight_on.wav';
	21	var OFF_SOUND_URL = 'http://hifi-public.s3.amazonaws.com/sounds/Switches%20and%20sliders/flashlight_off.wav';
	22
	23	//we are creating lights that we don't want to get stranded so lets make sure that we can get rid of them
	24	//if you're going to be using this in a dungeon or something and holding it for a long time, increase this lifetime value.
	25	var LIFETIME = 100;
	26
	27
	28	// this is the "constructor" for the entity as a JS object we don't do much here, but we do want to remember
	29	// our this object, so we can access it in cases where we're called without a this (like in the case of various global signals)
	30	function Flashlight() {
	31	return;
	32	}
	33
	34	//if the trigger value goes below this while held, the flashlight will turn off. if it goes above, it will
	35	var DISABLE_LIGHT_THRESHOLD = 0.7;
	36
	37	// These constants define the Spotlight position and orientation relative to the model
	38	var MODEL_LIGHT_POSITION = {
	39	x: 0,
	40	y: -0.3,
	41	z: 0
	42	};
	43	var MODEL_LIGHT_ROTATION = Quat.angleAxis(-90, {
	44	x: 1,
	45	y: 0,
	46	z: 0
	47	});
	48
	49	//there's another small point light we put at the end of the flashlight to make the end glow
	50
	51	var GLOW_LIGHT_POSITION = {
	52	x: 0,
	53	y: -0.1,
	54	z: 0
	55	};
	56
	57	// Evaluate the world light entity positions and orientations from the model ones
	58	function evalLightWorldTransform(modelPosition, modelRotation) {
	59
	60	return {
	61	p: Vec3.sum(modelPosition, Vec3.multiplyQbyV(modelRotation, MODEL_LIGHT_POSITION)),
	62	q: Quat.multiply(modelRotation, MODEL_LIGHT_ROTATION)
	63	};
	64	}
	65
	66	function glowLightWorldTransform(modelPosition, modelRotation) {
	67	return {
	68	p: Vec3.sum(modelPosition, Vec3.multiplyQbyV(modelRotation, GLOW_LIGHT_POSITION)),
	69	q: Quat.multiply(modelRotation, MODEL_LIGHT_ROTATION)
	70	};
	71	}
	72
	73	Flashlight.prototype = {
	74	lightOn: false,
	75	hand: null,
	76	whichHand: null,
	77	hasSpotlight: false,
	78	spotlight: null,
	79
	80	startNearGrab: function(entityID, args) {
	81	//this first second parameter in this method contains arguments from the grab script, the first of which is the 'hand' that was used to start the grab
	82	this.hand = args[0];
	83	if (!this.hasSpotlight) {
	84
	85	var modelProperties = Entities.getEntityProperties(this.entityID, ['position', 'rotation']);
	86	var lightTransform = evalLightWorldTransform(modelProperties.position, modelProperties.rotation);
	87	var glowLightTransform = glowLightWorldTransform(modelProperties.position, modelProperties.rotation);
	88
	89
	90	//this light casts the beam
	91	this.spotlight = Entities.addEntity({
	92	type: "Light",
	93	isSpotlight: true,
	94	dimensions: {
	95	x: 2,
	96	y: 2,
	97	z: 20
	98	},
	99	parentID: this.entityID,
	100	color: {
	101	red: 255,
	102	green: 255,
	103	blue: 255
	104	},
	105	intensity: 1,
	106	falloffRadius:0.9,
	107	exponent: 0.5,
	108	cutoff: 20,
	109	lifetime: LIFETIME,
	110	position: lightTransform.p,
	111	rotation: lightTransform.q,
	112	});
	113
	114	//this light creates the effect of a bulb at the end of the flashlight
	115	this.glowLight = Entities.addEntity({
	116	type: "Light",
	117	dimensions: {
	118	x: 0.25,
	119	y: 0.25,
	120	z: 0.25
	121	},
	122	parentID: this.entityID,
	123	isSpotlight: false,
	124	color: {
	125	red: 255,
	126	green: 255,
	127	blue: 255
	128	},
	129	exponent: 0,
	130	intensity:1.0,
	131	falloffRadius:0.3,
	132	lifetime: LIFETIME,
	133	cutoff: 90, // in degrees
	134	position: glowLightTransform.p,
	135	rotation: glowLightTransform.q,
	136
	137	});
	138
	139	this.hasSpotlight = true;
	140
	141	}
	142
	143	},
	144	startEquip: function(id, params) {
	145	this.startNearGrab(id, params);
	146	},
	147
	148	setWhichHand: function() {
	149	this.whichHand = this.hand;
	150	},
	151
	152	continueNearGrab: function() {
	153	if (this.whichHand === null) {
	154	//only set the active hand once -- if we always read the current hand, our 'holding' hand will get overwritten
	155	this.setWhichHand();
	156	} else {
	157	this.changeLightWithTriggerPressure(this.whichHand);
	158	}
	159	},
	160	continueEquip: function(entityID, args) {
	161	this.continueNearGrab(entityID, args);
	162	},
	163
	164	releaseGrab: function(entityID, args) {
	165	//delete the lights and reset state
	166	if (this.hasSpotlight) {
	167	Entities.deleteEntity(this.spotlight);
	168	Entities.deleteEntity(this.glowLight);
	169	this.hasSpotlight = false;
	170	this.glowLight = null;
	171	this.spotlight = null;
	172	this.whichHand = null;
	173	this.lightOn = false;
	174	}
	175	},
	176
	177	releaseEquip: function(entityID, args) {
	178	this.releaseGrab(entityID, args);
	179	},
	180
	181	changeLightWithTriggerPressure: function(flashLightHand) {
	182	//read the value of the controller trigger and use it to turn the light on / off when the value reaches certain thresholds
	183	if (flashLightHand === 'LEFT') {
	184	this.triggerValue = Controller.getValue(Controller.Standard.LT);
	185	}
	186	if (flashLightHand === 'RIGHT') {
	187	this.triggerValue = Controller.getValue(Controller.Standard.RT);
	188
	189	}
	190
	191	if (this.triggerValue < DISABLE_LIGHT_THRESHOLD && this.lightOn === true) {
	192	this.turnLightOff();
	193	} else if (this.triggerValue >= DISABLE_LIGHT_THRESHOLD && this.lightOn === false) {
	194	this.turnLightOn();
	195	}
	196	return;
	197	},
	198
	199	turnLightOff: function() {
	200	this.playSoundAtCurrentPosition(false);
	201	Entities.editEntity(this.spotlight, {
	202	intensity: 0
	203	});
	204	Entities.editEntity(this.glowLight, {
	205	intensity: 0
	206	});
	207	this.lightOn = false;
	208	},
	209
	210	turnLightOn: function() {
	211	this.playSoundAtCurrentPosition(true);
	212
	213	Entities.editEntity(this.glowLight, {
	214	intensity: 2
	215	});
	216	Entities.editEntity(this.spotlight, {
	217	intensity: 2
	218	});
	219	this.lightOn = true;
	220	},
	221
	222	playSoundAtCurrentPosition: function(playOnSound) {
	223	//when someone grabs, play a clicking noise for turning the flashlight on/off
	224	var position = Entities.getEntityProperties(this.entityID, "position").position;
	225
	226	var audioProperties = {
	227	volume: 0.25,
	228	position: position
	229	};
	230
	231	if (playOnSound) {
	232	Audio.playSound(this.ON_SOUND, audioProperties);
	233	} else {
	234	Audio.playSound(this.OFF_SOUND, audioProperties);
	235	}
	236	},
	237
	238	preload: function(entityID) {
	239	// preload() will be called when the entity has become visible (or known) to the interface
	240	// it gives us a chance to set our local JavaScript object up. In this case it means:
	241	// * remembering our entityID, so we can access it in cases where we're called without an entityID
	242	// * preloading sounds
	243	this.entityID = entityID;
	244	this.ON_SOUND = SoundCache.getSound(ON_SOUND_URL);
	245	this.OFF_SOUND = SoundCache.getSound(OFF_SOUND_URL);
	246
	247	},
	248
	249	unload: function() {
	250	// unload() will be called when our entity is no longer available. It may be because we were deleted,
	251	// or because we've left the domain or quit the application.
	252	if (this.hasSpotlight) {
	253	Entities.deleteEntity(this.spotlight);
	254	Entities.deleteEntity(this.glowLight);
	255	this.hasSpotlight = false;
	256	this.glowLight = null;
	257	this.spotlight = null;
	258	this.whichHand = null;
	259	this.lightOn = false;
	260	}
	261
	262	},
	263
	264	};
	265
	266	// entity should return a newly constructed object of our type
	267	return new Flashlight();
	268	});

scripts/tutorials/entity_scripts/golfClub.js+150−0

@@ -0,0 +1,150 @@
	1	//
	2	// golfClub.js
	3	//
	4	// Created by Philip Rosedale on April 11, 2016.
	5	// Copyright 2016 High Fidelity, Inc.
	6	//
	7	//
	8	// Distributed under the Apache License, Version 2.0.
	9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	10	//
	11	// A simple golf club. If you have equipped it, and pull trigger, it will either make
	12	// you a new golf ball, or take you to your ball if one is not made.
	13
	14	(function() {
	15	var ball = null;
	16	var collisionSoundURL = "http://hifi-production.s3.amazonaws.com/tutorials/golfClub/collision1.wav";
	17	var triggerState = false;
	18	var BALL_GRAVITY = -9.8;
	19	var BALL_START_VELOCITY = 0.1;
	20	var BALL_MAX_RANGE = 10;
	21	var BALL_DROP_DISTANCE = 0.6;
	22	var BALL_DIAMETER = 0.07;
	23	var BALL_LIFETIME = 3600;
	24	var MAX_BRAKING_SPEED = 0.2;
	25	var BALL_BRAKING_RATE = 0.5;
	26
	27	var TRIGGER_CONTROLS = [
	28	Controller.Standard.LT,
	29	Controller.Standard.RT,
	30	];
	31
	32	function triggerPulled(hand) {
	33	// Return true if the trigger has just been pulled
	34	var triggerValue = Controller.getValue(TRIGGER_CONTROLS[hand]);
	35	var oldTriggerState = triggerState;
	36	var TRIGGER_PULL_THRESHOLD = 0.5;
	37	var TRIGGER_RELEASE_THRESHOLD = 0.4;
	38	if (triggerValue > TRIGGER_PULL_THRESHOLD) {
	39	triggerState = true;
	40	} else if (triggerValue < TRIGGER_RELEASE_THRESHOLD) {
	41	triggerState = false;
	42	}
	43	return (triggerState && (oldTriggerState != triggerState));
	44	}
	45
	46	function ballPosition(ball) {
	47	// return the position of this entity
	48	var properties = Entities.getEntityProperties(ball, ['position']);
	49	if (!properties) {
	50	return null;
	51	} else {
	52	return properties.position;
	53	}
	54	}
	55
	56	function gotoPointOnGround(position, away) {
	57	// Position yourself facing in the direction you were originally facing, but with a
	58	// point on the ground away meters from position and in front of you.
	59
	60	var offset = Quat.getFront(MyAvatar.orientation);
	61	offset.y = 0.0;
	62	offset = Vec3.multiply(-away, Vec3.normalize(offset));
	63	var newAvatarPosition = Vec3.sum(position, offset);
	64
	65	// Assuming position is on ground, put me distance from eyes to hips higher, plus a 50% adjust for longer legs.
	66	// TODO: Need avatar callback for exact foot-to-hips height.
	67
	68	var halfHeight = avatarHalfHeight();
	69	print("Height = " + halfHeight);
	70	newAvatarPosition.y += (halfHeight * 1.5);
	71	MyAvatar.position = newAvatarPosition;
	72	}
	73
	74	function inFrontOfMe() {
	75	return Vec3.sum(MyAvatar.position, Vec3.multiply(BALL_DROP_DISTANCE, Quat.getFront(MyAvatar.orientation)));
	76	}
	77
	78	function avatarHalfHeight() {
	79	return MyAvatar.getDefaultEyePosition().y - MyAvatar.position.y;
	80	}
	81
	82	function brakeBall(ball) {
	83	// Check the ball's velocity and slow it down if beyond a threshold
	84	var properties = Entities.getEntityProperties(ball, ['velocity']);
	85	if (properties) {
	86	var velocity = Vec3.length(properties.velocity);
	87	if ((velocity > 0) && (velocity < MAX_BRAKING_SPEED)) {
	88	Entities.editEntity(ball, {
	89	velocity: Vec3.multiply(BALL_BRAKING_RATE, properties.velocity)
	90	});
	91	}
	92	}
	93	}
	94
	95	function makeBall(position) {
	96	// Create a new sphere entity
	97	ball = Entities.addEntity({
	98	type: "Sphere",
	99	position: position,
	100	color: {
	101	red: 255,
	102	green: 255,
	103	blue: 255
	104	},
	105	dimensions: {
	106	x: BALL_DIAMETER,
	107	y: BALL_DIAMETER,
	108	z: BALL_DIAMETER
	109	},
	110	gravity: {
	111	x: 0,
	112	y: BALL_GRAVITY,
	113	z: 0
	114	},
	115	velocity: {
	116	x: 0,
	117	y: BALL_START_VELOCITY,
	118	z: 0
	119	},
	120	friction: 0.5,
	121	restitution: 0.5,
	122	shapeType: "sphere",
	123	dynamic: true,
	124	lifetime: BALL_LIFETIME,
	125	collisionSoundURL: collisionSoundURL
	126	});
	127	}
	128
	129	function checkClub(params) {
	130	var hand = params[0] == "left" ? 0 : 1;
	131	var makeNewBall = false;
	132	if (triggerPulled(hand)) {
	133	// If trigger just pulled, either drop new ball or go to existing one
	134	var position = ballPosition(ball);
	135	if (position && (Vec3.distance(MyAvatar.position, position) < BALL_MAX_RANGE)) {
	136	gotoPointOnGround(position, BALL_DROP_DISTANCE);
	137	} else {
	138	Entities.deleteEntity(ball);
	139	makeBall(inFrontOfMe());
	140	}
	141	}
	142	brakeBall(ball);
	143	}
	144
	145	this.continueEquip = function(id, params) {
	146	// While holding the club, continuously check for trigger pull and brake ball if moving.
	147	checkClub(params);
	148	}
	149
	150	});

scripts/tutorials/entity_scripts/pingPongGun.js+177−0

@@ -0,0 +1,177 @@
	1	// pingPongGun.js
	2	//
	3	// Script Type: Entity
	4	// Created by James B. Pollack @imgntn on 9/21/2015
	5	// Copyright 2015 High Fidelity, Inc.
	6	//
	7	// This script shoots a ping pong ball.
	8	// Distributed under the Apache License, Version 2.0.
	9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	10	//
	11
	12	(function() {
	13	var _this = this;
	14
	15	var SHOOTING_SOUND_URL = 'http://hifi-production.s3.amazonaws.com/tutorials/pingPongGun/pong_sound.wav';
	16
	17	function PingPongGun() {
	18	return;
	19	}
	20
	21	//if the trigger value goes below this value, reload the gun.
	22	var RELOAD_THRESHOLD = 0.95;
	23	var GUN_TIP_FWD_OFFSET = -0.6;
	24	var GUN_TIP_UP_OFFSET = 0.12;
	25	var GUN_FORCE = 9;
	26	var BALL_RESTITUTION = 0.6;
	27	var BALL_LINEAR_DAMPING = 0.4;
	28	var BALL_GRAVITY = {
	29	x: 0,
	30	y: -4.8,
	31	z: 0
	32	};
	33
	34	var PING_PONG_GUN_GRAVITY = {
	35	x: 0,
	36	y: -10,
	37	z: 0
	38	};
	39
	40	var BALL_DIMENSIONS = {
	41	x: 0.04,
	42	y: 0.04,
	43	z: 0.04
	44	};
	45
	46
	47	var BALL_COLOR = {
	48	red: 255,
	49	green: 255,
	50	blue: 255
	51	};
	52
	53	var TRIGGER_CONTROLS = [
	54	Controller.Standard.LT,
	55	Controller.Standard.RT,
	56	];
	57
	58
	59	PingPongGun.prototype = {
	60	hand: null,
	61	gunTipPosition: null,
	62	canShoot: false,
	63	canShootTimeout: null,
	64
	65	startEquip: function(entityID, args) {
	66	this.hand = args[0] == "left" ? 0 : 1;
	67	},
	68
	69	continueEquip: function(entityID, args) {
	70	if (this.canShootTimeout !== null) {
	71	Script.clearTimeout(this.canShootTimeout);
	72	}
	73	this.checkTriggerPressure(this.hand);
	74	},
	75
	76	releaseEquip: function(entityID, args) {
	77	var _this = this;
	78	this.canShootTimeout = Script.setTimeout(function() {
	79	_this.canShoot = false;
	80	}, 250);
	81	},
	82
	83	checkTriggerPressure: function(gunHand) {
	84	this.triggerValue = Controller.getValue(TRIGGER_CONTROLS[gunHand]);
	85	if (this.triggerValue < RELOAD_THRESHOLD) {
	86	this.canShoot = true;
	87	} else if (this.triggerValue >= RELOAD_THRESHOLD && this.canShoot === true) {
	88	var gunProperties = Entities.getEntityProperties(this.entityID, ["position", "rotation"]);
	89	this.shootBall(gunProperties);
	90	this.canShoot = false;
	91	}
	92
	93	return;
	94	},
	95
	96	shootBall: function(gunProperties) {
	97	var forwardVec = Quat.getFront(Quat.multiply(gunProperties.rotation, Quat.fromPitchYawRollDegrees(0, 180, 0)));
	98	forwardVec = Vec3.normalize(forwardVec);
	99	forwardVec = Vec3.multiply(forwardVec, GUN_FORCE);
	100
	101	var properties = {
	102	name: 'Tutorial Ping Pong Ball',
	103	shapeType: 'sphere',
	104	type: 'Sphere',
	105	color: BALL_COLOR,
	106	dimensions: BALL_DIMENSIONS,
	107	damping: BALL_LINEAR_DAMPING,
	108	gravity: BALL_GRAVITY,
	109	restitution: BALL_RESTITUTION,
	110	dynamic: true,
	111	rotation: gunProperties.rotation,
	112	position: this.getGunTipPosition(gunProperties),
	113	gravity: PING_PONG_GUN_GRAVITY,
	114	velocity: forwardVec,
	115	lifetime: 10
	116	};
	117
	118	Entities.addEntity(properties);
	119
	120	this.playSoundAtCurrentPosition(gunProperties.position);
	121	},
	122
	123	playSoundAtCurrentPosition: function(position) {
	124	var audioProperties = {
	125	volume: 0.2,
	126	position: position
	127	};
	128
	129	Audio.playSound(this.SHOOTING_SOUND, audioProperties);
	130	},
	131
	132	getGunTipPosition: function(properties) {
	133	//the tip of the gun is going to be in a different place than the center, so we move in space relative to the model to find that position
	134	var frontVector = Quat.getFront(properties.rotation);
	135	var frontOffset = Vec3.multiply(frontVector, GUN_TIP_FWD_OFFSET);
	136	var upVector = Quat.getUp(properties.rotation);
	137	var upOffset = Vec3.multiply(upVector, GUN_TIP_UP_OFFSET);
	138
	139	var gunTipPosition = Vec3.sum(properties.position, frontOffset);
	140	gunTipPosition = Vec3.sum(gunTipPosition, upOffset);
	141
	142	return gunTipPosition;
	143	},
	144
	145	preload: function(entityID) {
	146	this.entityID = entityID;
	147	this.SHOOTING_SOUND = SoundCache.getSound(SHOOTING_SOUND_URL);
	148	// this.createTipEntity(entityID);
	149	},
	150	createTipEntity: function(entityID) {
	151	//for debugging where its going to shoot from
	152	var gunProperties = Entities.getEntityProperties(entityID, ["position", "rotation"]);
	153
	154	var tipProps = {
	155	name: 'Ping pong tip test',
	156	dimensions: {
	157	x: 0.1,
	158	y: 0.1,
	159	z: 0.1
	160	},
	161	color: {
	162	red: 0,
	163	green: 255,
	164	blue: 0
	165	},
	166	type: 'Box',
	167	parentID: entityID,
	168	position: this.getGunTipPosition(gunProperties)
	169	};
	170	var tip = Entities.addEntity(tipProps);
	171	}
	172
	173	};
	174
	175	// entity scripts should return a newly constructed object of our type
	176	return new PingPongGun();
	177	});

scripts/tutorials/entity_scripts/soundMaker.js+28−0

@@ -0,0 +1,28 @@
	1	//
	2	// Copyright 2016 High Fidelity, Inc.
	3	//
	4	//
	5	// Distributed under the Apache License, Version 2.0.
	6	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	7	//
	8
	9	(function(){
	10
	11	var soundURL ='http://hifi-production.s3.amazonaws.com/tutorials/soundMaker/bell.wav';
	12	var ringSound;
	13
	14	this.preload = function(entityID) {
	15	print("preload("+entityID+")");
	16	ringSound = SoundCache.getSound(soundURL);
	17	};
	18
	19	this.clickDownOnEntity = function(entityID, mouseEvent) {
	20	var bellPosition = Entities.getEntityProperties(entityID).position;
	21	print("clickDownOnEntity()...");
	22	Audio.playSound(ringSound, {
	23	position: bellPosition,
	24	volume: 0.5
	25	});
	26	};
	27
	28	})