AgustinVallejo
commented
1 month ago This was quite a challenge, and I will describe my findings in this comment. And afterwards, the preliminary patch of these changes.
- @jonathanolson suggested we look into the implementation of
LonePairGeometryData.jswhich in a way imports geometry data from a file calledballoon2.obj(multiple files but that's not important). - That file was converted into a JSON object via a python script from Three.js release 85. I tried to use it but it's in Python 2 and I didn't think it was worth it to downgrade my python version for this.
- In three.js-r86 they deprecated that python script and replaced it for the
obj2three.jsnode script. That one was also eventually deprecated and the current way of doing this is quite different, but by downloading r86 and running that script we got it to work. Not great, but not terrible. (commit above updatesballoon2-README.txtand links to this issue) - From then on it was a matter of adding the json into DuckData and playing around with DuckView. We're not including duck files in this patch since they are quite heavy and we want to settle for a definite shape before uploading unnecessarily.
The following patch sloppily implements this, without the actual duck geometry. We still have to figure out how to get the physics body vertices working, as well as the transverse area (projection?). @zepumph and I are on this.
```diff
Subject: [PATCH] Initial Duck go
---
Index: js/buoyancy/view/DuckView.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/js/buoyancy/view/DuckView.ts b/js/buoyancy/view/DuckView.ts
new file mode 100644
--- /dev/null (date 1710963085166)
+++ b/js/buoyancy/view/DuckView.ts (date 1710963085166)
@@ -0,0 +1,45 @@
+// Copyright 2019-2024, University of Colorado Boulder
+
+/**
+ * The 3D view for a Duck.
+ *
+ * @author Agustín Vallejo
+ * @author Michael Kauzman
+ */
+
+import Bounds3 from '../../../../dot/js/Bounds3.js';
+import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
+import MassView, { ModelPoint3ToViewPoint2 } from '../../common/view/MassView.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
+import Duck, { mainDuckGeometry } from '../model/Duck.js';
+
+export default class DuckView extends MassView {
+
+ public readonly duck: Duck;
+ private readonly duckGeometry: THREE.SphereGeometry;
+
+ // private readonly updateListener: ( newSize: Bounds3, oldSize: Bounds3 ) => void;
+
+ public constructor( duck: Duck, modelToViewPoint: ModelPoint3ToViewPoint2, dragBoundsProperty: TReadOnlyProperty ) {
+
+ const duckGeometry = mainDuckGeometry.children[ 0 ].geometry;
+
+ super( duck, duckGeometry, modelToViewPoint, dragBoundsProperty );
+
+ this.duck = duck;
+ this.duckGeometry = duckGeometry;
+ this.duckGeometry.scale( 0.1, 0.1, 0.1 );
+ }
+
+ /**
+ * Releases references.
+ */
+ public override dispose(): void {
+ this.duck.sizeProperty.unlink( this.updateListener );
+ this.duckGeometry.dispose();
+
+ super.dispose();
+ }
+}
+
+densityBuoyancyCommon.register( 'DuckView', DuckView );
Index: js/common/data/DuckData.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/js/common/data/DuckData.ts b/js/common/data/DuckData.ts
new file mode 100644
--- /dev/null (date 1710963127371)
+++ b/js/common/data/DuckData.ts (date 1710963127371)
@@ -0,0 +1,15 @@
+// Copyright 2024, University of Colorado Boulder
+/**
+ * DuckData modeled in blender by PhET, exported to .obj, and converted to THREE.js data using
+ * The obj2three.js script in three.js-r86/utils/converters/obj2three.js
+ *
+ * @author Agustín Vallejo (PhET Interactive Simulations)
+ * @author Michael Kauzmann (PhET Interactive Simulations)
+ */
+
+import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
+
+const DuckData = {}; // eslint-disable-line
+
+densityBuoyancyCommon.register( 'DuckData', DuckData );
+export default DuckData;
\ No newline at end of file
Index: js/buoyancy/model/BuoyancyShapesModel.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/js/buoyancy/model/BuoyancyShapesModel.ts b/js/buoyancy/model/BuoyancyShapesModel.ts
--- a/js/buoyancy/model/BuoyancyShapesModel.ts (revision 9f2a384d8fd424d7cd0d7e04019225bd21a32ec6)
+++ b/js/buoyancy/model/BuoyancyShapesModel.ts (date 1710881257946)
@@ -30,6 +30,7 @@
import TProperty from '../../../../axon/js/TProperty.js';
import isSettingPhetioStateProperty from '../../../../tandem/js/isSettingPhetioStateProperty.js';
import MassTag from '../../common/model/MassTag.js';
+import Duck from './Duck.js';
export type BuoyancyShapesModelOptions = DensityBuoyancyModelOptions;
@@ -82,7 +83,7 @@
} );
this.availableMasses.push( this.scale1 );
- this.primaryShapeProperty = new EnumerationProperty( MassShape.BLOCK, {
+ this.primaryShapeProperty = new EnumerationProperty( MassShape.DUCK, {
tandem: tandem.createTandem( 'primaryShapeProperty' )
} );
this.secondaryShapeProperty = new EnumerationProperty( MassShape.INVERTED_CONE, {
@@ -143,6 +144,9 @@
false,
massOptions
);
+ break;
+ case MassShape.DUCK:
+ mass = new Duck( this.engine, Duck.getSizeFromRatios( widthRatio, heightRatio ), massOptions );
break;
default:
throw new Error( `shape not recognized: ${shape}` );
Index: js/common/view/DensityBuoyancyScreenView.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/js/common/view/DensityBuoyancyScreenView.ts b/js/common/view/DensityBuoyancyScreenView.ts
--- a/js/common/view/DensityBuoyancyScreenView.ts (revision 9f2a384d8fd424d7cd0d7e04019225bd21a32ec6)
+++ b/js/common/view/DensityBuoyancyScreenView.ts (date 1710882121252)
@@ -66,6 +66,8 @@
import { PhetioObjectOptions } from '../../../../tandem/js/PhetioObject.js';
import grabSoundPlayer from '../../../../tambo/js/shared-sound-players/grabSoundPlayer.js';
import releaseSoundPlayer from '../../../../tambo/js/shared-sound-players/releaseSoundPlayer.js';
+import DuckView from '../../buoyancy/view/DuckView.js';
+import Duck from '../../buoyancy/model/Duck.js';
// constants
const MARGIN = DensityBuoyancyCommonConstants.MARGIN;
@@ -643,6 +645,9 @@
else if ( mass instanceof Boat ) {
massView = new BoatView( mass, boundModelToViewPoint, dragBoundsProperty, model.pool.liquidYInterpolatedProperty );
}
+ else if ( mass instanceof Duck ) {
+ massView = new DuckView( mass, boundModelToViewPoint, dragBoundsProperty );
+ }
if ( massView ) {
this.sceneNode.stage.threeScene.add( massView );
Index: js/common/model/MassShape.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/js/common/model/MassShape.ts b/js/common/model/MassShape.ts
--- a/js/common/model/MassShape.ts (revision 9f2a384d8fd424d7cd0d7e04019225bd21a32ec6)
+++ b/js/common/model/MassShape.ts (date 1710794800371)
@@ -17,6 +17,7 @@
public static readonly HORIZONTAL_CYLINDER = new MassShape();
public static readonly CONE = new MassShape();
public static readonly INVERTED_CONE = new MassShape();
+ public static readonly DUCK = new MassShape();
public static readonly enumeration = new Enumeration( MassShape, {
phetioDocumentation: 'Shape of the mass'
Index: js/buoyancy/view/ShapeSizeControlNode.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/js/buoyancy/view/ShapeSizeControlNode.ts b/js/buoyancy/view/ShapeSizeControlNode.ts
--- a/js/buoyancy/view/ShapeSizeControlNode.ts (revision 9f2a384d8fd424d7cd0d7e04019225bd21a32ec6)
+++ b/js/buoyancy/view/ShapeSizeControlNode.ts (date 1710798129746)
@@ -21,6 +21,7 @@
import { MassShape } from '../../common/model/MassShape.js';
import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
import DensityBuoyancyCommonStrings from '../../DensityBuoyancyCommonStrings.js';
+import StringProperty from '../../../../axon/js/StringProperty.js';
// constants
const shapeStringMap = {
@@ -29,7 +30,8 @@
[ MassShape.VERTICAL_CYLINDER.name ]: DensityBuoyancyCommonStrings.shape.verticalCylinderStringProperty,
[ MassShape.HORIZONTAL_CYLINDER.name ]: DensityBuoyancyCommonStrings.shape.horizontalCylinderStringProperty,
[ MassShape.CONE.name ]: DensityBuoyancyCommonStrings.shape.coneStringProperty,
- [ MassShape.INVERTED_CONE.name ]: DensityBuoyancyCommonStrings.shape.invertedConeStringProperty
+ [ MassShape.INVERTED_CONE.name ]: DensityBuoyancyCommonStrings.shape.invertedConeStringProperty,
+ [ MassShape.DUCK.name ]: new StringProperty( 'Duck' )
};
// TODO: this should come from somewhere else, https://github.com/phetsims/buoyancy/issues/90
const tandemNameMap = {
@@ -38,7 +40,8 @@
[ MassShape.VERTICAL_CYLINDER.name ]: 'verticalCylinder',
[ MassShape.HORIZONTAL_CYLINDER.name ]: 'horizontalCylinder',
[ MassShape.CONE.name ]: 'cone',
- [ MassShape.INVERTED_CONE.name ]: 'invertedCone'
+ [ MassShape.INVERTED_CONE.name ]: 'invertedCone',
+ [ MassShape.DUCK.name ]: 'duck'
};
type SelfOptions = {
Index: js/buoyancy/model/Duck.ts
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/js/buoyancy/model/Duck.ts b/js/buoyancy/model/Duck.ts
new file mode 100644
--- /dev/null (date 1710963085207)
+++ b/js/buoyancy/model/Duck.ts (date 1710963085207)
@@ -0,0 +1,248 @@
+// Copyright 2019-2024, University of Colorado Boulder
+
+/**
+ * An adjustable Duck
+ *
+ * @author Agustín Vallejo (PhET Interactive Simulations)
+ * @author Michael Kauzmann (PhET Interactive Simulations)
+ */
+
+import Property from '../../../../axon/js/Property.js';
+import StrictOmit from '../../../../phet-core/js/types/StrictOmit.js';
+import Bounds3 from '../../../../dot/js/Bounds3.js';
+import Ray3 from '../../../../dot/js/Ray3.js';
+import Utils from '../../../../dot/js/Utils.js';
+import Vector2 from '../../../../dot/js/Vector2.js';
+import Vector3 from '../../../../dot/js/Vector3.js';
+import { Shape } from '../../../../kite/js/imports.js';
+import optionize, { EmptySelfOptions } from '../../../../phet-core/js/optionize.js';
+import IOType from '../../../../tandem/js/types/IOType.js';
+import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
+import Mass, { InstrumentedMassOptions, MASS_MAX_SHAPES_DIMENSION, MASS_MIN_SHAPES_DIMENSION } from '../../common/model/Mass.js';
+import PhysicsEngine from '../../common/model/PhysicsEngine.js';
+import { MassShape } from '../../common/model/MassShape.js';
+import DuckData from '../../common/data/DuckData.js';
+
+export type DuckOptions = StrictOmit;
+
+const loader = new THREE.ObjectLoader();
+
+export const mainDuckGeometry = loader.parse( DuckData );
+
+const VERTICES = _.chunk( mainDuckGeometry.children[0].geometry.getAttribute('position').array, 3).map( vert3 => {
+ return new Vector2( vert3[0], vert3[2] );
+} );
+
+export default class Duck extends Mass {
+
+ public readonly sizeProperty: Property;
+
+ // Step information
+ public stepMaximumArea: number;
+ public stepMaximumVolume: number;
+
+ public constructor( engine: PhysicsEngine, size: Bounds3, providedConfig: DuckOptions ) {
+
+ const config = optionize()( {
+ body: engine.createFromVertices( Duck.getDuckVertices( size.width, size.height ), false ),
+ shape: Duck.getDuckShape( size.width, size.height ),
+ volume: Duck.getVolume( size ),
+ massShape: MassShape.DUCK,
+
+ phetioType: Duck.DuckIO
+ }, providedConfig );
+
+ assert && assert( !config.canRotate );
+
+ super( engine, config as InstrumentedMassOptions );
+
+ this.sizeProperty = new Property( size, {
+ valueType: Bounds3,
+ tandem: config.tandem.createTandem( 'sizeProperty' ),
+ phetioValueType: Bounds3.Bounds3IO
+ } );
+
+ this.stepMaximumArea = 0;
+ this.stepMaximumVolume = 0;
+
+ this.updateSize( size );
+ }
+
+ public override getLocalBounds(): Bounds3 {
+ return this.sizeProperty.value;
+ }
+
+ /**
+ * Updates the size of the duck.
+ */
+ public updateSize( size: Bounds3 ): void {
+ this.engine.updateFromVertices( this.body, Duck.getDuckVertices( size.width, size.height ), false );
+ this.sizeProperty.value = size;
+ this.shapeProperty.value = Duck.getDuckShape( size.width, size.height );
+
+ this.volumeLock = true;
+ this.volumeProperty.value = Duck.getVolume( size );
+ this.volumeLock = false;
+
+ this.forceOffsetProperty.value = new Vector3( 0, 0, size.maxZ );
+ this.massLabelOffsetProperty.value = new Vector3( 0, size.minY * 0.5, size.maxZ * 0.7 );
+ }
+
+ /**
+ * Returns the general size of the mass based on a general size scale.
+ */
+ public static getSizeFromRatios( widthRatio: number, heightRatio: number ): Bounds3 {
+ const x = ( MASS_MIN_SHAPES_DIMENSION + widthRatio * ( MASS_MAX_SHAPES_DIMENSION - MASS_MIN_SHAPES_DIMENSION ) ) / 2;
+ const y = ( MASS_MIN_SHAPES_DIMENSION + heightRatio * ( MASS_MAX_SHAPES_DIMENSION - MASS_MIN_SHAPES_DIMENSION ) ) / 2;
+ return new Bounds3( -x, -y, -x, x, y, x );
+ }
+
+ /**
+ * Sets the general size of the mass based on a general size scale.
+ */
+ public setRatios( widthRatio: number, heightRatio: number ): void {
+ this.updateSize( Duck.getSizeFromRatios( widthRatio, heightRatio ) );
+ }
+
+ /**
+ * Called after a engine-physics-model step once before doing other operations (like computing buoyant forces,
+ * displacement, etc.) so that it can set high-performance flags used for this purpose.
+ *
+ * Type-specific values are likely to be set, but this should set at least stepX/stepBottom/stepTop
+ */
+ public override updateStepInformation(): void {
+ super.updateStepInformation();
+
+ const xOffset = this.stepMatrix.m02();
+ const yOffset = this.stepMatrix.m12();
+
+ this.stepX = xOffset;
+ this.stepBottom = yOffset + this.sizeProperty.value.minY;
+ this.stepTop = yOffset + this.sizeProperty.value.maxY;
+
+ const a = this.sizeProperty.value.width / 2;
+ const b = this.sizeProperty.value.height / 2;
+ const c = this.sizeProperty.value.depth / 2;
+ this.stepMaximumArea = 4 * Math.PI * a * c; // 4 * pi * a * c
+ this.stepMaximumVolume = this.stepMaximumArea * b / 3; // 4/3 * pi * a * b * c
+ }
+
+ /**
+ * If there is an intersection with the ray and this mass, the t-value (distance the ray would need to travel to
+ * reach the intersection, e.g. ray.position + ray.distance * t === intersectionPoint) will be returned. Otherwise
+ * if there is no intersection, null will be returned.
+ */
+ public override intersect( ray: Ray3, isTouch: boolean ): number | null {
+ const translation = this.matrix.getTranslation().toVector3();
+ const size = this.sizeProperty.value;
+ const relativePosition = ray.position.minusXYZ( translation.x, translation.y, translation.z );
+
+ const xp = 4 / ( size.width * size.width );
+ const yp = 4 / ( size.height * size.height );
+ const zp = 4 / ( size.depth * size.depth );
+
+ const a = xp * ray.direction.x * ray.direction.x + yp * ray.direction.y * ray.direction.y + zp * ray.direction.z * ray.direction.z;
+ const b = 2 * ( xp * relativePosition.x * ray.direction.x + yp * relativePosition.y * ray.direction.y + zp * relativePosition.z * ray.direction.z );
+ const c = -1 + xp * relativePosition.x * relativePosition.x + yp * relativePosition.y * relativePosition.y + zp * relativePosition.z * relativePosition.z;
+
+ const tValues = Utils.solveQuadraticRootsReal( a, b, c )!.filter( t => t > 0 );
+
+ if ( tValues.length ) {
+ return tValues[ 0 ];
+ }
+ else {
+ return null;
+ }
+ }
+
+ /**
+ * Returns the cumulative displaced volume of this object up to a given y level.
+ *
+ * Assumes step information was updated.
+ */
+ public getDisplacedArea( liquidLevel: number ): number {
+ if ( liquidLevel < this.stepBottom || liquidLevel > this.stepTop ) {
+ return 0;
+ }
+ else {
+ const ratio = ( liquidLevel - this.stepBottom ) / ( this.stepTop - this.stepBottom );
+
+ return 0.1; // 4 * pi * a * c * ( t - t^2 )
+ }
+ }
+
+ /**
+ * Returns the displaced volume of this object up to a given y level, assuming a y value for the given liquid level.
+ *
+ * Assumes step information was updated.
+ */
+ public getDisplacedVolume( liquidLevel: number ): number {
+ if ( liquidLevel <= this.stepBottom ) {
+ return 0;
+ }
+ else if ( liquidLevel >= this.stepTop ) {
+ return this.stepMaximumVolume;
+ }
+ else {
+ const ratio = ( liquidLevel - this.stepBottom ) / ( this.stepTop - this.stepBottom );
+
+ return this.stepMaximumVolume * ratio * ratio * ( 3 - 2 * ratio ); // 4/3 * pi * a * b * c * t^2 * ( 3 - 2t )
+ }
+ }
+
+ /**
+ * Resets things to their original values.
+ */
+ public override reset(): void {
+ this.sizeProperty.reset();
+ this.updateSize( this.sizeProperty.value );
+
+ super.reset();
+ }
+
+ /**
+ * Releases references
+ */
+ public override dispose(): void {
+ this.sizeProperty.dispose();
+
+ super.dispose();
+ }
+
+ /**
+ * Returns a duck shape
+ */
+ public static getDuckShape( width: number, height: number ): Shape {
+ return Shape.circle( Vector2.ZERO, height / 2 );
+ }
+
+ /**
+ * Returns vertices for a duck
+ */
+ public static getDuckVertices( width: number, height: number ): Vector2[] {
+
+ // a square
+ const vertices = [
+ new Vector2( -width / 2, -height / 2 ),
+ new Vector2( width / 2, -height / 2 ),
+ new Vector2( width / 2, height / 2 ),
+ new Vector2( -width / 2, height / 2 )
+ ];
+ return vertices;
+ }
+
+ /**
+ * Returns the volume of a duck with the given axis-aligned bounding box.
+ */
+ public static getVolume( size: Bounds3 ): number {
+ return Math.PI * size.width * size.height * size.depth / 6;
+ }
+
+ public static DuckIO = new IOType( 'DuckIO', {
+ valueType: Duck,
+ supertype: Mass.MassIO,
+ documentation: 'Represents a duck'
+ } );
+}
+
+densityBuoyancyCommon.register( 'Duck', Duck );
zepumph
pixelzoom
DianaTavares
From the design meeting today, we humored the idea of having an extra, irregular shape on the shapes screen. A duck seems like an obvious choice, but we will want to do some investigation to see how hard it would be. @AgustinVallejo mentioned that he knows enough about blender that it isn't automatically out of the question to use our own custom mesh for this.