@polygonjs/polygonjs/dist/src/engine/containers/utils/GeometryContainerUtils.js

node-based WebGL 3D engine https://polygonjs.com

"use strict";
import {
  corePointClassFactory,
  coreVertexClassFactory,
  corePrimitiveClassFactory,
  coreObjectClassFactory
} from "../../..//core/geometry/CoreObjectFactory";
import {
  coreObjectsAttribSizesByName,
  coreObjectAttributeTypesByName
} from "../../..//core/geometry/entities/object/BaseCoreObjectUtils";
import { addToSetAtEntry } from "../../../core/MapUtils";
import { setToArray } from "../../..//core/SetUtils";
import { AttribType } from "../../..//core/geometry/Constant";
function _firstObject(sopContainer) {
  const coreGroup = sopContainer.coreContent();
  if (!coreGroup) {
    return;
  }
  return coreGroup.allObjects()[0];
}
export function pointAttributeSizesByName(sopContainer) {
  const sizesByName = {};
  const object = _firstObject(sopContainer);
  if (object) {
    const entityClass = corePointClassFactory(object);
    const attributeNames = entityClass.attributeNames(object);
    for (const attribName of attributeNames) {
      sizesByName[attribName] = entityClass.attribSize(object, attribName);
    }
  }
  return sizesByName;
}
export function pointAttributeTypesByName(sopContainer) {
  const typesByName = {};
  const object = _firstObject(sopContainer);
  if (!object) {
    return typesByName;
  }
  const entityClass = corePointClassFactory(object);
  const attributes = entityClass.attributes(object);
  if (!attributes) {
    return typesByName;
  }
  const attribNames = Object.keys(attributes);
  for (const attribName of attribNames) {
    const attribType = entityClass.attribType(object, attribName);
    typesByName[attribName] = attribType;
  }
  return typesByName;
}
export function vertexAttributeSizesByName(sopContainer) {
  const sizesByName = {};
  const object = _firstObject(sopContainer);
  if (object) {
    const entityClass = coreVertexClassFactory(object);
    const attributeNames = entityClass.attributeNames(object);
    for (const attribName of attributeNames) {
      sizesByName[attribName] = entityClass.attribSize(object, attribName);
    }
  }
  return sizesByName;
}
export function vertexAttributeTypesByName(sopContainer) {
  const typesByName = {};
  const object = _firstObject(sopContainer);
  if (!object) {
    return typesByName;
  }
  const entityClass = coreVertexClassFactory(object);
  const attributes = entityClass.attributes(object);
  if (!attributes) {
    return typesByName;
  }
  const attribNames = Object.keys(attributes);
  for (const attribName of attribNames) {
    const attribType = entityClass.attribType(object, attribName);
    typesByName[attribName] = attribType;
  }
  return typesByName;
}
export function primitiveAttributeSizesByName(sopContainer) {
  const sizesByName = {};
  const object = _firstObject(sopContainer);
  if (object) {
    const entityClass = corePrimitiveClassFactory(object);
    const attributeNames = entityClass.attributeNames(object);
    for (const attribName of attributeNames) {
      sizesByName[attribName] = entityClass.attribSize(object, attribName);
    }
  }
  return sizesByName;
}
export function primitiveAttributeTypesByName(sopContainer) {
  const typesByName = {};
  const object = _firstObject(sopContainer);
  if (!object) {
    return typesByName;
  }
  const entityClass = corePrimitiveClassFactory(object);
  const attributes = entityClass.attributes(object);
  if (!attributes) {
    return typesByName;
  }
  const attribNames = Object.keys(attributes);
  for (const attribName of attribNames) {
    const attribType = entityClass.attribType(object, attribName);
    typesByName[attribName] = attribType;
  }
  return typesByName;
}
export function objectAttributeSizesByName(sopContainer) {
  const coreGroup = sopContainer.coreContent();
  if (!coreGroup) {
    return;
  }
  return coreObjectsAttribSizesByName(coreGroup.allCoreObjects());
}
export function objectAttributeTypesByName(sopContainer) {
  const coreGroup = sopContainer.coreContent();
  if (!coreGroup) {
    return;
  }
  return coreObjectAttributeTypesByName(coreGroup.allCoreObjects());
}
export function objectAttributeTypeAndSizesByName(sopContainer) {
  const _sizesByTypeByName = /* @__PURE__ */ new Map();
  const coreGroup = sopContainer.coreContent();
  if (!coreGroup) {
    return;
  }
  const objects = coreGroup.allObjects();
  for (const object of objects) {
    const coreObjectClass = coreObjectClassFactory(object);
    const objectAttriNames = coreObjectClass.attribNames(object);
    for (const attribName of objectAttriNames) {
      const attribType = coreObjectClass.attribType(object, attribName);
      const attribSize = coreObjectClass.attribSize(object, attribName);
      let mapForName = _sizesByTypeByName.get(attribName);
      if (!mapForName) {
        mapForName = /* @__PURE__ */ new Map();
      }
      _sizesByTypeByName.set(attribName, mapForName);
      addToSetAtEntry(mapForName, attribType, attribSize);
    }
  }
  const sizesByTypeByName = {};
  _sizesByTypeByName.forEach((mapForName, attribName) => {
    sizesByTypeByName[attribName] = { [AttribType.NUMERIC]: [], [AttribType.STRING]: [] };
    mapForName.forEach((attribSizes, attribType) => {
      sizesByTypeByName[attribName][attribType] = setToArray(attribSizes, []);
    });
  });
  return sizesByTypeByName;
}
export function coreGroupAttributeSizesByName(sopContainer) {
  const sizes_by_name = {};
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    const attribNames = coreGroup.attribNames();
    for (const attribName of attribNames) {
      const size = coreGroup.attribSize(attribName);
      if (size != null) {
        sizes_by_name[attribName] = size;
      }
    }
  }
  return sizes_by_name;
}
export function coreGroupAttributeTypesByName(sopContainer) {
  const types_by_name = {};
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    const attribNames = coreGroup.attribNames();
    for (const attribName of attribNames) {
      types_by_name[attribName] = coreGroup.attribType(attribName);
    }
  }
  return types_by_name;
}
export function coreGroupAttributeValuesByName(sopContainer) {
  const valuesByName = {};
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    const attribNames = coreGroup.attribNames();
    for (const attribName of attribNames) {
      valuesByName[attribName] = coreGroup.attribValue(attribName);
    }
  }
  return valuesByName;
}
export function objectsData(sopContainer) {
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    return coreGroup.objectsData();
  } else {
    return [];
  }
}
export function totalPointsCount(sopContainer) {
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    return coreGroup.totalPointsCount();
  } else {
    return 0;
  }
}
export function boundingBox(sopContainer, target) {
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    return coreGroup.boundingBox(target);
  } else {
    target.makeEmpty();
  }
}
export function objectsCountByType(sopContainer) {
  const count_by_type = {};
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    for (const core_object of coreGroup.allCoreObjects()) {
      const human_type = core_object.humanType();
      if (count_by_type[human_type] == null) {
        count_by_type[human_type] = 0;
      }
      count_by_type[human_type] += 1;
    }
  }
  return count_by_type;
}
export function objectsNamesByType(sopContainer) {
  const names_by_type = {};
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    const coreObjects = coreGroup.allCoreObjects();
    for (const core_object of coreObjects) {
      const human_type = core_object.humanType();
      names_by_type[human_type] = names_by_type[human_type] || [];
      names_by_type[human_type].push(core_object.name());
    }
  }
  return names_by_type;
}
export function objectsVisibleCount(sopContainer) {
  let count = 0;
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    const objects = coreGroup.allObjects();
    for (const object of objects) {
      if (object.visible) {
        count++;
      }
    }
  }
  return count;
}
export function pointsCount(sopContainer) {
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    return coreGroup.pointsCount();
  } else {
    return 0;
  }
}
export function objectsCount(sopContainer) {
  const coreGroup = sopContainer.coreContent();
  if (coreGroup) {
    return coreGroup.allObjects().length;
  } else {
    return 0;
  }
}