Source: core/sceneObjs/glass/CircleGlass.js

  1. /*
  2.  * Copyright 2024 The Ray Optics Simulation authors and contributors
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *     http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  17. import BaseGlass from '../BaseGlass.js';
  18. import CircleObjMixin from '../CircleObjMixin.js';
  19. import i18next from 'i18next';
  20. import geometry from '../../geometry.js';
  22. /**
  23.  * Glass of the shape of a circle.
  24.  * 
  25.  * Tools -> Glass -> Circle
  26.  * @class
  27.  * @extends BaseGlass
  28.  * @memberof sceneObjs
  29.  * @property {Point} p1 - The center of the circle.
  30.  * @property {Point} p2 - A point on the boundary of the circle.
  31.  * @property {number} refIndex - The refractive index of the glass, or the Cauchy coefficient A of the glass if "Simulate Colors" is on.
  32.  * @property {number} cauchyB - The Cauchy coefficient B of the glass if "Simulate Colors" is on, in micrometer squared.
  33.  */
  34. class CircleGlass extends CircleObjMixin(BaseGlass) {
  35.   static type = 'CircleGlass';
  36.   static isOptical = true;
  37.   static supportsSurfaceMerging = true;
  38.   static serializableDefaults = {
  39.     p1: null,
  40.     p2: null,
  41.     refIndex: 1.5,
  42.     cauchyB: 0.004
  43.   };
  45.   populateObjBar(objBar) {
  46.     objBar.setTitle(i18next.t('main:meta.parentheses', { main: i18next.t('main:tools.categories.glass'), sub: i18next.t('main:tools.CircleGlass.title') }));
  47.     super.populateObjBar(objBar);
  48.   }
  50.   draw(canvasRenderer, isAboveLight, isHovered) {
  51.     const ctx = canvasRenderer.ctx;
  52.     const ls = canvasRenderer.lengthScale;
  54.     ctx.beginPath();
  55.     ctx.arc(this.p1.x, this.p1.y, geometry.segmentLength(this), 0, Math.PI * 2, false);
  56.     this.fillGlass(canvasRenderer, isAboveLight, isHovered);
  57.     ctx.lineWidth = 1;
  58.     ctx.fillStyle = 'red';
  59.     ctx.fillRect(this.p1.x - 1.5 * ls, this.p1.y - 1.5 * ls, 3 * ls, 3 * ls);
  60.     if (isHovered) {
  61.       ctx.fillStyle = 'magenta';
  62.       ctx.fillRect(this.p2.x - 1.5 * ls, this.p2.y - 1.5 * ls, 3 * ls, 3 * ls);
  63.     }
  64.   }
  66.   checkRayIntersects(ray) {
  67.     if (this.refIndex <= 0) return;
  68.     return this.checkRayIntersectsShape(ray);
  69.   }
  71.   onRayIncident(ray, rayIndex, incidentPoint, surfaceMergingObjs) {
  72.     var midpoint = geometry.segmentMidpoint(geometry.line(ray.p1, incidentPoint));
  73.     var d = geometry.distanceSquared(this.p1, this.p2) - geometry.distanceSquared(this.p1, midpoint);
  74.     if (d > 0) {
  75.       // From inside to outside
  76.       var n1 = this.getRefIndexAt(incidentPoint, ray);
  77.       var normal = { x: this.p1.x - incidentPoint.x, y: this.p1.y - incidentPoint.y };
  78.     } else if (d < 0) {
  79.       // From outside to inside
  80.       var n1 = 1 / this.getRefIndexAt(incidentPoint, ray);
  81.       var normal = { x: incidentPoint.x - this.p1.x, y: incidentPoint.y - this.p1.y };
  82.     } else {
  83.       // Situation that may cause bugs (e.g. incident on an edge point)
  84.       // To prevent shooting the ray to a wrong direction, absorb the ray
  85.       return {
  86.         isAbsorbed: true
  87.       };
  88.     }
  90.     return this.refract(ray, rayIndex, incidentPoint, normal, n1, surfaceMergingObjs, ray.bodyMergingObj);
  91.   }
  93.   getIncidentType(ray) {
  94.     var midpoint = geometry.segmentMidpoint(geometry.line(ray.p1, this.checkRayIntersects(ray)));
  95.     var d = geometry.distanceSquared(this.p1, this.p2) - geometry.distanceSquared(this.p1, midpoint);
  96.     if (d > 0) {
  97.       return 1; // From inside to outside
  98.     }
  99.     if (d < 0) {
  100.       return -1; // From outside to inside
  101.     }
  102.     return NaN;
  103.   }
  104. };
  106. export default CircleGlass;