Code Marathon - Steel Building

function drawRow(
  rowOffset: number,
  columnsSchedule: string[],
  beamsSchedule: string[],
  columnOuterSchedule?: string[]
) {
  if (!scene) return;

  // Start by drawing the ground floor columns
  const colCount = eastWestBayCount + 1;
  const columnSchedule = columnsSchedule;
  const columnFloorSets: number[] = [3, 3, 4]; // How many floors each column type gets, stacked
  const beamSchedule = beamsSchedule;
  const beamFloorSets: number[] = [3, 4, 3]; // How many floors each beam type gets, stacked
  let currentColumnElevation = 0;
  for (let f = 0; f < floorCount; f++) {
    const floorColumnProfileIndex =
      f < columnFloorSets[0]
        ? 0
        : f < columnFloorSets[0] + columnFloorSets[1]
          ? 1
          : 2;
    let targetColumnProfile = profileOptions.find(
      (p) => p.name === columnSchedule[floorColumnProfileIndex]
    );
    console.log(targetColumnProfile?.name);
    //console.log(profileOptions);
    if (!targetColumnProfile) {
      window.alert(
        `Profile ${columnSchedule[floorColumnProfileIndex]} not found.`
      );
      return;
    }
    let columnHeight;
    if (f === 0) {
      columnHeight = groundFloorHeightMeters + upperFloorHeightMeters / 2;
    } else if (f === floorCount - 2) {
      columnHeight = upperFloorHeightMeters + upperFloorHeightMeters / 2;
    } else {
      columnHeight = upperFloorHeightMeters;
    }
    for (let i = 0; i < colCount; i++) {
      if (f > floorCount - 2) break;
      if (columnOuterSchedule && (i === 0 || i === colCount - 1)) {
        const outerProfile = profileOptions.find(
          (p) => p.name === columnOuterSchedule[floorColumnProfileIndex]
        );
        if (outerProfile) {
          targetColumnProfile = outerProfile;
        }
      }
      const columnMesh = drawProfileMesh(targetColumnProfile, columnHeight);
      if (columnMesh) {
        columnMesh.parent = parentContainer;
        // Rotate 90 degrees to make it stand vertically
        columnMesh.rotation.x = -Math.PI / 2;
        columnMesh.position.x = i * eastWestBaySizeMeters;
        columnMesh.position.y = currentColumnElevation;
        columnMesh.position.z = rowOffset;
        // if (sharedSteelMaterial) {
        //   columnMesh.material = sharedSteelMaterial;
        // }
        // Apply a random color material to each column for visibility
        const randomColorMat = new BABYLON.StandardMaterial(
          `mat-${f}-${i}`,
          scene
        );
        let sectionColor = randomSectionColors[targetColumnProfile.name];
        if (!sectionColor) {
          sectionColor = BABYLON.Color3.Random();
          randomSectionColors[targetColumnProfile.name] = sectionColor;
        }
        randomColorMat.diffuseColor = sectionColor;
        columnMesh.material = randomColorMat;
      }
    }

    currentColumnElevation += columnHeight;

    const targetBeamProfileIndex =
      f < beamFloorSets[0]
        ? 0
        : f < beamFloorSets[0] + beamFloorSets[1]
          ? 1
          : 2;
    const targetBeamProfile = profileOptions.find(
      (p) => p.name === beamSchedule[targetBeamProfileIndex]
    );
    if (!targetBeamProfile) {
      window.alert(
        `Profile ${beamSchedule[targetBeamProfileIndex]} not found.`
      );
      return;
    }
    // Now draw the beams for this floor
    const beamCount = eastWestBayCount;
    for (let b = 0; b < beamCount; b++) {
      const beamElevation =
        groundFloorHeightMeters + upperFloorHeightMeters * f;
      const beamMesh = drawProfileMesh(
        targetBeamProfile,
        eastWestBaySizeMeters
      );
      if (beamMesh) {
        beamMesh.rotation.y = Math.PI / 2;
        beamMesh.parent = parentContainer;
        beamMesh.position.x = b * eastWestBaySizeMeters;
        beamMesh.position.y = beamElevation;
        beamMesh.position.z = rowOffset;
        const beamMaterial = new BABYLON.StandardMaterial(
          `beam-mat-${f}-${b}`,
          scene
        );
        let sectionColor = randomSectionColors[targetColumnProfile.name];
        if (!sectionColor) {
          sectionColor = BABYLON.Color3.Random();
          randomSectionColors[targetColumnProfile.name] = sectionColor;
        }
        beamMaterial.diffuseColor = sectionColor;
        beamMesh.material = beamMaterial;
      }
    }
  }
}

function drawOutsideColumnBeams(columnOffset: number, beamSchedule: string[]) {
  // Draw the outer beams for columns 1 and last
  const beamFloorSets: number[] = [3, 4, 3]; // How many floors each beam type gets, stacked
  let currentBeamElevation = 0;
  for (let f = 0; f < floorCount; f++) {
    const targetBeamProfileIndex =
      f < beamFloorSets[0]
        ? 0
        : f < beamFloorSets[0] + beamFloorSets[1]
          ? 1
          : 2;
    const targetBeamProfile = profileOptions.find(
      (p) => p.name === beamSchedule[targetBeamProfileIndex]
    );
    if (!targetBeamProfile) {
      window.alert(
        `Profile ${beamSchedule[targetBeamProfileIndex]} not found.`
      );
      return;
    }
    // Now draw the beams for this floor
    const beamCount = northSouthBayCount;
    for (let b = 0; b < beamCount; b++) {
      const beamElevation =
        groundFloorHeightMeters + upperFloorHeightMeters * f;
      const beamMesh = drawProfileMesh(
        targetBeamProfile,
        northSouthBaySizeMeters
      );
      if (beamMesh) {
        //beamMesh.rotation.y = Math.PI / 2;
        beamMesh.parent = parentContainer;
        beamMesh.position.x = columnOffset;
        beamMesh.position.y = beamElevation;
        beamMesh.position.z = b * northSouthBaySizeMeters;
        const beamMaterial = new BABYLON.StandardMaterial(
          `beam-mat-${f}-${b}`,
          scene
        );
        let sectionColor = randomSectionColors[targetBeamProfile.name];
        if (!sectionColor) {
          sectionColor = BABYLON.Color3.Random();
          randomSectionColors[targetBeamProfile.name] = sectionColor;
        }
        beamMaterial.diffuseColor = sectionColor;
        beamMesh.material = beamMaterial;
      }
    }
  }
}

function drawCompleteStructure() {
  // Draw all the rows
  const momentFrameColumnSchedule = ["W14x257", "W14x211", "W14x159"];
  const gravityFrameGravitySchedule = ["W14x132", "W14x109", "W14x90"];
  const beamsSchedule = ["W14x90", "W14x90", "W14x90"];
  const momentFrameBeamSchedule = ["W27x94", "W27x84", "W24x84"];
  for (let r = 0; r < northSouthBayCount + 1; r++) {
    const rowOffset = r * northSouthBaySizeMeters;
    const isEdgeRow = r === 0 || r === northSouthBayCount;
    drawRow(
      rowOffset,
      isEdgeRow ? momentFrameColumnSchedule : gravityFrameGravitySchedule,
      isEdgeRow ? momentFrameBeamSchedule : beamsSchedule,
      isEdgeRow ? undefined : momentFrameColumnSchedule
    );
  }
  // Draw the outer beams for columns 1 and last
  drawOutsideColumnBeams(0, momentFrameBeamSchedule);
  drawOutsideColumnBeams(
    eastWestBayCount * eastWestBaySizeMeters,
    momentFrameBeamSchedule
  );
  // Compute the center offsets for the whole build
  const northSouthOffset = (northSouthBayCount * northSouthBaySizeMeters) / 2;
  const eastWestOffset = (eastWestBayCount * eastWestBaySizeMeters) / 2;
  parentContainer.position = new BABYLON.Vector3(
    -eastWestOffset,
    0,
    -northSouthOffset
  );

  // Compute the vertical (y) offset to place the camera pivot at mid-height
  const totalHeightMeters =
    groundFloorHeightMeters + upperFloorHeightMeters * (floorCount - 1);

  if (camera) {
    camera.setTarget(new BABYLON.Vector3(0, totalHeightMeters / 2, 0));
  }
}