provide dragBounds via invisibleBarrierBoundsProperty, #98

Signed-off-by: Michael Kauzmann <michael.kauzmann@colorado.edu>

js/buoyancy/view/BoatView.ts

@@ -14,6 +14,7 @@ import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
 import Boat from '../model/Boat.js';
 import BoatDesign from '../model/BoatDesign.js';
 import DensityBuoyancyCommonConstants from '../../common/DensityBuoyancyCommonConstants.js';
+import Bounds3 from '../../../../dot/js/Bounds3.js';
 
 type BoatDrawingData = {
   backMiddleMaterial: THREE.MeshBasicMaterial;
@@ -28,10 +29,11 @@ export default class BoatView extends MassView {
 
   public readonly boat: Boat;
 
-  public constructor( boat: Boat, modelToViewPoint: ModelPoint3ToViewPoint2, liquidYInterpolatedProperty: TReadOnlyProperty<number> ) {
+  public constructor( boat: Boat, modelToViewPoint: ModelPoint3ToViewPoint2, dragBoundsProperty: TReadOnlyProperty<Bounds3>,
+                      liquidYInterpolatedProperty: TReadOnlyProperty<number> ) {
 
     // @ts-expect-error
-    super( boat, new THREE.Geometry(), modelToViewPoint );
+    super( boat, new THREE.Geometry(), modelToViewPoint, dragBoundsProperty );
 
     // Clip planes at the boat's water level
     const topBoatClipPlane = new THREE.Plane( new THREE.Vector3( 0, 1, 0 ), 0 );

js/buoyancy/view/BottleView.ts

@@ -10,6 +10,8 @@ import MassView, { ModelPoint3ToViewPoint2 } from '../../common/view/MassView.js
 import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
 import Bottle from '../model/Bottle.js';
 import Material from '../../common/model/Material.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
+import Bounds3 from '../../../../dot/js/Bounds3.js';
 
 type BottleDrawingData = {
   group: THREE.Group;
@@ -22,10 +24,11 @@ export default class BottleView extends MassView {
 
   public readonly bottle: Bottle;
 
-  public constructor( bottle: Bottle, modelToViewPoint: ModelPoint3ToViewPoint2 ) {
+  public constructor( bottle: Bottle, modelToViewPoint: ModelPoint3ToViewPoint2,
+                      dragBoundsProperty: TReadOnlyProperty<Bounds3> ) {
 
     // @ts-expect-error
-    super( bottle, new THREE.Geometry(), modelToViewPoint );
+    super( bottle, new THREE.Geometry(), modelToViewPoint, dragBoundsProperty );
 
     const bottomClipPlane = new THREE.Plane( new THREE.Vector3( 0, -1, 0 ), 0 );
     const topClipPlane = new THREE.Plane( new THREE.Vector3( 0, 1, 0 ), 0 );

js/common/view/ConeView.ts

@@ -12,6 +12,8 @@ import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
 import Cone from '../model/Cone.js';
 import MassView, { ModelPoint3ToViewPoint2 } from './MassView.js';
 import { TAG_OFFSET } from './MassTagView.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
+import Bounds3 from '../../../../dot/js/Bounds3.js';
 
 // constants
 const segments = 64;
@@ -23,7 +25,7 @@ export default class ConeView extends MassView {
   private readonly coneGeometry: THREE.BufferGeometry;
   private readonly updateListener: () => void;
 
-  public constructor( cone: Cone, modelToViewPoint: ModelPoint3ToViewPoint2 ) {
+  public constructor( cone: Cone, modelToViewPoint: ModelPoint3ToViewPoint2, dragBoundsProperty: TReadOnlyProperty<Bounds3> ) {
 
     const positionArray = new Float32Array( numElements * 3 );
     const normalArray = new Float32Array( numElements * 3 );
@@ -36,7 +38,7 @@ export default class ConeView extends MassView {
     coneGeometry.addAttribute( 'normal', new THREE.BufferAttribute( normalArray, 3 ) );
     coneGeometry.addAttribute( 'uv', new THREE.BufferAttribute( uvArray, 2 ) );
 
-    super( cone, coneGeometry, modelToViewPoint );
+    super( cone, coneGeometry, modelToViewPoint, dragBoundsProperty );
 
     this.cone = cone;
     this.coneGeometry = coneGeometry;

js/common/view/CuboidView.ts

@@ -13,6 +13,7 @@ import MassView, { ModelPoint3ToViewPoint2 } from './MassView.js';
 import Cuboid from '../model/Cuboid.js';
 import Bounds3 from '../../../../dot/js/Bounds3.js';
 import { TAG_OFFSET } from './MassTagView.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
 
 // constants
 const numElements = 18 * 3;
@@ -23,7 +24,7 @@ export default class CuboidView extends MassView {
   private readonly cuboidGeometry: THREE.BufferGeometry;
   private readonly updateListener: ( size: Bounds3 ) => void;
 
-  public constructor( cuboid: Cuboid, modelToViewPoint: ModelPoint3ToViewPoint2 ) {
+  public constructor( cuboid: Cuboid, modelToViewPoint: ModelPoint3ToViewPoint2, dragBoundsProperty: TReadOnlyProperty<Bounds3> ) {
     const size = cuboid.sizeProperty.value;
 
     const positionArray = new Float32Array( numElements * 3 );
@@ -37,7 +38,7 @@ export default class CuboidView extends MassView {
     cuboidGeometry.addAttribute( 'normal', new THREE.BufferAttribute( normalArray, 3 ) );
     cuboidGeometry.addAttribute( 'uv', new THREE.BufferAttribute( uvArray, 2 ) );
 
-    super( cuboid, cuboidGeometry, modelToViewPoint );
+    super( cuboid, cuboidGeometry, modelToViewPoint, dragBoundsProperty );
 
     this.cuboid = cuboid;
     this.cuboidGeometry = cuboidGeometry;

js/common/view/DensityBuoyancyScreenView.ts

@@ -619,28 +619,28 @@ export default class DensityBuoyancyScreenView<Model extends DensityBuoyancyMode
       let massView = null;
 
       if ( mass instanceof Cuboid ) {
-        massView = new CuboidView( mass, boundModelToViewPoint );
+        massView = new CuboidView( mass, boundModelToViewPoint, model.invisibleBarrierBoundsProperty );
       }
       else if ( mass instanceof Scale ) {
-        massView = new ScaleView( mass, boundModelToViewPoint );
+        massView = new ScaleView( mass, boundModelToViewPoint, model.invisibleBarrierBoundsProperty );
       }
       else if ( mass instanceof Cone ) {
-        massView = new ConeView( mass, boundModelToViewPoint );
+        massView = new ConeView( mass, boundModelToViewPoint, model.invisibleBarrierBoundsProperty );
       }
       else if ( mass instanceof Ellipsoid ) {
-        massView = new EllipsoidView( mass, boundModelToViewPoint );
+        massView = new EllipsoidView( mass, boundModelToViewPoint, model.invisibleBarrierBoundsProperty );
       }
       else if ( mass instanceof HorizontalCylinder ) {
-        massView = new HorizontalCylinderView( mass, boundModelToViewPoint );
+        massView = new HorizontalCylinderView( mass, boundModelToViewPoint, model.invisibleBarrierBoundsProperty );
       }
       else if ( mass instanceof VerticalCylinder ) {
-        massView = new VerticalCylinderView( mass, boundModelToViewPoint );
+        massView = new VerticalCylinderView( mass, boundModelToViewPoint, model.invisibleBarrierBoundsProperty );
       }
       else if ( mass instanceof Bottle ) {
-        massView = new BottleView( mass, boundModelToViewPoint );
+        massView = new BottleView( mass, boundModelToViewPoint, model.invisibleBarrierBoundsProperty );
       }
       else if ( mass instanceof Boat ) {
-        massView = new BoatView( mass, boundModelToViewPoint, model.pool.liquidYInterpolatedProperty );
+        massView = new BoatView( mass, boundModelToViewPoint, model.invisibleBarrierBoundsProperty, model.pool.liquidYInterpolatedProperty );
       }
 
       if ( massView ) {

js/common/view/EllipsoidView.ts

@@ -12,18 +12,19 @@ import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
 import Ellipsoid from '../model/Ellipsoid.js';
 import MassView, { ModelPoint3ToViewPoint2 } from './MassView.js';
 import { TAG_OFFSET } from './MassTagView.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
 
 export default class EllipsoidView extends MassView {
 
   public readonly ellipsoid: Ellipsoid;
   private readonly ellipsoidGeometry: THREE.SphereGeometry;
   private readonly updateListener: ( newSize: Bounds3, oldSize: Bounds3 ) => void;
 
-  public constructor( ellipsoid: Ellipsoid, modelToViewPoint: ModelPoint3ToViewPoint2 ) {
+  public constructor( ellipsoid: Ellipsoid, modelToViewPoint: ModelPoint3ToViewPoint2, dragBoundsProperty: TReadOnlyProperty<Bounds3> ) {
 
     const ellipsoidGeometry = new THREE.SphereGeometry( 1, 30, 24 );
 
-    super( ellipsoid, ellipsoidGeometry, modelToViewPoint );
+    super( ellipsoid, ellipsoidGeometry, modelToViewPoint, dragBoundsProperty );
 
     this.ellipsoid = ellipsoid;
     this.ellipsoidGeometry = ellipsoidGeometry;

js/common/view/HorizontalCylinderView.ts

@@ -12,6 +12,8 @@ import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
 import MassView, { ModelPoint3ToViewPoint2 } from './MassView.js';
 import HorizontalCylinder from '../model/HorizontalCylinder.js';
 import { TAG_OFFSET } from './MassTagView.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
+import Bounds3 from '../../../../dot/js/Bounds3.js';
 
 // constants
 const segments = 64;
@@ -23,7 +25,8 @@ export default class HorizontalCylinderView extends MassView {
   private readonly horizontalCylinderGeometry: THREE.BufferGeometry;
   private readonly updateListener: () => void;
 
-  public constructor( horizontalCylinder: HorizontalCylinder, modelToViewPoint: ModelPoint3ToViewPoint2 ) {
+  public constructor( horizontalCylinder: HorizontalCylinder, modelToViewPoint: ModelPoint3ToViewPoint2,
+                      dragBoundsProperty: TReadOnlyProperty<Bounds3> ) {
 
     const positionArray = new Float32Array( numElements * 3 );
     const normalArray = new Float32Array( numElements * 3 );
@@ -36,7 +39,7 @@ export default class HorizontalCylinderView extends MassView {
     horizontalCylinderGeometry.addAttribute( 'normal', new THREE.BufferAttribute( normalArray, 3 ) );
     horizontalCylinderGeometry.addAttribute( 'uv', new THREE.BufferAttribute( uvArray, 2 ) );
 
-    super( horizontalCylinder, horizontalCylinderGeometry, modelToViewPoint );
+    super( horizontalCylinder, horizontalCylinderGeometry, modelToViewPoint, dragBoundsProperty );
 
     const positionTag = () => {
       const radius = horizontalCylinder.radiusProperty.value;

js/common/view/MassView.ts

@@ -19,6 +19,10 @@ import MassTagView from './MassTagView.js';
 import ConvexHull2 from '../../../../dot/js/ConvexHull2.js';
 import Vector2 from '../../../../dot/js/Vector2.js';
 import ModelViewTransform2 from '../../../../phetcommon/js/view/ModelViewTransform2.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
+import Bounds3 from '../../../../dot/js/Bounds3.js';
+import MappedProperty from '../../../../axon/js/MappedProperty.js';
+import Bounds2 from '../../../../dot/js/Bounds2.js';
 
 export type ModelPoint3ToViewPoint2 = ( point: Vector3 ) => Vector2;
 
@@ -36,7 +40,8 @@ export default abstract class MassView extends THREE.Mesh {
 
   public readonly focusablePath: Path | null;
 
-  protected constructor( mass: Mass, initialGeometry: THREE.BufferGeometry, modelToViewPoint: ModelPoint3ToViewPoint2 ) {
+  protected constructor( mass: Mass, initialGeometry: THREE.BufferGeometry, modelToViewPoint: ModelPoint3ToViewPoint2,
+                         dragBoundsProperty: TReadOnlyProperty<Bounds3> ) {
     const materialView = DensityMaterials.getMaterialView( mass.materialProperty.value );
 
     super( initialGeometry, materialView.material );
@@ -118,6 +123,7 @@ export default abstract class MassView extends THREE.Mesh {
 
         // This is needed for keyboard but not for mouse/touch because keyboard input applies deltas, not absolute positions
         transform: INVERT_Y_TRANSFORM,
+        dragBoundsProperty: new MappedProperty( dragBoundsProperty, { map: bounds3 => Bounds2.create( bounds3 ) } ),
         drag: ( vectorDelta: Vector2 ) => {
           mass.updateDrag( mass.matrix.translation.add( vectorDelta ) );
         }

js/common/view/ScaleView.ts

@@ -12,16 +12,18 @@ import Scale from '../model/Scale.js';
 import CuboidView from './CuboidView.js';
 import MassView, { ModelPoint3ToViewPoint2 } from './MassView.js';
 import VerticalCylinderView from './VerticalCylinderView.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
+import Bounds3 from '../../../../dot/js/Bounds3.js';
 
 export default class ScaleView extends MassView {
 
   private readonly scaleGeometry: THREE.BufferGeometry;
 
-  public constructor( mass: Scale, modelToViewPoint: ModelPoint3ToViewPoint2 ) {
+  public constructor( mass: Scale, modelToViewPoint: ModelPoint3ToViewPoint2, dragBoundsProperty: TReadOnlyProperty<Bounds3> ) {
 
     const scaleGeometry = ScaleView.getScaleGeometry();
 
-    super( mass, scaleGeometry, modelToViewPoint );
+    super( mass, scaleGeometry, modelToViewPoint, dragBoundsProperty );
 
     this.scaleGeometry = scaleGeometry;
   }

js/common/view/VerticalCylinderView.ts

@@ -12,6 +12,8 @@ import densityBuoyancyCommon from '../../densityBuoyancyCommon.js';
 import VerticalCylinder from '../model/VerticalCylinder.js';
 import MassView, { ModelPoint3ToViewPoint2 } from './MassView.js';
 import { TAG_OFFSET } from './MassTagView.js';
+import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
+import Bounds3 from '../../../../dot/js/Bounds3.js';
 
 // constants
 const segments = 64;
@@ -23,7 +25,8 @@ export default class VerticalCylinderView extends MassView {
   private readonly verticalCylinderGeometry: THREE.BufferGeometry;
   private readonly updateListener: () => void;
 
-  public constructor( verticalCylinder: VerticalCylinder, modelToViewPoint: ModelPoint3ToViewPoint2 ) {
+  public constructor( verticalCylinder: VerticalCylinder, modelToViewPoint: ModelPoint3ToViewPoint2,
+                      dragBoundsProperty: TReadOnlyProperty<Bounds3> ) {
 
     const positionArray = new Float32Array( numElements * 3 );
     const normalArray = new Float32Array( numElements * 3 );
@@ -36,7 +39,7 @@ export default class VerticalCylinderView extends MassView {
     verticalCylinderGeometry.addAttribute( 'normal', new THREE.BufferAttribute( normalArray, 3 ) );
     verticalCylinderGeometry.addAttribute( 'uv', new THREE.BufferAttribute( uvArray, 2 ) );
 
-    super( verticalCylinder, verticalCylinderGeometry, modelToViewPoint );
+    super( verticalCylinder, verticalCylinderGeometry, modelToViewPoint, dragBoundsProperty );
 
     const positionTag = () => {
       const radius = verticalCylinder.radiusProperty.value;