From d1999a9425d7951595db9954bed980124529c018 Mon Sep 17 00:00:00 2001 From: Samuel Arsenault-Brassard Date: Tue, 6 Oct 2026 10:50:04 +0900 Subject: [PATCH 1/3] Assets: a Light asset type for light sources and their IES profiles "light/lights.json" (one record per light source: element, world position and axes, emitter shape, distribution, intensity, colour temperature) and "light/.ies" (IESNA LM-63 text). Without the type, ValidateAssets rejects such buffers. First user: the Revit exporter (vimaec/vimaec sam/exporter-lights). Co-Authored-By: Claude Opus 5.5 --- src/cs/vim/Vim.Format.Core/AssetInfo.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/cs/vim/Vim.Format.Core/AssetInfo.cs b/src/cs/vim/Vim.Format.Core/AssetInfo.cs index c698cfc5..d4a03d80 100644 --- a/src/cs/vim/Vim.Format.Core/AssetInfo.cs +++ b/src/cs/vim/Vim.Format.Core/AssetInfo.cs @@ -11,6 +11,12 @@ public enum AssetType { Texture, Render, + /// + /// Light sources for rendering: "light/lights.json" (one record per light source - its element, world + /// position and axes, emitter shape, distribution, intensity, colour temperature) and the photometric + /// profiles it names, "light/<file>.ies" (IESNA LM-63 text, as Revit's lighting families carry them). + /// + Light, } /// From be6649e39d8c88a363193bd105451243fbaad263 Mon Sep 17 00:00:00 2001 From: Samuel Arsenault-Brassard Date: Tue, 6 Oct 2026 23:30:36 +0900 Subject: [PATCH 2/3] AssetType.Grid: grid/grids.json (the Revit exporter's grids and levels asset, experimental) Co-Authored-By: Claude Opus 5.5 --- src/cs/vim/Vim.Format.Core/AssetInfo.cs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/cs/vim/Vim.Format.Core/AssetInfo.cs b/src/cs/vim/Vim.Format.Core/AssetInfo.cs index d4a03d80..304851af 100644 --- a/src/cs/vim/Vim.Format.Core/AssetInfo.cs +++ b/src/cs/vim/Vim.Format.Core/AssetInfo.cs @@ -17,6 +17,11 @@ public enum AssetType /// profiles it names, "light/<file>.ies" (IESNA LM-63 text, as Revit's lighting families carry them). /// Light, + /// + /// Grids and levels (experimental): "grid/grids.json" (one record per grid - its element, curve, vertical + /// range, multi-segment chain and bubble ends - and one per level - name, elevations, building story). + /// + Grid, } /// From 43af42925dc63d4df4fa3d9e7232d21a68b0e0de Mon Sep 17 00:00:00 2001 From: Samuel Arsenault-Brassard Date: Wed, 7 Oct 2026 09:22:28 +0900 Subject: [PATCH 3/3] Object model 5.8.0: LightType, LightSource and SunAndShadowSettings entities Light data moves out of the JSON asset (light/lights.json, light/sun.json) into entity tables, so it merges like every other table (Martin, 2026-10-07). LightType relates to FamilyType (Revit keeps the light definition on the type) and to the IES file's asset row; LightSource relates to the fixture's Element and its LightType; SunAndShadowSettings relates to the exported View. Raw .ies files stay assets. Additions only; regenerated C#, TypeScript and C++; LightEntityTests round-trip and merge. Co-Authored-By: Claude Opus 5.5 --- docs/object-model-schema.json | 59 +- docs/schema-diff.json | 55 + src/cpp/vim/object-model.h | 2061 +++++++++++++++++ src/cs/vim/Vim.Format.Core/AssetInfo.cs | 7 +- src/cs/vim/Vim.Format.Core/VimConstants.cs | 3 + .../vim/Vim.Format.Tests/LightEntityTests.cs | 202 ++ .../vim/Vim.Format/ObjectModel/ObjectModel.cs | 402 +++- .../ObjectModel/ObjectModelGenerated.cs | 1000 ++++++++ src/ts/src/objectModel.ts | 1112 +++++++++ 9 files changed, 4896 insertions(+), 5 deletions(-) create mode 100644 src/cs/vim/Vim.Format.Tests/LightEntityTests.cs diff --git a/docs/object-model-schema.json b/docs/object-model-schema.json index 36fd452a..73979aef 100644 --- a/docs/object-model-schema.json +++ b/docs/object-model-schema.json @@ -1,6 +1,6 @@ { "VimFormatVersion": "1.0.0", - "SchemaVersion": "5.7.0", + "SchemaVersion": "5.8.0", "Tables": { "Vim.Area": [ "byte:IsGrossInterior", @@ -269,6 +269,50 @@ "index:Vim.Level:Level", "index:Vim.View:View" ], + "Vim.LightSource": [ + "byte:HasLightSourceTransform", + "byte:IsOn", + "double:BasisX.X", + "double:BasisX.Y", + "double:BasisX.Z", + "double:BasisY.X", + "double:BasisY.Y", + "double:BasisY.Z", + "double:BasisZ.X", + "double:BasisZ.Y", + "double:BasisZ.Z", + "double:Origin.X", + "double:Origin.Y", + "double:Origin.Z", + "index:Vim.Element:Element", + "index:Vim.LightType:LightType" + ], + "Vim.LightType": [ + "double:ColorFilter.X", + "double:ColorFilter.Y", + "double:ColorFilter.Z", + "double:Efficacy", + "double:EmitDiameter", + "double:EmitLength", + "double:EmitWidth", + "double:Flux", + "double:Illuminance", + "double:IlluminanceDistance", + "double:InitialColorTemperature", + "double:LossFactor", + "double:Luminosity", + "double:SpotBeamAngle", + "double:SpotFieldAngle", + "double:TiltAngle", + "double:Wattage", + "index:Vim.Asset:PhotometricWebFile", + "index:Vim.FamilyType:FamilyType", + "int:DimmingColor", + "int:InitialIntensityType", + "int:LightDistributionStyle", + "int:LightShapeStyle", + "string:PhotometricWebFileName" + ], "Vim.Material": [ "double:Color.X", "double:Color.Y", @@ -379,6 +423,19 @@ "string:Address", "string:Number" ], + "Vim.SunAndShadowSettings": [ + "byte:RelativeToView", + "byte:UsesDST", + "double:Altitude", + "double:Azimuth", + "index:Vim.View:View", + "int:ActiveFrame", + "int:NumberOfFrames", + "string:ActiveFrameTime", + "string:EndDateAndTime", + "string:StartDateAndTime", + "string:SunAndShadowType" + ], "Vim.System": [ "index:Vim.Element:Element", "index:Vim.FamilyType:FamilyType", diff --git a/docs/schema-diff.json b/docs/schema-diff.json index 95b765e4..e1949285 100644 --- a/docs/schema-diff.json +++ b/docs/schema-diff.json @@ -177,5 +177,60 @@ "Vim.Element__string:LastChangedBy", "Vim.Element__string:Owner" ] + }, + "5.7.0 to 5.8.0": { + "Added": [ + "Vim.LightSource__byte:HasLightSourceTransform", + "Vim.LightSource__byte:IsOn", + "Vim.LightSource__double:BasisX.X", + "Vim.LightSource__double:BasisX.Y", + "Vim.LightSource__double:BasisX.Z", + "Vim.LightSource__double:BasisY.X", + "Vim.LightSource__double:BasisY.Y", + "Vim.LightSource__double:BasisY.Z", + "Vim.LightSource__double:BasisZ.X", + "Vim.LightSource__double:BasisZ.Y", + "Vim.LightSource__double:BasisZ.Z", + "Vim.LightSource__double:Origin.X", + "Vim.LightSource__double:Origin.Y", + "Vim.LightSource__double:Origin.Z", + "Vim.LightSource__index:Vim.Element:Element", + "Vim.LightSource__index:Vim.LightType:LightType", + "Vim.LightType__double:ColorFilter.X", + "Vim.LightType__double:ColorFilter.Y", + "Vim.LightType__double:ColorFilter.Z", + "Vim.LightType__double:Efficacy", + "Vim.LightType__double:EmitDiameter", + "Vim.LightType__double:EmitLength", + "Vim.LightType__double:EmitWidth", + "Vim.LightType__double:Flux", + "Vim.LightType__double:Illuminance", + "Vim.LightType__double:IlluminanceDistance", + "Vim.LightType__double:InitialColorTemperature", + "Vim.LightType__double:LossFactor", + "Vim.LightType__double:Luminosity", + "Vim.LightType__double:SpotBeamAngle", + "Vim.LightType__double:SpotFieldAngle", + "Vim.LightType__double:TiltAngle", + "Vim.LightType__double:Wattage", + "Vim.LightType__index:Vim.Asset:PhotometricWebFile", + "Vim.LightType__index:Vim.FamilyType:FamilyType", + "Vim.LightType__int:DimmingColor", + "Vim.LightType__int:InitialIntensityType", + "Vim.LightType__int:LightDistributionStyle", + "Vim.LightType__int:LightShapeStyle", + "Vim.LightType__string:PhotometricWebFileName", + "Vim.SunAndShadowSettings__byte:RelativeToView", + "Vim.SunAndShadowSettings__byte:UsesDST", + "Vim.SunAndShadowSettings__double:Altitude", + "Vim.SunAndShadowSettings__double:Azimuth", + "Vim.SunAndShadowSettings__index:Vim.View:View", + "Vim.SunAndShadowSettings__int:ActiveFrame", + "Vim.SunAndShadowSettings__int:NumberOfFrames", + "Vim.SunAndShadowSettings__string:ActiveFrameTime", + "Vim.SunAndShadowSettings__string:EndDateAndTime", + "Vim.SunAndShadowSettings__string:StartDateAndTime", + "Vim.SunAndShadowSettings__string:SunAndShadowType" + ] } } \ No newline at end of file diff --git a/src/cpp/vim/object-model.h b/src/cpp/vim/object-model.h index 674f8b73..2037d7ff 100644 --- a/src/cpp/vim/object-model.h +++ b/src/cpp/vim/object-model.h @@ -120,6 +120,12 @@ namespace Vim class SiteTable; class Building; class BuildingTable; + class LightType; + class LightTypeTable; + class LightSource; + class LightSourceTable; + class SunAndShadowSettings; + class SunAndShadowSettingsTable; class DocumentModel { @@ -178,6 +184,9 @@ namespace Vim ViewInViewSheetTable* mViewInViewSheet; SiteTable* mSite; BuildingTable* mBuilding; + LightTypeTable* mLightType; + LightSourceTable* mLightSource; + SunAndShadowSettingsTable* mSunAndShadowSettings; DocumentModel(Scene& scene); ~DocumentModel(); @@ -14228,6 +14237,2052 @@ namespace Vim return new BuildingTable(scene.mEntityTables["Vim.Building"], scene.mStrings); } + class LightType + { + public: + int mIndex; + int mLightShapeStyle; + double mEmitLength; + double mEmitWidth; + double mEmitDiameter; + int mLightDistributionStyle; + double mSpotBeamAngle; + double mSpotFieldAngle; + double mTiltAngle; + std::string mPhotometricWebFileName; + int mInitialIntensityType; + double mLuminosity; + double mFlux; + double mWattage; + double mEfficacy; + double mIlluminance; + double mIlluminanceDistance; + double mInitialColorTemperature; + double mColorFilter_X; + double mColorFilter_Y; + double mColorFilter_Z; + double mLossFactor; + int mDimmingColor; + + int mPhotometricWebFileIndex; + Asset* mPhotometricWebFile; + int mFamilyTypeIndex; + FamilyType* mFamilyType; + + LightType() {} + }; + + class LightTypeTable + { + EntityTable& mEntityTable; + std::vector& mStrings; + public: + LightTypeTable(EntityTable& entityTable, std::vector& strings): + mEntityTable(entityTable), mStrings(strings) {} + + size_t GetCount() + { + return mEntityTable.get_count(); + } + + LightType* Get(int lightTypeIndex) + { + LightType* lightType = new LightType(); + lightType->mIndex = lightTypeIndex; + lightType->mLightShapeStyle = GetLightShapeStyle(lightTypeIndex); + lightType->mEmitLength = GetEmitLength(lightTypeIndex); + lightType->mEmitWidth = GetEmitWidth(lightTypeIndex); + lightType->mEmitDiameter = GetEmitDiameter(lightTypeIndex); + lightType->mLightDistributionStyle = GetLightDistributionStyle(lightTypeIndex); + lightType->mSpotBeamAngle = GetSpotBeamAngle(lightTypeIndex); + lightType->mSpotFieldAngle = GetSpotFieldAngle(lightTypeIndex); + lightType->mTiltAngle = GetTiltAngle(lightTypeIndex); + lightType->mPhotometricWebFileName = GetPhotometricWebFileName(lightTypeIndex); + lightType->mInitialIntensityType = GetInitialIntensityType(lightTypeIndex); + lightType->mLuminosity = GetLuminosity(lightTypeIndex); + lightType->mFlux = GetFlux(lightTypeIndex); + lightType->mWattage = GetWattage(lightTypeIndex); + lightType->mEfficacy = GetEfficacy(lightTypeIndex); + lightType->mIlluminance = GetIlluminance(lightTypeIndex); + lightType->mIlluminanceDistance = GetIlluminanceDistance(lightTypeIndex); + lightType->mInitialColorTemperature = GetInitialColorTemperature(lightTypeIndex); + lightType->mColorFilter_X = GetColorFilter_X(lightTypeIndex); + lightType->mColorFilter_Y = GetColorFilter_Y(lightTypeIndex); + lightType->mColorFilter_Z = GetColorFilter_Z(lightTypeIndex); + lightType->mLossFactor = GetLossFactor(lightTypeIndex); + lightType->mDimmingColor = GetDimmingColor(lightTypeIndex); + lightType->mPhotometricWebFileIndex = GetPhotometricWebFileIndex(lightTypeIndex); + lightType->mFamilyTypeIndex = GetFamilyTypeIndex(lightTypeIndex); + return lightType; + } + + std::vector* GetAll() + { + bool existsLightShapeStyle = mEntityTable.column_exists("int:LightShapeStyle"); + bool existsEmitLength = mEntityTable.column_exists("double:EmitLength"); + bool existsEmitWidth = mEntityTable.column_exists("double:EmitWidth"); + bool existsEmitDiameter = mEntityTable.column_exists("double:EmitDiameter"); + bool existsLightDistributionStyle = mEntityTable.column_exists("int:LightDistributionStyle"); + bool existsSpotBeamAngle = mEntityTable.column_exists("double:SpotBeamAngle"); + bool existsSpotFieldAngle = mEntityTable.column_exists("double:SpotFieldAngle"); + bool existsTiltAngle = mEntityTable.column_exists("double:TiltAngle"); + bool existsPhotometricWebFileName = mEntityTable.column_exists("string:PhotometricWebFileName"); + bool existsInitialIntensityType = mEntityTable.column_exists("int:InitialIntensityType"); + bool existsLuminosity = mEntityTable.column_exists("double:Luminosity"); + bool existsFlux = mEntityTable.column_exists("double:Flux"); + bool existsWattage = mEntityTable.column_exists("double:Wattage"); + bool existsEfficacy = mEntityTable.column_exists("double:Efficacy"); + bool existsIlluminance = mEntityTable.column_exists("double:Illuminance"); + bool existsIlluminanceDistance = mEntityTable.column_exists("double:IlluminanceDistance"); + bool existsInitialColorTemperature = mEntityTable.column_exists("double:InitialColorTemperature"); + bool existsColorFilter_X = mEntityTable.column_exists("double:ColorFilter.X"); + bool existsColorFilter_Y = mEntityTable.column_exists("double:ColorFilter.Y"); + bool existsColorFilter_Z = mEntityTable.column_exists("double:ColorFilter.Z"); + bool existsLossFactor = mEntityTable.column_exists("double:LossFactor"); + bool existsDimmingColor = mEntityTable.column_exists("int:DimmingColor"); + bool existsPhotometricWebFile = mEntityTable.column_exists("index:Vim.Asset:PhotometricWebFile"); + bool existsFamilyType = mEntityTable.column_exists("index:Vim.FamilyType:FamilyType"); + + const auto count = GetCount(); + + std::vector* lightType = new std::vector(); + lightType->reserve(count); + + int* lightShapeStyleData = new int[count]; + if (mEntityTable.column_exists("int:LightShapeStyle")) { + memcpy(lightShapeStyleData, mEntityTable.mDataColumns["int:LightShapeStyle"].begin(), count * sizeof(int)); + } + + double* emitLengthData = new double[count]; + if (mEntityTable.column_exists("double:EmitLength")) { + memcpy(emitLengthData, mEntityTable.mDataColumns["double:EmitLength"].begin(), count * sizeof(double)); + } + + double* emitWidthData = new double[count]; + if (mEntityTable.column_exists("double:EmitWidth")) { + memcpy(emitWidthData, mEntityTable.mDataColumns["double:EmitWidth"].begin(), count * sizeof(double)); + } + + double* emitDiameterData = new double[count]; + if (mEntityTable.column_exists("double:EmitDiameter")) { + memcpy(emitDiameterData, mEntityTable.mDataColumns["double:EmitDiameter"].begin(), count * sizeof(double)); + } + + int* lightDistributionStyleData = new int[count]; + if (mEntityTable.column_exists("int:LightDistributionStyle")) { + memcpy(lightDistributionStyleData, mEntityTable.mDataColumns["int:LightDistributionStyle"].begin(), count * sizeof(int)); + } + + double* spotBeamAngleData = new double[count]; + if (mEntityTable.column_exists("double:SpotBeamAngle")) { + memcpy(spotBeamAngleData, mEntityTable.mDataColumns["double:SpotBeamAngle"].begin(), count * sizeof(double)); + } + + double* spotFieldAngleData = new double[count]; + if (mEntityTable.column_exists("double:SpotFieldAngle")) { + memcpy(spotFieldAngleData, mEntityTable.mDataColumns["double:SpotFieldAngle"].begin(), count * sizeof(double)); + } + + double* tiltAngleData = new double[count]; + if (mEntityTable.column_exists("double:TiltAngle")) { + memcpy(tiltAngleData, mEntityTable.mDataColumns["double:TiltAngle"].begin(), count * sizeof(double)); + } + + const std::vector& photometricWebFileNameData = mEntityTable.column_exists("string:PhotometricWebFileName") ? mEntityTable.mStringColumns["string:PhotometricWebFileName"] : std::vector(); + + int* initialIntensityTypeData = new int[count]; + if (mEntityTable.column_exists("int:InitialIntensityType")) { + memcpy(initialIntensityTypeData, mEntityTable.mDataColumns["int:InitialIntensityType"].begin(), count * sizeof(int)); + } + + double* luminosityData = new double[count]; + if (mEntityTable.column_exists("double:Luminosity")) { + memcpy(luminosityData, mEntityTable.mDataColumns["double:Luminosity"].begin(), count * sizeof(double)); + } + + double* fluxData = new double[count]; + if (mEntityTable.column_exists("double:Flux")) { + memcpy(fluxData, mEntityTable.mDataColumns["double:Flux"].begin(), count * sizeof(double)); + } + + double* wattageData = new double[count]; + if (mEntityTable.column_exists("double:Wattage")) { + memcpy(wattageData, mEntityTable.mDataColumns["double:Wattage"].begin(), count * sizeof(double)); + } + + double* efficacyData = new double[count]; + if (mEntityTable.column_exists("double:Efficacy")) { + memcpy(efficacyData, mEntityTable.mDataColumns["double:Efficacy"].begin(), count * sizeof(double)); + } + + double* illuminanceData = new double[count]; + if (mEntityTable.column_exists("double:Illuminance")) { + memcpy(illuminanceData, mEntityTable.mDataColumns["double:Illuminance"].begin(), count * sizeof(double)); + } + + double* illuminanceDistanceData = new double[count]; + if (mEntityTable.column_exists("double:IlluminanceDistance")) { + memcpy(illuminanceDistanceData, mEntityTable.mDataColumns["double:IlluminanceDistance"].begin(), count * sizeof(double)); + } + + double* initialColorTemperatureData = new double[count]; + if (mEntityTable.column_exists("double:InitialColorTemperature")) { + memcpy(initialColorTemperatureData, mEntityTable.mDataColumns["double:InitialColorTemperature"].begin(), count * sizeof(double)); + } + + double* colorFilter_XData = new double[count]; + if (mEntityTable.column_exists("double:ColorFilter.X")) { + memcpy(colorFilter_XData, mEntityTable.mDataColumns["double:ColorFilter.X"].begin(), count * sizeof(double)); + } + + double* colorFilter_YData = new double[count]; + if (mEntityTable.column_exists("double:ColorFilter.Y")) { + memcpy(colorFilter_YData, mEntityTable.mDataColumns["double:ColorFilter.Y"].begin(), count * sizeof(double)); + } + + double* colorFilter_ZData = new double[count]; + if (mEntityTable.column_exists("double:ColorFilter.Z")) { + memcpy(colorFilter_ZData, mEntityTable.mDataColumns["double:ColorFilter.Z"].begin(), count * sizeof(double)); + } + + double* lossFactorData = new double[count]; + if (mEntityTable.column_exists("double:LossFactor")) { + memcpy(lossFactorData, mEntityTable.mDataColumns["double:LossFactor"].begin(), count * sizeof(double)); + } + + int* dimmingColorData = new int[count]; + if (mEntityTable.column_exists("int:DimmingColor")) { + memcpy(dimmingColorData, mEntityTable.mDataColumns["int:DimmingColor"].begin(), count * sizeof(int)); + } + + const std::vector& photometricWebFileData = mEntityTable.column_exists("index:Vim.Asset:PhotometricWebFile") ? mEntityTable.mIndexColumns["index:Vim.Asset:PhotometricWebFile"] : std::vector(); + const std::vector& familyTypeData = mEntityTable.column_exists("index:Vim.FamilyType:FamilyType") ? mEntityTable.mIndexColumns["index:Vim.FamilyType:FamilyType"] : std::vector(); + + for (int i = 0; i < count; ++i) + { + LightType entity; + entity.mIndex = i; + if (existsLightShapeStyle) + entity.mLightShapeStyle = lightShapeStyleData[i]; + if (existsEmitLength) + entity.mEmitLength = emitLengthData[i]; + if (existsEmitWidth) + entity.mEmitWidth = emitWidthData[i]; + if (existsEmitDiameter) + entity.mEmitDiameter = emitDiameterData[i]; + if (existsLightDistributionStyle) + entity.mLightDistributionStyle = lightDistributionStyleData[i]; + if (existsSpotBeamAngle) + entity.mSpotBeamAngle = spotBeamAngleData[i]; + if (existsSpotFieldAngle) + entity.mSpotFieldAngle = spotFieldAngleData[i]; + if (existsTiltAngle) + entity.mTiltAngle = tiltAngleData[i]; + if (existsPhotometricWebFileName) + entity.mPhotometricWebFileName = std::string(reinterpret_cast(mStrings[photometricWebFileNameData[i]])); + if (existsInitialIntensityType) + entity.mInitialIntensityType = initialIntensityTypeData[i]; + if (existsLuminosity) + entity.mLuminosity = luminosityData[i]; + if (existsFlux) + entity.mFlux = fluxData[i]; + if (existsWattage) + entity.mWattage = wattageData[i]; + if (existsEfficacy) + entity.mEfficacy = efficacyData[i]; + if (existsIlluminance) + entity.mIlluminance = illuminanceData[i]; + if (existsIlluminanceDistance) + entity.mIlluminanceDistance = illuminanceDistanceData[i]; + if (existsInitialColorTemperature) + entity.mInitialColorTemperature = initialColorTemperatureData[i]; + if (existsColorFilter_X) + entity.mColorFilter_X = colorFilter_XData[i]; + if (existsColorFilter_Y) + entity.mColorFilter_Y = colorFilter_YData[i]; + if (existsColorFilter_Z) + entity.mColorFilter_Z = colorFilter_ZData[i]; + if (existsLossFactor) + entity.mLossFactor = lossFactorData[i]; + if (existsDimmingColor) + entity.mDimmingColor = dimmingColorData[i]; + entity.mPhotometricWebFileIndex = existsPhotometricWebFile ? photometricWebFileData[i] : -1; + entity.mFamilyTypeIndex = existsFamilyType ? familyTypeData[i] : -1; + lightType->push_back(entity); + } + + delete[] lightShapeStyleData; + delete[] emitLengthData; + delete[] emitWidthData; + delete[] emitDiameterData; + delete[] lightDistributionStyleData; + delete[] spotBeamAngleData; + delete[] spotFieldAngleData; + delete[] tiltAngleData; + delete[] initialIntensityTypeData; + delete[] luminosityData; + delete[] fluxData; + delete[] wattageData; + delete[] efficacyData; + delete[] illuminanceData; + delete[] illuminanceDistanceData; + delete[] initialColorTemperatureData; + delete[] colorFilter_XData; + delete[] colorFilter_YData; + delete[] colorFilter_ZData; + delete[] lossFactorData; + delete[] dimmingColorData; + + return lightType; + } + + int GetLightShapeStyle(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("int:LightShapeStyle")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["int:LightShapeStyle"].begin() + lightTypeIndex * sizeof(int))); + } + + return {}; + } + + std::vector* GetAllLightShapeStyle() + { + const auto count = GetCount(); + + int* lightShapeStyleData = new int[count]; + if (mEntityTable.column_exists("int:LightShapeStyle")) { + memcpy(lightShapeStyleData, mEntityTable.mDataColumns["int:LightShapeStyle"].begin(), count * sizeof(int)); + } + + std::vector* result = new std::vector(lightShapeStyleData, lightShapeStyleData + count); + + delete[] lightShapeStyleData; + + return result; + } + + double GetEmitLength(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:EmitLength")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:EmitLength"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllEmitLength() + { + const auto count = GetCount(); + + double* emitLengthData = new double[count]; + if (mEntityTable.column_exists("double:EmitLength")) { + memcpy(emitLengthData, mEntityTable.mDataColumns["double:EmitLength"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(emitLengthData, emitLengthData + count); + + delete[] emitLengthData; + + return result; + } + + double GetEmitWidth(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:EmitWidth")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:EmitWidth"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllEmitWidth() + { + const auto count = GetCount(); + + double* emitWidthData = new double[count]; + if (mEntityTable.column_exists("double:EmitWidth")) { + memcpy(emitWidthData, mEntityTable.mDataColumns["double:EmitWidth"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(emitWidthData, emitWidthData + count); + + delete[] emitWidthData; + + return result; + } + + double GetEmitDiameter(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:EmitDiameter")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:EmitDiameter"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllEmitDiameter() + { + const auto count = GetCount(); + + double* emitDiameterData = new double[count]; + if (mEntityTable.column_exists("double:EmitDiameter")) { + memcpy(emitDiameterData, mEntityTable.mDataColumns["double:EmitDiameter"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(emitDiameterData, emitDiameterData + count); + + delete[] emitDiameterData; + + return result; + } + + int GetLightDistributionStyle(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("int:LightDistributionStyle")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["int:LightDistributionStyle"].begin() + lightTypeIndex * sizeof(int))); + } + + return {}; + } + + std::vector* GetAllLightDistributionStyle() + { + const auto count = GetCount(); + + int* lightDistributionStyleData = new int[count]; + if (mEntityTable.column_exists("int:LightDistributionStyle")) { + memcpy(lightDistributionStyleData, mEntityTable.mDataColumns["int:LightDistributionStyle"].begin(), count * sizeof(int)); + } + + std::vector* result = new std::vector(lightDistributionStyleData, lightDistributionStyleData + count); + + delete[] lightDistributionStyleData; + + return result; + } + + double GetSpotBeamAngle(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:SpotBeamAngle")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:SpotBeamAngle"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllSpotBeamAngle() + { + const auto count = GetCount(); + + double* spotBeamAngleData = new double[count]; + if (mEntityTable.column_exists("double:SpotBeamAngle")) { + memcpy(spotBeamAngleData, mEntityTable.mDataColumns["double:SpotBeamAngle"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(spotBeamAngleData, spotBeamAngleData + count); + + delete[] spotBeamAngleData; + + return result; + } + + double GetSpotFieldAngle(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:SpotFieldAngle")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:SpotFieldAngle"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllSpotFieldAngle() + { + const auto count = GetCount(); + + double* spotFieldAngleData = new double[count]; + if (mEntityTable.column_exists("double:SpotFieldAngle")) { + memcpy(spotFieldAngleData, mEntityTable.mDataColumns["double:SpotFieldAngle"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(spotFieldAngleData, spotFieldAngleData + count); + + delete[] spotFieldAngleData; + + return result; + } + + double GetTiltAngle(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:TiltAngle")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:TiltAngle"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllTiltAngle() + { + const auto count = GetCount(); + + double* tiltAngleData = new double[count]; + if (mEntityTable.column_exists("double:TiltAngle")) { + memcpy(tiltAngleData, mEntityTable.mDataColumns["double:TiltAngle"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(tiltAngleData, tiltAngleData + count); + + delete[] tiltAngleData; + + return result; + } + + std::string GetPhotometricWebFileName(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("string:PhotometricWebFileName")) { + return std::string(reinterpret_cast(mStrings[mEntityTable.mStringColumns["string:PhotometricWebFileName"][lightTypeIndex]])); + } + + return {}; + } + + std::vector* GetAllPhotometricWebFileName() + { + const auto count = GetCount(); + + const std::vector& photometricWebFileNameData = mEntityTable.column_exists("string:PhotometricWebFileName") ? mEntityTable.mStringColumns["string:PhotometricWebFileName"] : std::vector(); + + std::vector* result = new std::vector(); + result->reserve(count); + + for (int i = 0; i < count; ++i) + { + result->push_back(std::string(reinterpret_cast(mStrings[photometricWebFileNameData[i]]))); + } + + return result; + } + + int GetInitialIntensityType(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("int:InitialIntensityType")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["int:InitialIntensityType"].begin() + lightTypeIndex * sizeof(int))); + } + + return {}; + } + + std::vector* GetAllInitialIntensityType() + { + const auto count = GetCount(); + + int* initialIntensityTypeData = new int[count]; + if (mEntityTable.column_exists("int:InitialIntensityType")) { + memcpy(initialIntensityTypeData, mEntityTable.mDataColumns["int:InitialIntensityType"].begin(), count * sizeof(int)); + } + + std::vector* result = new std::vector(initialIntensityTypeData, initialIntensityTypeData + count); + + delete[] initialIntensityTypeData; + + return result; + } + + double GetLuminosity(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Luminosity")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Luminosity"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllLuminosity() + { + const auto count = GetCount(); + + double* luminosityData = new double[count]; + if (mEntityTable.column_exists("double:Luminosity")) { + memcpy(luminosityData, mEntityTable.mDataColumns["double:Luminosity"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(luminosityData, luminosityData + count); + + delete[] luminosityData; + + return result; + } + + double GetFlux(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Flux")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Flux"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllFlux() + { + const auto count = GetCount(); + + double* fluxData = new double[count]; + if (mEntityTable.column_exists("double:Flux")) { + memcpy(fluxData, mEntityTable.mDataColumns["double:Flux"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(fluxData, fluxData + count); + + delete[] fluxData; + + return result; + } + + double GetWattage(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Wattage")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Wattage"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllWattage() + { + const auto count = GetCount(); + + double* wattageData = new double[count]; + if (mEntityTable.column_exists("double:Wattage")) { + memcpy(wattageData, mEntityTable.mDataColumns["double:Wattage"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(wattageData, wattageData + count); + + delete[] wattageData; + + return result; + } + + double GetEfficacy(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Efficacy")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Efficacy"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllEfficacy() + { + const auto count = GetCount(); + + double* efficacyData = new double[count]; + if (mEntityTable.column_exists("double:Efficacy")) { + memcpy(efficacyData, mEntityTable.mDataColumns["double:Efficacy"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(efficacyData, efficacyData + count); + + delete[] efficacyData; + + return result; + } + + double GetIlluminance(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Illuminance")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Illuminance"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllIlluminance() + { + const auto count = GetCount(); + + double* illuminanceData = new double[count]; + if (mEntityTable.column_exists("double:Illuminance")) { + memcpy(illuminanceData, mEntityTable.mDataColumns["double:Illuminance"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(illuminanceData, illuminanceData + count); + + delete[] illuminanceData; + + return result; + } + + double GetIlluminanceDistance(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:IlluminanceDistance")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:IlluminanceDistance"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllIlluminanceDistance() + { + const auto count = GetCount(); + + double* illuminanceDistanceData = new double[count]; + if (mEntityTable.column_exists("double:IlluminanceDistance")) { + memcpy(illuminanceDistanceData, mEntityTable.mDataColumns["double:IlluminanceDistance"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(illuminanceDistanceData, illuminanceDistanceData + count); + + delete[] illuminanceDistanceData; + + return result; + } + + double GetInitialColorTemperature(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:InitialColorTemperature")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:InitialColorTemperature"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllInitialColorTemperature() + { + const auto count = GetCount(); + + double* initialColorTemperatureData = new double[count]; + if (mEntityTable.column_exists("double:InitialColorTemperature")) { + memcpy(initialColorTemperatureData, mEntityTable.mDataColumns["double:InitialColorTemperature"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(initialColorTemperatureData, initialColorTemperatureData + count); + + delete[] initialColorTemperatureData; + + return result; + } + + double GetColorFilter_X(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:ColorFilter.X")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:ColorFilter.X"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllColorFilter_X() + { + const auto count = GetCount(); + + double* colorFilter_XData = new double[count]; + if (mEntityTable.column_exists("double:ColorFilter.X")) { + memcpy(colorFilter_XData, mEntityTable.mDataColumns["double:ColorFilter.X"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(colorFilter_XData, colorFilter_XData + count); + + delete[] colorFilter_XData; + + return result; + } + + double GetColorFilter_Y(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:ColorFilter.Y")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:ColorFilter.Y"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllColorFilter_Y() + { + const auto count = GetCount(); + + double* colorFilter_YData = new double[count]; + if (mEntityTable.column_exists("double:ColorFilter.Y")) { + memcpy(colorFilter_YData, mEntityTable.mDataColumns["double:ColorFilter.Y"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(colorFilter_YData, colorFilter_YData + count); + + delete[] colorFilter_YData; + + return result; + } + + double GetColorFilter_Z(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:ColorFilter.Z")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:ColorFilter.Z"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllColorFilter_Z() + { + const auto count = GetCount(); + + double* colorFilter_ZData = new double[count]; + if (mEntityTable.column_exists("double:ColorFilter.Z")) { + memcpy(colorFilter_ZData, mEntityTable.mDataColumns["double:ColorFilter.Z"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(colorFilter_ZData, colorFilter_ZData + count); + + delete[] colorFilter_ZData; + + return result; + } + + double GetLossFactor(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:LossFactor")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:LossFactor"].begin() + lightTypeIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllLossFactor() + { + const auto count = GetCount(); + + double* lossFactorData = new double[count]; + if (mEntityTable.column_exists("double:LossFactor")) { + memcpy(lossFactorData, mEntityTable.mDataColumns["double:LossFactor"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(lossFactorData, lossFactorData + count); + + delete[] lossFactorData; + + return result; + } + + int GetDimmingColor(int lightTypeIndex) + { + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("int:DimmingColor")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["int:DimmingColor"].begin() + lightTypeIndex * sizeof(int))); + } + + return {}; + } + + std::vector* GetAllDimmingColor() + { + const auto count = GetCount(); + + int* dimmingColorData = new int[count]; + if (mEntityTable.column_exists("int:DimmingColor")) { + memcpy(dimmingColorData, mEntityTable.mDataColumns["int:DimmingColor"].begin(), count * sizeof(int)); + } + + std::vector* result = new std::vector(dimmingColorData, dimmingColorData + count); + + delete[] dimmingColorData; + + return result; + } + + int GetPhotometricWebFileIndex(int lightTypeIndex) + { + if (!mEntityTable.column_exists("index:Vim.Asset:PhotometricWebFile")) { + return -1; + } + + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return -1; + + return mEntityTable.mIndexColumns["index:Vim.Asset:PhotometricWebFile"][lightTypeIndex]; + } + + int GetFamilyTypeIndex(int lightTypeIndex) + { + if (!mEntityTable.column_exists("index:Vim.FamilyType:FamilyType")) { + return -1; + } + + if (lightTypeIndex < 0 || lightTypeIndex >= GetCount()) + return -1; + + return mEntityTable.mIndexColumns["index:Vim.FamilyType:FamilyType"][lightTypeIndex]; + } + + }; + + static LightTypeTable* GetLightTypeTable(Scene& scene) + { + if (scene.mEntityTables.find("Vim.LightType") == scene.mEntityTables.end()) + return {}; + + return new LightTypeTable(scene.mEntityTables["Vim.LightType"], scene.mStrings); + } + + class LightSource + { + public: + int mIndex; + double mOrigin_X; + double mOrigin_Y; + double mOrigin_Z; + double mBasisX_X; + double mBasisX_Y; + double mBasisX_Z; + double mBasisY_X; + double mBasisY_Y; + double mBasisY_Z; + double mBasisZ_X; + double mBasisZ_Y; + double mBasisZ_Z; + bool mHasLightSourceTransform; + bool mIsOn; + + int mLightTypeIndex; + LightType* mLightType; + int mElementIndex; + Element* mElement; + + LightSource() {} + }; + + class LightSourceTable + { + EntityTable& mEntityTable; + std::vector& mStrings; + public: + LightSourceTable(EntityTable& entityTable, std::vector& strings): + mEntityTable(entityTable), mStrings(strings) {} + + size_t GetCount() + { + return mEntityTable.get_count(); + } + + LightSource* Get(int lightSourceIndex) + { + LightSource* lightSource = new LightSource(); + lightSource->mIndex = lightSourceIndex; + lightSource->mOrigin_X = GetOrigin_X(lightSourceIndex); + lightSource->mOrigin_Y = GetOrigin_Y(lightSourceIndex); + lightSource->mOrigin_Z = GetOrigin_Z(lightSourceIndex); + lightSource->mBasisX_X = GetBasisX_X(lightSourceIndex); + lightSource->mBasisX_Y = GetBasisX_Y(lightSourceIndex); + lightSource->mBasisX_Z = GetBasisX_Z(lightSourceIndex); + lightSource->mBasisY_X = GetBasisY_X(lightSourceIndex); + lightSource->mBasisY_Y = GetBasisY_Y(lightSourceIndex); + lightSource->mBasisY_Z = GetBasisY_Z(lightSourceIndex); + lightSource->mBasisZ_X = GetBasisZ_X(lightSourceIndex); + lightSource->mBasisZ_Y = GetBasisZ_Y(lightSourceIndex); + lightSource->mBasisZ_Z = GetBasisZ_Z(lightSourceIndex); + lightSource->mHasLightSourceTransform = GetHasLightSourceTransform(lightSourceIndex); + lightSource->mIsOn = GetIsOn(lightSourceIndex); + lightSource->mLightTypeIndex = GetLightTypeIndex(lightSourceIndex); + lightSource->mElementIndex = GetElementIndex(lightSourceIndex); + return lightSource; + } + + std::vector* GetAll() + { + bool existsOrigin_X = mEntityTable.column_exists("double:Origin.X"); + bool existsOrigin_Y = mEntityTable.column_exists("double:Origin.Y"); + bool existsOrigin_Z = mEntityTable.column_exists("double:Origin.Z"); + bool existsBasisX_X = mEntityTable.column_exists("double:BasisX.X"); + bool existsBasisX_Y = mEntityTable.column_exists("double:BasisX.Y"); + bool existsBasisX_Z = mEntityTable.column_exists("double:BasisX.Z"); + bool existsBasisY_X = mEntityTable.column_exists("double:BasisY.X"); + bool existsBasisY_Y = mEntityTable.column_exists("double:BasisY.Y"); + bool existsBasisY_Z = mEntityTable.column_exists("double:BasisY.Z"); + bool existsBasisZ_X = mEntityTable.column_exists("double:BasisZ.X"); + bool existsBasisZ_Y = mEntityTable.column_exists("double:BasisZ.Y"); + bool existsBasisZ_Z = mEntityTable.column_exists("double:BasisZ.Z"); + bool existsHasLightSourceTransform = mEntityTable.column_exists("byte:HasLightSourceTransform"); + bool existsIsOn = mEntityTable.column_exists("byte:IsOn"); + bool existsLightType = mEntityTable.column_exists("index:Vim.LightType:LightType"); + bool existsElement = mEntityTable.column_exists("index:Vim.Element:Element"); + + const auto count = GetCount(); + + std::vector* lightSource = new std::vector(); + lightSource->reserve(count); + + double* origin_XData = new double[count]; + if (mEntityTable.column_exists("double:Origin.X")) { + memcpy(origin_XData, mEntityTable.mDataColumns["double:Origin.X"].begin(), count * sizeof(double)); + } + + double* origin_YData = new double[count]; + if (mEntityTable.column_exists("double:Origin.Y")) { + memcpy(origin_YData, mEntityTable.mDataColumns["double:Origin.Y"].begin(), count * sizeof(double)); + } + + double* origin_ZData = new double[count]; + if (mEntityTable.column_exists("double:Origin.Z")) { + memcpy(origin_ZData, mEntityTable.mDataColumns["double:Origin.Z"].begin(), count * sizeof(double)); + } + + double* basisX_XData = new double[count]; + if (mEntityTable.column_exists("double:BasisX.X")) { + memcpy(basisX_XData, mEntityTable.mDataColumns["double:BasisX.X"].begin(), count * sizeof(double)); + } + + double* basisX_YData = new double[count]; + if (mEntityTable.column_exists("double:BasisX.Y")) { + memcpy(basisX_YData, mEntityTable.mDataColumns["double:BasisX.Y"].begin(), count * sizeof(double)); + } + + double* basisX_ZData = new double[count]; + if (mEntityTable.column_exists("double:BasisX.Z")) { + memcpy(basisX_ZData, mEntityTable.mDataColumns["double:BasisX.Z"].begin(), count * sizeof(double)); + } + + double* basisY_XData = new double[count]; + if (mEntityTable.column_exists("double:BasisY.X")) { + memcpy(basisY_XData, mEntityTable.mDataColumns["double:BasisY.X"].begin(), count * sizeof(double)); + } + + double* basisY_YData = new double[count]; + if (mEntityTable.column_exists("double:BasisY.Y")) { + memcpy(basisY_YData, mEntityTable.mDataColumns["double:BasisY.Y"].begin(), count * sizeof(double)); + } + + double* basisY_ZData = new double[count]; + if (mEntityTable.column_exists("double:BasisY.Z")) { + memcpy(basisY_ZData, mEntityTable.mDataColumns["double:BasisY.Z"].begin(), count * sizeof(double)); + } + + double* basisZ_XData = new double[count]; + if (mEntityTable.column_exists("double:BasisZ.X")) { + memcpy(basisZ_XData, mEntityTable.mDataColumns["double:BasisZ.X"].begin(), count * sizeof(double)); + } + + double* basisZ_YData = new double[count]; + if (mEntityTable.column_exists("double:BasisZ.Y")) { + memcpy(basisZ_YData, mEntityTable.mDataColumns["double:BasisZ.Y"].begin(), count * sizeof(double)); + } + + double* basisZ_ZData = new double[count]; + if (mEntityTable.column_exists("double:BasisZ.Z")) { + memcpy(basisZ_ZData, mEntityTable.mDataColumns["double:BasisZ.Z"].begin(), count * sizeof(double)); + } + + bfast::byte* hasLightSourceTransformData = new bfast::byte[count]; + if (mEntityTable.column_exists("byte:HasLightSourceTransform")) { + memcpy(hasLightSourceTransformData, mEntityTable.mDataColumns["byte:HasLightSourceTransform"].begin(), count * sizeof(bfast::byte)); + } + + bfast::byte* isOnData = new bfast::byte[count]; + if (mEntityTable.column_exists("byte:IsOn")) { + memcpy(isOnData, mEntityTable.mDataColumns["byte:IsOn"].begin(), count * sizeof(bfast::byte)); + } + + const std::vector& lightTypeData = mEntityTable.column_exists("index:Vim.LightType:LightType") ? mEntityTable.mIndexColumns["index:Vim.LightType:LightType"] : std::vector(); + const std::vector& elementData = mEntityTable.column_exists("index:Vim.Element:Element") ? mEntityTable.mIndexColumns["index:Vim.Element:Element"] : std::vector(); + + for (int i = 0; i < count; ++i) + { + LightSource entity; + entity.mIndex = i; + if (existsOrigin_X) + entity.mOrigin_X = origin_XData[i]; + if (existsOrigin_Y) + entity.mOrigin_Y = origin_YData[i]; + if (existsOrigin_Z) + entity.mOrigin_Z = origin_ZData[i]; + if (existsBasisX_X) + entity.mBasisX_X = basisX_XData[i]; + if (existsBasisX_Y) + entity.mBasisX_Y = basisX_YData[i]; + if (existsBasisX_Z) + entity.mBasisX_Z = basisX_ZData[i]; + if (existsBasisY_X) + entity.mBasisY_X = basisY_XData[i]; + if (existsBasisY_Y) + entity.mBasisY_Y = basisY_YData[i]; + if (existsBasisY_Z) + entity.mBasisY_Z = basisY_ZData[i]; + if (existsBasisZ_X) + entity.mBasisZ_X = basisZ_XData[i]; + if (existsBasisZ_Y) + entity.mBasisZ_Y = basisZ_YData[i]; + if (existsBasisZ_Z) + entity.mBasisZ_Z = basisZ_ZData[i]; + if (existsHasLightSourceTransform) + entity.mHasLightSourceTransform = hasLightSourceTransformData[i]; + if (existsIsOn) + entity.mIsOn = isOnData[i]; + entity.mLightTypeIndex = existsLightType ? lightTypeData[i] : -1; + entity.mElementIndex = existsElement ? elementData[i] : -1; + lightSource->push_back(entity); + } + + delete[] origin_XData; + delete[] origin_YData; + delete[] origin_ZData; + delete[] basisX_XData; + delete[] basisX_YData; + delete[] basisX_ZData; + delete[] basisY_XData; + delete[] basisY_YData; + delete[] basisY_ZData; + delete[] basisZ_XData; + delete[] basisZ_YData; + delete[] basisZ_ZData; + delete[] hasLightSourceTransformData; + delete[] isOnData; + + return lightSource; + } + + double GetOrigin_X(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Origin.X")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Origin.X"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllOrigin_X() + { + const auto count = GetCount(); + + double* origin_XData = new double[count]; + if (mEntityTable.column_exists("double:Origin.X")) { + memcpy(origin_XData, mEntityTable.mDataColumns["double:Origin.X"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(origin_XData, origin_XData + count); + + delete[] origin_XData; + + return result; + } + + double GetOrigin_Y(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Origin.Y")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Origin.Y"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllOrigin_Y() + { + const auto count = GetCount(); + + double* origin_YData = new double[count]; + if (mEntityTable.column_exists("double:Origin.Y")) { + memcpy(origin_YData, mEntityTable.mDataColumns["double:Origin.Y"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(origin_YData, origin_YData + count); + + delete[] origin_YData; + + return result; + } + + double GetOrigin_Z(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Origin.Z")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Origin.Z"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllOrigin_Z() + { + const auto count = GetCount(); + + double* origin_ZData = new double[count]; + if (mEntityTable.column_exists("double:Origin.Z")) { + memcpy(origin_ZData, mEntityTable.mDataColumns["double:Origin.Z"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(origin_ZData, origin_ZData + count); + + delete[] origin_ZData; + + return result; + } + + double GetBasisX_X(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisX.X")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisX.X"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisX_X() + { + const auto count = GetCount(); + + double* basisX_XData = new double[count]; + if (mEntityTable.column_exists("double:BasisX.X")) { + memcpy(basisX_XData, mEntityTable.mDataColumns["double:BasisX.X"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisX_XData, basisX_XData + count); + + delete[] basisX_XData; + + return result; + } + + double GetBasisX_Y(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisX.Y")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisX.Y"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisX_Y() + { + const auto count = GetCount(); + + double* basisX_YData = new double[count]; + if (mEntityTable.column_exists("double:BasisX.Y")) { + memcpy(basisX_YData, mEntityTable.mDataColumns["double:BasisX.Y"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisX_YData, basisX_YData + count); + + delete[] basisX_YData; + + return result; + } + + double GetBasisX_Z(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisX.Z")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisX.Z"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisX_Z() + { + const auto count = GetCount(); + + double* basisX_ZData = new double[count]; + if (mEntityTable.column_exists("double:BasisX.Z")) { + memcpy(basisX_ZData, mEntityTable.mDataColumns["double:BasisX.Z"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisX_ZData, basisX_ZData + count); + + delete[] basisX_ZData; + + return result; + } + + double GetBasisY_X(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisY.X")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisY.X"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisY_X() + { + const auto count = GetCount(); + + double* basisY_XData = new double[count]; + if (mEntityTable.column_exists("double:BasisY.X")) { + memcpy(basisY_XData, mEntityTable.mDataColumns["double:BasisY.X"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisY_XData, basisY_XData + count); + + delete[] basisY_XData; + + return result; + } + + double GetBasisY_Y(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisY.Y")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisY.Y"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisY_Y() + { + const auto count = GetCount(); + + double* basisY_YData = new double[count]; + if (mEntityTable.column_exists("double:BasisY.Y")) { + memcpy(basisY_YData, mEntityTable.mDataColumns["double:BasisY.Y"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisY_YData, basisY_YData + count); + + delete[] basisY_YData; + + return result; + } + + double GetBasisY_Z(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisY.Z")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisY.Z"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisY_Z() + { + const auto count = GetCount(); + + double* basisY_ZData = new double[count]; + if (mEntityTable.column_exists("double:BasisY.Z")) { + memcpy(basisY_ZData, mEntityTable.mDataColumns["double:BasisY.Z"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisY_ZData, basisY_ZData + count); + + delete[] basisY_ZData; + + return result; + } + + double GetBasisZ_X(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisZ.X")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisZ.X"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisZ_X() + { + const auto count = GetCount(); + + double* basisZ_XData = new double[count]; + if (mEntityTable.column_exists("double:BasisZ.X")) { + memcpy(basisZ_XData, mEntityTable.mDataColumns["double:BasisZ.X"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisZ_XData, basisZ_XData + count); + + delete[] basisZ_XData; + + return result; + } + + double GetBasisZ_Y(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisZ.Y")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisZ.Y"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisZ_Y() + { + const auto count = GetCount(); + + double* basisZ_YData = new double[count]; + if (mEntityTable.column_exists("double:BasisZ.Y")) { + memcpy(basisZ_YData, mEntityTable.mDataColumns["double:BasisZ.Y"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisZ_YData, basisZ_YData + count); + + delete[] basisZ_YData; + + return result; + } + + double GetBasisZ_Z(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:BasisZ.Z")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:BasisZ.Z"].begin() + lightSourceIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllBasisZ_Z() + { + const auto count = GetCount(); + + double* basisZ_ZData = new double[count]; + if (mEntityTable.column_exists("double:BasisZ.Z")) { + memcpy(basisZ_ZData, mEntityTable.mDataColumns["double:BasisZ.Z"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(basisZ_ZData, basisZ_ZData + count); + + delete[] basisZ_ZData; + + return result; + } + + bool GetHasLightSourceTransform(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("byte:HasLightSourceTransform")) { + return static_cast(*reinterpret_cast(const_cast(mEntityTable.mDataColumns["byte:HasLightSourceTransform"].begin() + lightSourceIndex * sizeof(bfast::byte)))); + } + + return {}; + } + + std::vector* GetAllHasLightSourceTransform() + { + const auto count = GetCount(); + + bfast::byte* hasLightSourceTransformData = new bfast::byte[count]; + if (mEntityTable.column_exists("byte:HasLightSourceTransform")) { + memcpy(hasLightSourceTransformData, mEntityTable.mDataColumns["byte:HasLightSourceTransform"].begin(), count * sizeof(bfast::byte)); + } + + std::vector* result = new std::vector(hasLightSourceTransformData, hasLightSourceTransformData + count); + + delete[] hasLightSourceTransformData; + + return result; + } + + bool GetIsOn(int lightSourceIndex) + { + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("byte:IsOn")) { + return static_cast(*reinterpret_cast(const_cast(mEntityTable.mDataColumns["byte:IsOn"].begin() + lightSourceIndex * sizeof(bfast::byte)))); + } + + return {}; + } + + std::vector* GetAllIsOn() + { + const auto count = GetCount(); + + bfast::byte* isOnData = new bfast::byte[count]; + if (mEntityTable.column_exists("byte:IsOn")) { + memcpy(isOnData, mEntityTable.mDataColumns["byte:IsOn"].begin(), count * sizeof(bfast::byte)); + } + + std::vector* result = new std::vector(isOnData, isOnData + count); + + delete[] isOnData; + + return result; + } + + int GetLightTypeIndex(int lightSourceIndex) + { + if (!mEntityTable.column_exists("index:Vim.LightType:LightType")) { + return -1; + } + + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return -1; + + return mEntityTable.mIndexColumns["index:Vim.LightType:LightType"][lightSourceIndex]; + } + + int GetElementIndex(int lightSourceIndex) + { + if (!mEntityTable.column_exists("index:Vim.Element:Element")) { + return -1; + } + + if (lightSourceIndex < 0 || lightSourceIndex >= GetCount()) + return -1; + + return mEntityTable.mIndexColumns["index:Vim.Element:Element"][lightSourceIndex]; + } + + }; + + static LightSourceTable* GetLightSourceTable(Scene& scene) + { + if (scene.mEntityTables.find("Vim.LightSource") == scene.mEntityTables.end()) + return {}; + + return new LightSourceTable(scene.mEntityTables["Vim.LightSource"], scene.mStrings); + } + + class SunAndShadowSettings + { + public: + int mIndex; + std::string mSunAndShadowType; + bool mUsesDST; + std::string mActiveFrameTime; + std::string mStartDateAndTime; + std::string mEndDateAndTime; + int mActiveFrame; + int mNumberOfFrames; + double mAltitude; + double mAzimuth; + bool mRelativeToView; + + int mViewIndex; + View* mView; + + SunAndShadowSettings() {} + }; + + class SunAndShadowSettingsTable + { + EntityTable& mEntityTable; + std::vector& mStrings; + public: + SunAndShadowSettingsTable(EntityTable& entityTable, std::vector& strings): + mEntityTable(entityTable), mStrings(strings) {} + + size_t GetCount() + { + return mEntityTable.get_count(); + } + + SunAndShadowSettings* Get(int sunAndShadowSettingsIndex) + { + SunAndShadowSettings* sunAndShadowSettings = new SunAndShadowSettings(); + sunAndShadowSettings->mIndex = sunAndShadowSettingsIndex; + sunAndShadowSettings->mSunAndShadowType = GetSunAndShadowType(sunAndShadowSettingsIndex); + sunAndShadowSettings->mUsesDST = GetUsesDST(sunAndShadowSettingsIndex); + sunAndShadowSettings->mActiveFrameTime = GetActiveFrameTime(sunAndShadowSettingsIndex); + sunAndShadowSettings->mStartDateAndTime = GetStartDateAndTime(sunAndShadowSettingsIndex); + sunAndShadowSettings->mEndDateAndTime = GetEndDateAndTime(sunAndShadowSettingsIndex); + sunAndShadowSettings->mActiveFrame = GetActiveFrame(sunAndShadowSettingsIndex); + sunAndShadowSettings->mNumberOfFrames = GetNumberOfFrames(sunAndShadowSettingsIndex); + sunAndShadowSettings->mAltitude = GetAltitude(sunAndShadowSettingsIndex); + sunAndShadowSettings->mAzimuth = GetAzimuth(sunAndShadowSettingsIndex); + sunAndShadowSettings->mRelativeToView = GetRelativeToView(sunAndShadowSettingsIndex); + sunAndShadowSettings->mViewIndex = GetViewIndex(sunAndShadowSettingsIndex); + return sunAndShadowSettings; + } + + std::vector* GetAll() + { + bool existsSunAndShadowType = mEntityTable.column_exists("string:SunAndShadowType"); + bool existsUsesDST = mEntityTable.column_exists("byte:UsesDST"); + bool existsActiveFrameTime = mEntityTable.column_exists("string:ActiveFrameTime"); + bool existsStartDateAndTime = mEntityTable.column_exists("string:StartDateAndTime"); + bool existsEndDateAndTime = mEntityTable.column_exists("string:EndDateAndTime"); + bool existsActiveFrame = mEntityTable.column_exists("int:ActiveFrame"); + bool existsNumberOfFrames = mEntityTable.column_exists("int:NumberOfFrames"); + bool existsAltitude = mEntityTable.column_exists("double:Altitude"); + bool existsAzimuth = mEntityTable.column_exists("double:Azimuth"); + bool existsRelativeToView = mEntityTable.column_exists("byte:RelativeToView"); + bool existsView = mEntityTable.column_exists("index:Vim.View:View"); + + const auto count = GetCount(); + + std::vector* sunAndShadowSettings = new std::vector(); + sunAndShadowSettings->reserve(count); + + const std::vector& sunAndShadowTypeData = mEntityTable.column_exists("string:SunAndShadowType") ? mEntityTable.mStringColumns["string:SunAndShadowType"] : std::vector(); + + bfast::byte* usesDSTData = new bfast::byte[count]; + if (mEntityTable.column_exists("byte:UsesDST")) { + memcpy(usesDSTData, mEntityTable.mDataColumns["byte:UsesDST"].begin(), count * sizeof(bfast::byte)); + } + + const std::vector& activeFrameTimeData = mEntityTable.column_exists("string:ActiveFrameTime") ? mEntityTable.mStringColumns["string:ActiveFrameTime"] : std::vector(); + + const std::vector& startDateAndTimeData = mEntityTable.column_exists("string:StartDateAndTime") ? mEntityTable.mStringColumns["string:StartDateAndTime"] : std::vector(); + + const std::vector& endDateAndTimeData = mEntityTable.column_exists("string:EndDateAndTime") ? mEntityTable.mStringColumns["string:EndDateAndTime"] : std::vector(); + + int* activeFrameData = new int[count]; + if (mEntityTable.column_exists("int:ActiveFrame")) { + memcpy(activeFrameData, mEntityTable.mDataColumns["int:ActiveFrame"].begin(), count * sizeof(int)); + } + + int* numberOfFramesData = new int[count]; + if (mEntityTable.column_exists("int:NumberOfFrames")) { + memcpy(numberOfFramesData, mEntityTable.mDataColumns["int:NumberOfFrames"].begin(), count * sizeof(int)); + } + + double* altitudeData = new double[count]; + if (mEntityTable.column_exists("double:Altitude")) { + memcpy(altitudeData, mEntityTable.mDataColumns["double:Altitude"].begin(), count * sizeof(double)); + } + + double* azimuthData = new double[count]; + if (mEntityTable.column_exists("double:Azimuth")) { + memcpy(azimuthData, mEntityTable.mDataColumns["double:Azimuth"].begin(), count * sizeof(double)); + } + + bfast::byte* relativeToViewData = new bfast::byte[count]; + if (mEntityTable.column_exists("byte:RelativeToView")) { + memcpy(relativeToViewData, mEntityTable.mDataColumns["byte:RelativeToView"].begin(), count * sizeof(bfast::byte)); + } + + const std::vector& viewData = mEntityTable.column_exists("index:Vim.View:View") ? mEntityTable.mIndexColumns["index:Vim.View:View"] : std::vector(); + + for (int i = 0; i < count; ++i) + { + SunAndShadowSettings entity; + entity.mIndex = i; + if (existsSunAndShadowType) + entity.mSunAndShadowType = std::string(reinterpret_cast(mStrings[sunAndShadowTypeData[i]])); + if (existsUsesDST) + entity.mUsesDST = usesDSTData[i]; + if (existsActiveFrameTime) + entity.mActiveFrameTime = std::string(reinterpret_cast(mStrings[activeFrameTimeData[i]])); + if (existsStartDateAndTime) + entity.mStartDateAndTime = std::string(reinterpret_cast(mStrings[startDateAndTimeData[i]])); + if (existsEndDateAndTime) + entity.mEndDateAndTime = std::string(reinterpret_cast(mStrings[endDateAndTimeData[i]])); + if (existsActiveFrame) + entity.mActiveFrame = activeFrameData[i]; + if (existsNumberOfFrames) + entity.mNumberOfFrames = numberOfFramesData[i]; + if (existsAltitude) + entity.mAltitude = altitudeData[i]; + if (existsAzimuth) + entity.mAzimuth = azimuthData[i]; + if (existsRelativeToView) + entity.mRelativeToView = relativeToViewData[i]; + entity.mViewIndex = existsView ? viewData[i] : -1; + sunAndShadowSettings->push_back(entity); + } + + delete[] usesDSTData; + delete[] activeFrameData; + delete[] numberOfFramesData; + delete[] altitudeData; + delete[] azimuthData; + delete[] relativeToViewData; + + return sunAndShadowSettings; + } + + std::string GetSunAndShadowType(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("string:SunAndShadowType")) { + return std::string(reinterpret_cast(mStrings[mEntityTable.mStringColumns["string:SunAndShadowType"][sunAndShadowSettingsIndex]])); + } + + return {}; + } + + std::vector* GetAllSunAndShadowType() + { + const auto count = GetCount(); + + const std::vector& sunAndShadowTypeData = mEntityTable.column_exists("string:SunAndShadowType") ? mEntityTable.mStringColumns["string:SunAndShadowType"] : std::vector(); + + std::vector* result = new std::vector(); + result->reserve(count); + + for (int i = 0; i < count; ++i) + { + result->push_back(std::string(reinterpret_cast(mStrings[sunAndShadowTypeData[i]]))); + } + + return result; + } + + bool GetUsesDST(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("byte:UsesDST")) { + return static_cast(*reinterpret_cast(const_cast(mEntityTable.mDataColumns["byte:UsesDST"].begin() + sunAndShadowSettingsIndex * sizeof(bfast::byte)))); + } + + return {}; + } + + std::vector* GetAllUsesDST() + { + const auto count = GetCount(); + + bfast::byte* usesDSTData = new bfast::byte[count]; + if (mEntityTable.column_exists("byte:UsesDST")) { + memcpy(usesDSTData, mEntityTable.mDataColumns["byte:UsesDST"].begin(), count * sizeof(bfast::byte)); + } + + std::vector* result = new std::vector(usesDSTData, usesDSTData + count); + + delete[] usesDSTData; + + return result; + } + + std::string GetActiveFrameTime(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("string:ActiveFrameTime")) { + return std::string(reinterpret_cast(mStrings[mEntityTable.mStringColumns["string:ActiveFrameTime"][sunAndShadowSettingsIndex]])); + } + + return {}; + } + + std::vector* GetAllActiveFrameTime() + { + const auto count = GetCount(); + + const std::vector& activeFrameTimeData = mEntityTable.column_exists("string:ActiveFrameTime") ? mEntityTable.mStringColumns["string:ActiveFrameTime"] : std::vector(); + + std::vector* result = new std::vector(); + result->reserve(count); + + for (int i = 0; i < count; ++i) + { + result->push_back(std::string(reinterpret_cast(mStrings[activeFrameTimeData[i]]))); + } + + return result; + } + + std::string GetStartDateAndTime(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("string:StartDateAndTime")) { + return std::string(reinterpret_cast(mStrings[mEntityTable.mStringColumns["string:StartDateAndTime"][sunAndShadowSettingsIndex]])); + } + + return {}; + } + + std::vector* GetAllStartDateAndTime() + { + const auto count = GetCount(); + + const std::vector& startDateAndTimeData = mEntityTable.column_exists("string:StartDateAndTime") ? mEntityTable.mStringColumns["string:StartDateAndTime"] : std::vector(); + + std::vector* result = new std::vector(); + result->reserve(count); + + for (int i = 0; i < count; ++i) + { + result->push_back(std::string(reinterpret_cast(mStrings[startDateAndTimeData[i]]))); + } + + return result; + } + + std::string GetEndDateAndTime(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("string:EndDateAndTime")) { + return std::string(reinterpret_cast(mStrings[mEntityTable.mStringColumns["string:EndDateAndTime"][sunAndShadowSettingsIndex]])); + } + + return {}; + } + + std::vector* GetAllEndDateAndTime() + { + const auto count = GetCount(); + + const std::vector& endDateAndTimeData = mEntityTable.column_exists("string:EndDateAndTime") ? mEntityTable.mStringColumns["string:EndDateAndTime"] : std::vector(); + + std::vector* result = new std::vector(); + result->reserve(count); + + for (int i = 0; i < count; ++i) + { + result->push_back(std::string(reinterpret_cast(mStrings[endDateAndTimeData[i]]))); + } + + return result; + } + + int GetActiveFrame(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("int:ActiveFrame")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["int:ActiveFrame"].begin() + sunAndShadowSettingsIndex * sizeof(int))); + } + + return {}; + } + + std::vector* GetAllActiveFrame() + { + const auto count = GetCount(); + + int* activeFrameData = new int[count]; + if (mEntityTable.column_exists("int:ActiveFrame")) { + memcpy(activeFrameData, mEntityTable.mDataColumns["int:ActiveFrame"].begin(), count * sizeof(int)); + } + + std::vector* result = new std::vector(activeFrameData, activeFrameData + count); + + delete[] activeFrameData; + + return result; + } + + int GetNumberOfFrames(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("int:NumberOfFrames")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["int:NumberOfFrames"].begin() + sunAndShadowSettingsIndex * sizeof(int))); + } + + return {}; + } + + std::vector* GetAllNumberOfFrames() + { + const auto count = GetCount(); + + int* numberOfFramesData = new int[count]; + if (mEntityTable.column_exists("int:NumberOfFrames")) { + memcpy(numberOfFramesData, mEntityTable.mDataColumns["int:NumberOfFrames"].begin(), count * sizeof(int)); + } + + std::vector* result = new std::vector(numberOfFramesData, numberOfFramesData + count); + + delete[] numberOfFramesData; + + return result; + } + + double GetAltitude(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Altitude")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Altitude"].begin() + sunAndShadowSettingsIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllAltitude() + { + const auto count = GetCount(); + + double* altitudeData = new double[count]; + if (mEntityTable.column_exists("double:Altitude")) { + memcpy(altitudeData, mEntityTable.mDataColumns["double:Altitude"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(altitudeData, altitudeData + count); + + delete[] altitudeData; + + return result; + } + + double GetAzimuth(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("double:Azimuth")) { + return *reinterpret_cast(const_cast(mEntityTable.mDataColumns["double:Azimuth"].begin() + sunAndShadowSettingsIndex * sizeof(double))); + } + + return {}; + } + + std::vector* GetAllAzimuth() + { + const auto count = GetCount(); + + double* azimuthData = new double[count]; + if (mEntityTable.column_exists("double:Azimuth")) { + memcpy(azimuthData, mEntityTable.mDataColumns["double:Azimuth"].begin(), count * sizeof(double)); + } + + std::vector* result = new std::vector(azimuthData, azimuthData + count); + + delete[] azimuthData; + + return result; + } + + bool GetRelativeToView(int sunAndShadowSettingsIndex) + { + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return {}; + + if (mEntityTable.column_exists("byte:RelativeToView")) { + return static_cast(*reinterpret_cast(const_cast(mEntityTable.mDataColumns["byte:RelativeToView"].begin() + sunAndShadowSettingsIndex * sizeof(bfast::byte)))); + } + + return {}; + } + + std::vector* GetAllRelativeToView() + { + const auto count = GetCount(); + + bfast::byte* relativeToViewData = new bfast::byte[count]; + if (mEntityTable.column_exists("byte:RelativeToView")) { + memcpy(relativeToViewData, mEntityTable.mDataColumns["byte:RelativeToView"].begin(), count * sizeof(bfast::byte)); + } + + std::vector* result = new std::vector(relativeToViewData, relativeToViewData + count); + + delete[] relativeToViewData; + + return result; + } + + int GetViewIndex(int sunAndShadowSettingsIndex) + { + if (!mEntityTable.column_exists("index:Vim.View:View")) { + return -1; + } + + if (sunAndShadowSettingsIndex < 0 || sunAndShadowSettingsIndex >= GetCount()) + return -1; + + return mEntityTable.mIndexColumns["index:Vim.View:View"][sunAndShadowSettingsIndex]; + } + + }; + + static SunAndShadowSettingsTable* GetSunAndShadowSettingsTable(Scene& scene) + { + if (scene.mEntityTables.find("Vim.SunAndShadowSettings") == scene.mEntityTables.end()) + return {}; + + return new SunAndShadowSettingsTable(scene.mEntityTables["Vim.SunAndShadowSettings"], scene.mStrings); + } + DocumentModel::DocumentModel(Scene& scene) { mAsset = GetAssetTable(scene); @@ -14284,6 +16339,9 @@ namespace Vim mViewInViewSheet = GetViewInViewSheetTable(scene); mSite = GetSiteTable(scene); mBuilding = GetBuildingTable(scene); + mLightType = GetLightTypeTable(scene); + mLightSource = GetLightSourceTable(scene); + mSunAndShadowSettings = GetSunAndShadowSettingsTable(scene); } DocumentModel::~DocumentModel() @@ -14342,6 +16400,9 @@ namespace Vim delete mViewInViewSheet; delete mSite; delete mBuilding; + delete mLightType; + delete mLightSource; + delete mSunAndShadowSettings; } } diff --git a/src/cs/vim/Vim.Format.Core/AssetInfo.cs b/src/cs/vim/Vim.Format.Core/AssetInfo.cs index 304851af..ccd96e94 100644 --- a/src/cs/vim/Vim.Format.Core/AssetInfo.cs +++ b/src/cs/vim/Vim.Format.Core/AssetInfo.cs @@ -12,9 +12,10 @@ public enum AssetType Texture, Render, /// - /// Light sources for rendering: "light/lights.json" (one record per light source - its element, world - /// position and axes, emitter shape, distribution, intensity, colour temperature) and the photometric - /// profiles it names, "light/<file>.ies" (IESNA LM-63 text, as Revit's lighting families carry them). + /// Photometric web files, "light/<file>.ies" (IESNA LM-63 text, as Revit's lighting families carry them), + /// referenced by LightType.PhotometricWebFile. Since object model 5.8.0 the light sources themselves are entities + /// (LightType, LightSource, SunAndShadowSettings). Files exported before 5.8.0 may carry "light/lights.json" and + /// "light/sun.json" instead. /// Light, /// diff --git a/src/cs/vim/Vim.Format.Core/VimConstants.cs b/src/cs/vim/Vim.Format.Core/VimConstants.cs index 72867a68..4b738a22 100644 --- a/src/cs/vim/Vim.Format.Core/VimConstants.cs +++ b/src/cs/vim/Vim.Format.Core/VimConstants.cs @@ -68,6 +68,9 @@ public static class TableNames public const string ViewInViewSheet = "Vim.ViewInViewSheet"; public const string Site = "Vim.Site"; public const string Building = "Vim.Building"; + public const string LightType = "Vim.LightType"; + public const string LightSource = "Vim.LightSource"; + public const string SunAndShadowSettings = "Vim.SunAndShadowSettings"; } public static class VimConstants diff --git a/src/cs/vim/Vim.Format.Tests/LightEntityTests.cs b/src/cs/vim/Vim.Format.Tests/LightEntityTests.cs new file mode 100644 index 00000000..1bbde7d9 --- /dev/null +++ b/src/cs/vim/Vim.Format.Tests/LightEntityTests.cs @@ -0,0 +1,202 @@ +using System.IO; +using System.Linq; +using System.Text; +using NUnit.Framework; +using Vim.Format.Merge; +using Vim.Format.ObjectModel; +using Vim.Format.SceneBuilder; +using Vim.LinqArray; +using Vim.Math3d; +using Vim.Util.Tests; + +namespace Vim.Format.Tests +{ + /// + /// The light entities (LightType, LightSource, SunAndShadowSettings) round-trip through a VIM file and merge like the + /// other entity tables: their relations are offset by the merge. + /// + [TestFixture] + public static class LightEntityTests + { + private const string IesBufferName = "light/a1137_1300lm.ies"; + + /// + /// Writes a VIM with one view, one lighting family type, two fixtures (each with a light source), one IES asset and a sun. + /// + private static string WriteLightVim(string dir, string fileName) + { + var store = new ObjectModelStore(); + var omb = store.ObjectModelBuilder; + + var bimDocument = new BimDocument { Name = "Lights", Title = "Lights" }; + var bimDocumentElement = omb.ElementBuilder.Add(bimDocument.CreateParameterHolderElement()).Entity; + bimDocument._Element.Index = bimDocumentElement.Index; + omb.BimDocumentBuilder.Add(bimDocument); + + var viewElement = omb.ElementBuilder.Add(new Element { Id = 10, Name = "{3D}", UniqueId = "view" }).Entity; + var view = new Format.ObjectModel.View { Title = "{3D}", ViewType = "ThreeD" }; + view._Element.Index = viewElement.Index; + omb.ViewBuilder.Add(view); + + var typeElement = omb.ElementBuilder.Add(new Element { Id = 20, Name = "Downlight", UniqueId = "type" }).Entity; + var familyType = new FamilyType(); + familyType._Element.Index = typeElement.Index; + omb.FamilyTypeBuilder.Add(familyType); + + var fixture1 = omb.ElementBuilder.Add(new Element { Id = 30, Name = "Downlight", UniqueId = "fixture1" }).Entity; + var fixture2 = omb.ElementBuilder.Add(new Element { Id = 31, Name = "Downlight", UniqueId = "fixture2" }).Entity; + + var asset = omb.AssetBuilder.Add(new Asset { BufferName = IesBufferName }).Entity; + + var lightType = new LightType + { + LightShapeStyle = (int) LightShapeStyle.Circle, + EmitDiameter = 0.5, + LightDistributionStyle = (int) LightDistributionStyle.PhotometricWeb, + TiltAngle = 1.5708, + PhotometricWebFileName = "A1137 1300Lm.IES", + InitialIntensityType = (int) InitialIntensityType.Flux, + Flux = 1300, + InitialColorTemperature = 3000, + ColorFilter = new DVector3(1, 0.9, 0.8), + LossFactor = 0.85, + DimmingColor = (int) LightDimmingColor.Incandescent, + }; + lightType._PhotometricWebFile.Index = asset.Index; + lightType._FamilyType.Index = familyType.Index; + omb.LightTypeBuilder.Add(lightType); + + foreach (var (fixture, x) in new[] { (fixture1, 1.0), (fixture2, 2.0) }) + { + var lightSource = new LightSource + { + Origin = new DVector3(x, 2, 9), + BasisX = new DVector3(1, 0, 0), + BasisY = new DVector3(0, 1, 0), + BasisZ = new DVector3(0, 0, 1), + HasLightSourceTransform = true, + IsOn = x < 1.5, + }; + lightSource._Element.Index = fixture.Index; + lightSource._LightType.Index = lightType.Index; + omb.LightSourceBuilder.Add(lightSource); + } + + var sun = new SunAndShadowSettings + { + SunAndShadowType = "StillImage", + UsesDST = true, + ActiveFrameTime = "2026-06-21T12:00:00", + StartDateAndTime = "2026-06-21T12:00:00", + EndDateAndTime = "2026-06-21T12:00:00", + ActiveFrame = 1, + NumberOfFrames = 1, + Altitude = 1.2, + Azimuth = 3.1, + }; + sun._View.Index = view.Index; + omb.SunAndShadowSettingsBuilder.Add(sun); + + var documentBuilder = store.ToDocumentBuilder(nameof(LightEntityTests), "0.0.0"); + documentBuilder.Assets[IesBufferName] = Encoding.UTF8.GetBytes("IESNA:LM-63-2002\n"); + + var path = Path.Combine(dir, fileName); + documentBuilder.Write(path); + return path; + } + + [Test] + public static void TestLightEntitiesRoundTrip() + { + var ctx = new CallerTestContext(); + var dir = ctx.PrepareDirectory(); + var path = WriteLightVim(dir, "lights.vim"); + + var vim = VimScene.LoadVim(path); + vim.Validate(); + var dm = vim.DocumentModel; + + Assert.AreEqual(SchemaVersion.Current.ToString(), vim.Document.Header.Schema.ToString()); + Assert.AreEqual(1, dm.NumLightType); + Assert.AreEqual(2, dm.NumLightSource); + Assert.AreEqual(1, dm.NumSunAndShadowSettings); + + var lightType = dm.GetLightType(0); + Assert.AreEqual(LightShapeStyle.Circle, lightType.GetLightShapeStyle()); + Assert.AreEqual(LightDistributionStyle.PhotometricWeb, lightType.GetLightDistributionStyle()); + Assert.AreEqual(InitialIntensityType.Flux, lightType.GetInitialIntensityType()); + Assert.AreEqual(LightDimmingColor.Incandescent, lightType.GetDimmingColor()); + Assert.AreEqual(1300, lightType.Flux); + Assert.AreEqual(1.5708, lightType.TiltAngle); + Assert.AreEqual(new DVector3(1, 0.9, 0.8), lightType.ColorFilter); + Assert.AreEqual("A1137 1300Lm.IES", lightType.PhotometricWebFileName); + Assert.AreEqual(IesBufferName, lightType.PhotometricWebFile.BufferName); + Assert.AreEqual("Downlight", lightType.FamilyType.Element.Name); + Assert.IsTrue(vim.Document.Assets.Keys.ToEnumerable().Contains(IesBufferName)); + + var lightSource = dm.GetLightSource(1); + Assert.AreEqual(new DVector3(2, 2, 9), lightSource.Origin); + Assert.AreEqual(new DVector3(0, 0, 1), lightSource.BasisZ); + Assert.IsTrue(lightSource.HasLightSourceTransform); + Assert.IsFalse(lightSource.IsOn); + Assert.AreEqual("fixture2", lightSource.Element.UniqueId); + Assert.AreEqual(0, lightSource.LightType.Index); + + var sun = dm.GetSunAndShadowSettings(0); + Assert.AreEqual("StillImage", sun.SunAndShadowType); + Assert.AreEqual(3.1, sun.Azimuth); + Assert.AreEqual("{3D}", sun.View.Title); + } + + [Test] + public static void TestLightEntitiesMerge() + { + var ctx = new CallerTestContext(); + var dir = ctx.PrepareDirectory(); + var path1 = WriteLightVim(dir, "lights1.vim"); + var path2 = WriteLightVim(dir, "lights2.vim"); + var mergedPath = Path.Combine(dir, "merged.vim"); + + MergeService.MergeVimFiles( + new MergeConfigFiles(new[] { (path1, Matrix4x4.Identity), (path2, Matrix4x4.Identity) }, mergedPath), + new MergeConfigOptions { GeneratorString = ctx.TestName, VersionString = "0.0.0", DeduplicateEntities = false, KeepBimData = true }); + + var merged = VimScene.LoadVim(mergedPath); + merged.Validate(); + var dm = merged.DocumentModel; + var source = VimScene.LoadVim(path1).DocumentModel; + var numElementsPerFile = source.NumElement; + var fixture2ElementIndex = source.GetLightSource(1).Element.Index; + + Assert.AreEqual(2, dm.NumLightType); + Assert.AreEqual(4, dm.NumLightSource); + Assert.AreEqual(2, dm.NumSunAndShadowSettings); + + // The second file's rows point at the second file's entities. + var lightSource = dm.GetLightSource(3); + Assert.AreEqual(1, lightSource.LightType.Index); + Assert.AreEqual(numElementsPerFile + fixture2ElementIndex, lightSource.Element.Index); + Assert.AreEqual("fixture2", lightSource.Element.UniqueId); + + var lightType = dm.GetLightType(1); + Assert.AreEqual(1, lightType.PhotometricWebFile.Index); + Assert.AreEqual(IesBufferName, lightType.PhotometricWebFile.BufferName); + Assert.AreEqual(1, lightType.FamilyType.Index); + + Assert.AreEqual(1, dm.GetSunAndShadowSettings(1).View.Index); + + // The two files carry the same IES file under the same name: the merged file keeps one buffer. + Assert.AreEqual(1, merged.Document.Assets.Keys.ToEnumerable().Count(k => k == IesBufferName)); + + // With deduplication (the merge verb's default), the light sources stay distinct: they point at different elements. + var dedupPath = Path.Combine(dir, "merged_dedup.vim"); + MergeService.MergeVimFiles( + new MergeConfigFiles(new[] { (path1, Matrix4x4.Identity), (path2, Matrix4x4.Identity) }, dedupPath), + new MergeConfigOptions { GeneratorString = ctx.TestName, VersionString = "0.0.0", DeduplicateEntities = true, KeepBimData = true }); + var dedup = VimScene.LoadVim(dedupPath); + dedup.Validate(); + Assert.AreEqual(4, dedup.DocumentModel.NumLightSource); + Assert.IsTrue(dedup.DocumentModel.LightSourceList.ToEnumerable().All(ls => ls.LightType != null && ls.Element != null)); + } + } +} diff --git a/src/cs/vim/Vim.Format/ObjectModel/ObjectModel.cs b/src/cs/vim/Vim.Format/ObjectModel/ObjectModel.cs index ddcf8846..ceaa36a8 100644 --- a/src/cs/vim/Vim.Format/ObjectModel/ObjectModel.cs +++ b/src/cs/vim/Vim.Format/ObjectModel/ObjectModel.cs @@ -14,6 +14,60 @@ public static class SchemaVersion // ReSharper disable MemberHidesStaticFromOuterClass public static class History { + // Schema additions (light sources and the sun, previously written as "light/lights.json" and "light/sun.json" assets) + // Vim.LightSource__byte:HasLightSourceTransform + // Vim.LightSource__byte:IsOn + // Vim.LightSource__double:BasisX.X + // Vim.LightSource__double:BasisX.Y + // Vim.LightSource__double:BasisX.Z + // Vim.LightSource__double:BasisY.X + // Vim.LightSource__double:BasisY.Y + // Vim.LightSource__double:BasisY.Z + // Vim.LightSource__double:BasisZ.X + // Vim.LightSource__double:BasisZ.Y + // Vim.LightSource__double:BasisZ.Z + // Vim.LightSource__double:Origin.X + // Vim.LightSource__double:Origin.Y + // Vim.LightSource__double:Origin.Z + // Vim.LightSource__index:Vim.Element:Element + // Vim.LightSource__index:Vim.LightType:LightType + // Vim.LightType__double:ColorFilter.X + // Vim.LightType__double:ColorFilter.Y + // Vim.LightType__double:ColorFilter.Z + // Vim.LightType__double:Efficacy + // Vim.LightType__double:EmitDiameter + // Vim.LightType__double:EmitLength + // Vim.LightType__double:EmitWidth + // Vim.LightType__double:Flux + // Vim.LightType__double:Illuminance + // Vim.LightType__double:IlluminanceDistance + // Vim.LightType__double:InitialColorTemperature + // Vim.LightType__double:LossFactor + // Vim.LightType__double:Luminosity + // Vim.LightType__double:SpotBeamAngle + // Vim.LightType__double:SpotFieldAngle + // Vim.LightType__double:TiltAngle + // Vim.LightType__double:Wattage + // Vim.LightType__index:Vim.Asset:PhotometricWebFile + // Vim.LightType__index:Vim.FamilyType:FamilyType + // Vim.LightType__int:DimmingColor + // Vim.LightType__int:InitialIntensityType + // Vim.LightType__int:LightDistributionStyle + // Vim.LightType__int:LightShapeStyle + // Vim.LightType__string:PhotometricWebFileName + // Vim.SunAndShadowSettings__byte:RelativeToView + // Vim.SunAndShadowSettings__byte:UsesDST + // Vim.SunAndShadowSettings__double:Altitude + // Vim.SunAndShadowSettings__double:Azimuth + // Vim.SunAndShadowSettings__index:Vim.View:View + // Vim.SunAndShadowSettings__int:ActiveFrame + // Vim.SunAndShadowSettings__int:NumberOfFrames + // Vim.SunAndShadowSettings__string:ActiveFrameTime + // Vim.SunAndShadowSettings__string:EndDateAndTime + // Vim.SunAndShadowSettings__string:StartDateAndTime + // Vim.SunAndShadowSettings__string:SunAndShadowType + public const string v5_8_0 = "5.8.0"; + // Schema additions // Vim.Element__string:Creator // Vim.Element__string:LastChangedBy @@ -186,7 +240,8 @@ public static class History // ReSharper enable MemberHidesStaticFromOuterClass // [MAINTAIN] Add more object model SerializableVersions below and update the current one. - public static SerializableVersion Current => v5_7_0; + public static SerializableVersion Current => v5_8_0; + public static SerializableVersion v5_8_0 => SerializableVersion.Parse(History.v5_8_0); public static SerializableVersion v5_7_0 => SerializableVersion.Parse(History.v5_7_0); public static SerializableVersion v5_6_0 => SerializableVersion.Parse(History.v5_6_0); public static SerializableVersion v5_5_0 => SerializableVersion.Parse(History.v5_5_0); @@ -2149,6 +2204,351 @@ public partial class Building : EntityWithElement public Relation _Site; } + /// + /// The shape of a light's emitter. Maps to Revit's LightShapeStyle (LightType.GetLightShape()). + /// + public enum LightShapeStyle + { + Unknown = 0, + Point = 1, + Line = 2, + Rectangle = 3, + Circle = 4, + } + + /// + /// The distribution of a light. Maps to Revit's LightDistributionStyle (LightType.GetLightDistribution()). + /// + public enum LightDistributionStyle + { + Unknown = 0, + Spherical = 1, + Hemispherical = 2, + Spot = 3, + PhotometricWeb = 4, + } + + /// + /// How the initial intensity of a light is defined. Maps to the subclass of Revit's InitialIntensity (LightType.GetInitialIntensity()). + /// + public enum InitialIntensityType + { + Unknown = 0, + /// InitialLuminousIntensity: LightType.Luminosity applies. + LuminousIntensity = 1, + /// InitialFluxIntensity: LightType.Flux applies. + Flux = 2, + /// InitialWattageIntensity: LightType.Wattage and LightType.Efficacy apply. + Wattage = 3, + /// InitialIlluminanceIntensity: LightType.Illuminance and LightType.IlluminanceDistance apply. + Illuminance = 4, + /// + /// The Revit Lighting API refused the family; the values were read from the family type's FBX_LIGHT_* built-in parameters. + /// Any of Luminosity, Flux, Wattage, Efficacy and Illuminance may be set (0 when the parameter is absent). + /// + TypeParameters = 5, + } + + /// + /// The dimming behaviour of a light. Maps to Revit's LightDimmingColor (LightType.DimmingColor). + /// + public enum LightDimmingColor + { + Unknown = 0, + None = 1, + Incandescent = 2, + } + + /// + /// Represents the photometric definition of a lighting FamilyType: its emitter shape, its distribution, its initial + /// intensity and its color. All the FamilyInstances of the FamilyType share it; each of them has a LightSource.
+ /// Revit: maps to Autodesk.Revit.DB.Lighting.LightType (LightType.GetLightTypeFromInstance).
+ /// Units: the Revit Lighting API returns SI values (cd, lm, W, lm/W, lx, K), with lengths in feet and angles in radians; + /// they are stored as they are. A value which does not apply to the shape, the distribution or the intensity type is 0. + /// + [TableName(TableNames.LightType)] + public partial class LightType : Entity + { + /// + /// The integer representation of the LightShapeStyle enum (LightType.GetLightShape()). + /// + public int LightShapeStyle; + + public LightShapeStyle GetLightShapeStyle() + => (LightShapeStyle) LightShapeStyle; + + /// + /// The emit length in feet, for a Line or a Rectangle shape (LineLightShape.EmitLength, RectangleLightShape.EmitLength). + /// + public double EmitLength; + + /// + /// The emit width in feet, for a Rectangle shape (RectangleLightShape.EmitWidth). + /// + public double EmitWidth; + + /// + /// The emit diameter in feet, for a Circle shape (CircleLightShape.EmitDiameter). + /// + public double EmitDiameter; + + /// + /// The integer representation of the LightDistributionStyle enum (LightType.GetLightDistribution()). + /// + public int LightDistributionStyle; + + public LightDistributionStyle GetLightDistributionStyle() + => (LightDistributionStyle) LightDistributionStyle; + + /// + /// The spot beam angle in radians, for a Spot distribution (SpotLightDistribution.SpotBeamAngle). + /// + public double SpotBeamAngle; + + /// + /// The spot field angle in radians, for a Spot distribution (SpotLightDistribution.SpotFieldAngle). + /// + public double SpotFieldAngle; + + /// + /// The tilt angle in radians, for a Spot or a PhotometricWeb distribution (SpotLightDistribution.TiltAngle, PhotometricWebLightDistribution.TiltAngle). + /// Note: RevitAPI.xml says PhotometricWebLightDistribution.TiltAngle is in degrees; measured on Revit 2027, it returns radians. + /// + public double TiltAngle; + + /// + /// The photometric web (IES) file name, as Revit names it (PhotometricWebLightDistribution.PhotometricWebFile, or the + /// FBX_LIGHT_PHOTOMETRIC_FILE parameter). Kept even when the file itself could not be found. + /// + public string PhotometricWebFileName; + + /// + /// The asset holding the photometric web file's bytes as they are (IESNA LM-63 text), or none if the file could not be + /// found. Read from the family type's cache (the FBX_LIGHT_PHOTOMETRIC_FILE_CACHE parameter), else from the disk. + /// Light types which use the same file share the same asset. + /// + public Relation _PhotometricWebFile; + + /// + /// The integer representation of the InitialIntensityType enum (LightType.GetInitialIntensity()). + /// + public int InitialIntensityType; + + public InitialIntensityType GetInitialIntensityType() + => (InitialIntensityType) InitialIntensityType; + + /// + /// The luminous intensity in candelas (InitialLuminousIntensity.Luminosity). + /// + public double Luminosity; + + /// + /// The luminous flux in lumens (InitialFluxIntensity.Flux). + /// + public double Flux; + + /// + /// The wattage in watts (InitialWattageIntensity.Wattage). + /// + public double Wattage; + + /// + /// The efficacy in lumens per watt (InitialWattageIntensity.Efficacy). + /// + public double Efficacy; + + /// + /// The illuminance in lux (InitialIlluminanceIntensity.Illuminance). + /// + public double Illuminance; + + /// + /// The distance in feet at which the Illuminance is measured (InitialIlluminanceIntensity.Distance). + /// + public double IlluminanceDistance; + + /// + /// The initial color temperature in kelvins (LightType.GetInitialColor().TemperatureValue). 0 if unknown. + /// + public double InitialColorTemperature; + + /// + /// The color filter, each component in [0..1] (LightType.ColorFilter, whose bytes are divided by 255). (0, 0, 0) if unknown. + /// + public double ColorFilter_X; + public double ColorFilter_Y; + public double ColorFilter_Z; + public DVector3 ColorFilter + { + get => new DVector3(ColorFilter_X, ColorFilter_Y, ColorFilter_Z); + set => (ColorFilter_X, ColorFilter_Y, ColorFilter_Z) = value; + } + + /// + /// The total light loss factor, a ratio (LightType.GetLossFactor().LossFactorValue). 0 if unknown. + /// + public double LossFactor; + + /// + /// The integer representation of the LightDimmingColor enum (LightType.DimmingColor). + /// + public int DimmingColor; + + public LightDimmingColor GetDimmingColor() + => (LightDimmingColor) DimmingColor; + + /// + /// The FamilyType which carries this light definition (in Revit, the FamilySymbol of the light fixtures). + /// + public Relation _FamilyType; + } + + /// + /// Represents the light source of a light fixture: where it is, how it is oriented, and whether it is on. + /// The Element relation is the fixture's Element (a FamilyInstance). Revit allows one light source per family + /// (LightFamily.GetLightSourceTransform), hence at most one LightSource per Element. + /// + [TableName(TableNames.LightSource)] + [CascadeElementRemap] + public partial class LightSource : EntityWithElement + { + /// + /// The origin of the light source, in the same world space and units (feet) as the geometry: the transform of the + /// document holding the fixture (identity, or the link's transform) x FamilyInstance.GetTotalTransform() x + /// LightFamily.GetLightSourceTransform() (read in the light's family document). + /// + public double Origin_X; + public double Origin_Y; + public double Origin_Z; + public DVector3 Origin + { + get => new DVector3(Origin_X, Origin_Y, Origin_Z); + set => (Origin_X, Origin_Y, Origin_Z) = value; + } + + /// + /// The X axis of the light source frame, in world space, as a unit vector. + /// + public double BasisX_X; + public double BasisX_Y; + public double BasisX_Z; + public DVector3 BasisX + { + get => new DVector3(BasisX_X, BasisX_Y, BasisX_Z); + set => (BasisX_X, BasisX_Y, BasisX_Z) = value; + } + + /// + /// The Y axis of the light source frame, in world space, as a unit vector. + /// + public double BasisY_X; + public double BasisY_Y; + public double BasisY_Z; + public DVector3 BasisY + { + get => new DVector3(BasisY_X, BasisY_Y, BasisY_Z); + set => (BasisY_X, BasisY_Y, BasisY_Z) = value; + } + + /// + /// The Z axis of the light source frame, in world space, as a unit vector. The light points along -BasisZ (the + /// photometric nadir, as in IES files). A mirrored fixture gives a left-handed frame: do not assume BasisX x BasisY = BasisZ. + /// + public double BasisZ_X; + public double BasisZ_Y; + public double BasisZ_Z; + public DVector3 BasisZ + { + get => new DVector3(BasisZ_X, BasisZ_Y, BasisZ_Z); + set => (BasisZ_X, BasisZ_Y, BasisZ_Z) = value; + } + + /// + /// True if the frame includes the family's light source transform (LightFamily.GetLightSourceTransform). + /// False if the family could not be read (in-place or non-editable family, or Revit refused to open it): + /// the frame is then the fixture's own frame. + /// + public bool HasLightSourceTransform; + + /// + /// Whether the light is on in the exported 3D view's light groups (LightGroupManager.IsLightOn). + /// Lights in linked documents are always on. + /// + public bool IsOn; + + /// + /// The photometric definition shared by the fixtures of the same FamilyType. + /// + public Relation _LightType; + } + + /// + /// Represents the sun of a 3D view. Revit: maps to the View's SunAndShadowSettings.
+ /// The place on Earth (latitude, longitude, time zone, elevation) is in the BimDocument, and the angle to true north in the BasePoint. + /// + [TableName(TableNames.SunAndShadowSettings)] + public partial class SunAndShadowSettings : Entity + { + /// + /// The name of Revit's SunAndShadowType: "StillImage", "OneDayStudy", "MultiDayStudy" or "Lighting". + /// "Lighting" is a fixed angle which is not tied to a place or a time. + /// + public string SunAndShadowType; + + /// + /// Whether daylight saving time applies (SunAndShadowSettings.UsesDST). + /// + public bool UsesDST; + + /// + /// The time of the active frame, on the project's clock, as "yyyy-MM-ddTHH:mm:ss" (SunAndShadowSettings.GetFrameTime(ActiveFrame)). + /// Empty for the Lighting type. + /// + public string ActiveFrameTime; + + /// + /// The start of the study, on the project's clock, as "yyyy-MM-ddTHH:mm:ss" (SunAndShadowSettings.StartDateAndTime). Empty for the Lighting type. + /// + public string StartDateAndTime; + + /// + /// The end of the study, on the project's clock, as "yyyy-MM-ddTHH:mm:ss" (SunAndShadowSettings.EndDateAndTime). Empty for the Lighting type. + /// + public string EndDateAndTime; + + /// + /// The active frame of the study (SunAndShadowSettings.ActiveFrame). 0 for the Lighting type. + /// + public int ActiveFrame; + + /// + /// The number of frames of the study (SunAndShadowSettings.NumberOfFrames). 0 for the Lighting type. + /// + public int NumberOfFrames; + + /// + /// The altitude of the sun, in radians: the sun Revit computed for the active frame (SunAndShadowSettings.GetFrameAltitude), + /// or the fixed altitude for the Lighting type (SunAndShadowSettings.Altitude). + /// + public double Altitude; + + /// + /// The azimuth of the sun, in radians: clockwise from true north for the sun Revit computed for the active frame + /// (SunAndShadowSettings.GetFrameAzimuth), or the fixed azimuth for the Lighting type (SunAndShadowSettings.Azimuth). + /// + public double Azimuth; + + /// + /// For the Lighting type, whether the fixed angles are relative to the view rather than to the model (SunAndShadowSettings.RelativeToView). + /// + public bool RelativeToView; + + /// + /// The 3D view which owns these settings. + /// + public Relation _View; + } + /// /// Helper functions for performing reflection over the object model /// diff --git a/src/cs/vim/Vim.Format/ObjectModel/ObjectModelGenerated.cs b/src/cs/vim/Vim.Format/ObjectModel/ObjectModelGenerated.cs index 8df50365..707792d7 100644 --- a/src/cs/vim/Vim.Format/ObjectModel/ObjectModelGenerated.cs +++ b/src/cs/vim/Vim.Format/ObjectModel/ObjectModelGenerated.cs @@ -1996,6 +1996,147 @@ public override bool FieldsAreEqual(object obj) } // end of class + // AUTO-GENERATED + public partial class LightType + { + public Vim.Format.ObjectModel.Asset PhotometricWebFile => _PhotometricWebFile?.Value; + public int PhotometricWebFileIndex => _PhotometricWebFile?.Index ?? EntityRelation.None; + public Vim.Format.ObjectModel.FamilyType FamilyType => _FamilyType?.Value; + public int FamilyTypeIndex => _FamilyType?.Index ?? EntityRelation.None; + public LightType() + { + _PhotometricWebFile = new Relation(); + _FamilyType = new Relation(); + } + + public override bool FieldsAreEqual(object obj) + { + if ((obj is LightType other)) + { + var fieldsAreEqual = + (Index == other.Index) && + (LightShapeStyle == other.LightShapeStyle) && + (EmitLength == other.EmitLength) && + (EmitWidth == other.EmitWidth) && + (EmitDiameter == other.EmitDiameter) && + (LightDistributionStyle == other.LightDistributionStyle) && + (SpotBeamAngle == other.SpotBeamAngle) && + (SpotFieldAngle == other.SpotFieldAngle) && + (TiltAngle == other.TiltAngle) && + (PhotometricWebFileName == other.PhotometricWebFileName) && + (InitialIntensityType == other.InitialIntensityType) && + (Luminosity == other.Luminosity) && + (Flux == other.Flux) && + (Wattage == other.Wattage) && + (Efficacy == other.Efficacy) && + (Illuminance == other.Illuminance) && + (IlluminanceDistance == other.IlluminanceDistance) && + (InitialColorTemperature == other.InitialColorTemperature) && + (ColorFilter_X == other.ColorFilter_X) && + (ColorFilter_Y == other.ColorFilter_Y) && + (ColorFilter_Z == other.ColorFilter_Z) && + (LossFactor == other.LossFactor) && + (DimmingColor == other.DimmingColor) && + (_PhotometricWebFile?.Index == other._PhotometricWebFile?.Index) && + (_FamilyType?.Index == other._FamilyType?.Index); + if (!fieldsAreEqual) + { + return false; + } + + return true; + } + return false; + } + + } // end of class + + // AUTO-GENERATED + public partial class LightSource + { + public Vim.Format.ObjectModel.LightType LightType => _LightType?.Value; + public int LightTypeIndex => _LightType?.Index ?? EntityRelation.None; + public Vim.Format.ObjectModel.Element Element => _Element?.Value; + public int ElementIndex => _Element?.Index ?? EntityRelation.None; + public LightSource() + { + _LightType = new Relation(); + _Element = new Relation(); + } + + public override bool FieldsAreEqual(object obj) + { + if ((obj is LightSource other)) + { + var fieldsAreEqual = + (Index == other.Index) && + (Origin_X == other.Origin_X) && + (Origin_Y == other.Origin_Y) && + (Origin_Z == other.Origin_Z) && + (BasisX_X == other.BasisX_X) && + (BasisX_Y == other.BasisX_Y) && + (BasisX_Z == other.BasisX_Z) && + (BasisY_X == other.BasisY_X) && + (BasisY_Y == other.BasisY_Y) && + (BasisY_Z == other.BasisY_Z) && + (BasisZ_X == other.BasisZ_X) && + (BasisZ_Y == other.BasisZ_Y) && + (BasisZ_Z == other.BasisZ_Z) && + (HasLightSourceTransform == other.HasLightSourceTransform) && + (IsOn == other.IsOn) && + (_LightType?.Index == other._LightType?.Index) && + (_Element?.Index == other._Element?.Index); + if (!fieldsAreEqual) + { + return false; + } + + return true; + } + return false; + } + + } // end of class + + // AUTO-GENERATED + public partial class SunAndShadowSettings + { + public Vim.Format.ObjectModel.View View => _View?.Value; + public int ViewIndex => _View?.Index ?? EntityRelation.None; + public SunAndShadowSettings() + { + _View = new Relation(); + } + + public override bool FieldsAreEqual(object obj) + { + if ((obj is SunAndShadowSettings other)) + { + var fieldsAreEqual = + (Index == other.Index) && + (SunAndShadowType == other.SunAndShadowType) && + (UsesDST == other.UsesDST) && + (ActiveFrameTime == other.ActiveFrameTime) && + (StartDateAndTime == other.StartDateAndTime) && + (EndDateAndTime == other.EndDateAndTime) && + (ActiveFrame == other.ActiveFrame) && + (NumberOfFrames == other.NumberOfFrames) && + (Altitude == other.Altitude) && + (Azimuth == other.Azimuth) && + (RelativeToView == other.RelativeToView) && + (_View?.Index == other._View?.Index); + if (!fieldsAreEqual) + { + return false; + } + + return true; + } + return false; + } + + } // end of class + public partial class DocumentModel { public ElementIndexMaps ElementIndexMaps { get; } @@ -3874,6 +4015,207 @@ public Building GetBuilding(int n) return r; } + + // LightType + + public EntityTable LightTypeEntityTable { get; } + + public IArray LightTypeLightShapeStyle { get; } + public Int32 GetLightTypeLightShapeStyle(int index, Int32 defaultValue = default) => LightTypeLightShapeStyle?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeEmitLength { get; } + public Double GetLightTypeEmitLength(int index, Double defaultValue = default) => LightTypeEmitLength?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeEmitWidth { get; } + public Double GetLightTypeEmitWidth(int index, Double defaultValue = default) => LightTypeEmitWidth?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeEmitDiameter { get; } + public Double GetLightTypeEmitDiameter(int index, Double defaultValue = default) => LightTypeEmitDiameter?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeLightDistributionStyle { get; } + public Int32 GetLightTypeLightDistributionStyle(int index, Int32 defaultValue = default) => LightTypeLightDistributionStyle?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeSpotBeamAngle { get; } + public Double GetLightTypeSpotBeamAngle(int index, Double defaultValue = default) => LightTypeSpotBeamAngle?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeSpotFieldAngle { get; } + public Double GetLightTypeSpotFieldAngle(int index, Double defaultValue = default) => LightTypeSpotFieldAngle?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeTiltAngle { get; } + public Double GetLightTypeTiltAngle(int index, Double defaultValue = default) => LightTypeTiltAngle?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypePhotometricWebFileName { get; } + public String GetLightTypePhotometricWebFileName(int index, String defaultValue = "") => LightTypePhotometricWebFileName?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeInitialIntensityType { get; } + public Int32 GetLightTypeInitialIntensityType(int index, Int32 defaultValue = default) => LightTypeInitialIntensityType?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeLuminosity { get; } + public Double GetLightTypeLuminosity(int index, Double defaultValue = default) => LightTypeLuminosity?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeFlux { get; } + public Double GetLightTypeFlux(int index, Double defaultValue = default) => LightTypeFlux?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeWattage { get; } + public Double GetLightTypeWattage(int index, Double defaultValue = default) => LightTypeWattage?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeEfficacy { get; } + public Double GetLightTypeEfficacy(int index, Double defaultValue = default) => LightTypeEfficacy?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeIlluminance { get; } + public Double GetLightTypeIlluminance(int index, Double defaultValue = default) => LightTypeIlluminance?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeIlluminanceDistance { get; } + public Double GetLightTypeIlluminanceDistance(int index, Double defaultValue = default) => LightTypeIlluminanceDistance?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeInitialColorTemperature { get; } + public Double GetLightTypeInitialColorTemperature(int index, Double defaultValue = default) => LightTypeInitialColorTemperature?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeColorFilter_X { get; } + public Double GetLightTypeColorFilter_X(int index, Double defaultValue = default) => LightTypeColorFilter_X?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeColorFilter_Y { get; } + public Double GetLightTypeColorFilter_Y(int index, Double defaultValue = default) => LightTypeColorFilter_Y?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeColorFilter_Z { get; } + public Double GetLightTypeColorFilter_Z(int index, Double defaultValue = default) => LightTypeColorFilter_Z?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeLossFactor { get; } + public Double GetLightTypeLossFactor(int index, Double defaultValue = default) => LightTypeLossFactor?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypeDimmingColor { get; } + public Int32 GetLightTypeDimmingColor(int index, Int32 defaultValue = default) => LightTypeDimmingColor?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightTypePhotometricWebFileIndex { get; } + public int GetLightTypePhotometricWebFileIndex(int index) => LightTypePhotometricWebFileIndex?.ElementAtOrDefault(index, EntityRelation.None) ?? EntityRelation.None; + public IArray LightTypeFamilyTypeIndex { get; } + public int GetLightTypeFamilyTypeIndex(int index) => LightTypeFamilyTypeIndex?.ElementAtOrDefault(index, EntityRelation.None) ?? EntityRelation.None; + public int NumLightType => LightTypeEntityTable?.NumRows ?? 0; + public IArray LightTypeList { get; } + public LightType GetLightType(int n) + { + if (n < 0) return null; + var r = new LightType(); + r.Document = Document; + r.Index = n; + r.LightShapeStyle = LightTypeLightShapeStyle.ElementAtOrDefault(n); + r.EmitLength = LightTypeEmitLength.ElementAtOrDefault(n); + r.EmitWidth = LightTypeEmitWidth.ElementAtOrDefault(n); + r.EmitDiameter = LightTypeEmitDiameter.ElementAtOrDefault(n); + r.LightDistributionStyle = LightTypeLightDistributionStyle.ElementAtOrDefault(n); + r.SpotBeamAngle = LightTypeSpotBeamAngle.ElementAtOrDefault(n); + r.SpotFieldAngle = LightTypeSpotFieldAngle.ElementAtOrDefault(n); + r.TiltAngle = LightTypeTiltAngle.ElementAtOrDefault(n); + r.PhotometricWebFileName = LightTypePhotometricWebFileName.ElementAtOrDefault(n); + r.InitialIntensityType = LightTypeInitialIntensityType.ElementAtOrDefault(n); + r.Luminosity = LightTypeLuminosity.ElementAtOrDefault(n); + r.Flux = LightTypeFlux.ElementAtOrDefault(n); + r.Wattage = LightTypeWattage.ElementAtOrDefault(n); + r.Efficacy = LightTypeEfficacy.ElementAtOrDefault(n); + r.Illuminance = LightTypeIlluminance.ElementAtOrDefault(n); + r.IlluminanceDistance = LightTypeIlluminanceDistance.ElementAtOrDefault(n); + r.InitialColorTemperature = LightTypeInitialColorTemperature.ElementAtOrDefault(n); + r.ColorFilter_X = LightTypeColorFilter_X.ElementAtOrDefault(n); + r.ColorFilter_Y = LightTypeColorFilter_Y.ElementAtOrDefault(n); + r.ColorFilter_Z = LightTypeColorFilter_Z.ElementAtOrDefault(n); + r.LossFactor = LightTypeLossFactor.ElementAtOrDefault(n); + r.DimmingColor = LightTypeDimmingColor.ElementAtOrDefault(n); + r._PhotometricWebFile = new Relation(GetLightTypePhotometricWebFileIndex(n), GetAsset); + r._FamilyType = new Relation(GetLightTypeFamilyTypeIndex(n), GetFamilyType); + return r; + } + + + // LightSource + + public EntityTable LightSourceEntityTable { get; } + + public IArray LightSourceOrigin_X { get; } + public Double GetLightSourceOrigin_X(int index, Double defaultValue = default) => LightSourceOrigin_X?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceOrigin_Y { get; } + public Double GetLightSourceOrigin_Y(int index, Double defaultValue = default) => LightSourceOrigin_Y?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceOrigin_Z { get; } + public Double GetLightSourceOrigin_Z(int index, Double defaultValue = default) => LightSourceOrigin_Z?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisX_X { get; } + public Double GetLightSourceBasisX_X(int index, Double defaultValue = default) => LightSourceBasisX_X?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisX_Y { get; } + public Double GetLightSourceBasisX_Y(int index, Double defaultValue = default) => LightSourceBasisX_Y?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisX_Z { get; } + public Double GetLightSourceBasisX_Z(int index, Double defaultValue = default) => LightSourceBasisX_Z?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisY_X { get; } + public Double GetLightSourceBasisY_X(int index, Double defaultValue = default) => LightSourceBasisY_X?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisY_Y { get; } + public Double GetLightSourceBasisY_Y(int index, Double defaultValue = default) => LightSourceBasisY_Y?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisY_Z { get; } + public Double GetLightSourceBasisY_Z(int index, Double defaultValue = default) => LightSourceBasisY_Z?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisZ_X { get; } + public Double GetLightSourceBasisZ_X(int index, Double defaultValue = default) => LightSourceBasisZ_X?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisZ_Y { get; } + public Double GetLightSourceBasisZ_Y(int index, Double defaultValue = default) => LightSourceBasisZ_Y?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceBasisZ_Z { get; } + public Double GetLightSourceBasisZ_Z(int index, Double defaultValue = default) => LightSourceBasisZ_Z?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceHasLightSourceTransform { get; } + public Boolean GetLightSourceHasLightSourceTransform(int index, Boolean defaultValue = default) => LightSourceHasLightSourceTransform?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceIsOn { get; } + public Boolean GetLightSourceIsOn(int index, Boolean defaultValue = default) => LightSourceIsOn?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray LightSourceLightTypeIndex { get; } + public int GetLightSourceLightTypeIndex(int index) => LightSourceLightTypeIndex?.ElementAtOrDefault(index, EntityRelation.None) ?? EntityRelation.None; + public IArray LightSourceElementIndex { get; } + public int GetLightSourceElementIndex(int index) => LightSourceElementIndex?.ElementAtOrDefault(index, EntityRelation.None) ?? EntityRelation.None; + public int NumLightSource => LightSourceEntityTable?.NumRows ?? 0; + public IArray LightSourceList { get; } + public LightSource GetLightSource(int n) + { + if (n < 0) return null; + var r = new LightSource(); + r.Document = Document; + r.Index = n; + r.Origin_X = LightSourceOrigin_X.ElementAtOrDefault(n); + r.Origin_Y = LightSourceOrigin_Y.ElementAtOrDefault(n); + r.Origin_Z = LightSourceOrigin_Z.ElementAtOrDefault(n); + r.BasisX_X = LightSourceBasisX_X.ElementAtOrDefault(n); + r.BasisX_Y = LightSourceBasisX_Y.ElementAtOrDefault(n); + r.BasisX_Z = LightSourceBasisX_Z.ElementAtOrDefault(n); + r.BasisY_X = LightSourceBasisY_X.ElementAtOrDefault(n); + r.BasisY_Y = LightSourceBasisY_Y.ElementAtOrDefault(n); + r.BasisY_Z = LightSourceBasisY_Z.ElementAtOrDefault(n); + r.BasisZ_X = LightSourceBasisZ_X.ElementAtOrDefault(n); + r.BasisZ_Y = LightSourceBasisZ_Y.ElementAtOrDefault(n); + r.BasisZ_Z = LightSourceBasisZ_Z.ElementAtOrDefault(n); + r.HasLightSourceTransform = LightSourceHasLightSourceTransform.ElementAtOrDefault(n); + r.IsOn = LightSourceIsOn.ElementAtOrDefault(n); + r._LightType = new Relation(GetLightSourceLightTypeIndex(n), GetLightType); + r._Element = new Relation(GetLightSourceElementIndex(n), GetElement); + return r; + } + + + // SunAndShadowSettings + + public EntityTable SunAndShadowSettingsEntityTable { get; } + + public IArray SunAndShadowSettingsSunAndShadowType { get; } + public String GetSunAndShadowSettingsSunAndShadowType(int index, String defaultValue = "") => SunAndShadowSettingsSunAndShadowType?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsUsesDST { get; } + public Boolean GetSunAndShadowSettingsUsesDST(int index, Boolean defaultValue = default) => SunAndShadowSettingsUsesDST?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsActiveFrameTime { get; } + public String GetSunAndShadowSettingsActiveFrameTime(int index, String defaultValue = "") => SunAndShadowSettingsActiveFrameTime?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsStartDateAndTime { get; } + public String GetSunAndShadowSettingsStartDateAndTime(int index, String defaultValue = "") => SunAndShadowSettingsStartDateAndTime?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsEndDateAndTime { get; } + public String GetSunAndShadowSettingsEndDateAndTime(int index, String defaultValue = "") => SunAndShadowSettingsEndDateAndTime?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsActiveFrame { get; } + public Int32 GetSunAndShadowSettingsActiveFrame(int index, Int32 defaultValue = default) => SunAndShadowSettingsActiveFrame?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsNumberOfFrames { get; } + public Int32 GetSunAndShadowSettingsNumberOfFrames(int index, Int32 defaultValue = default) => SunAndShadowSettingsNumberOfFrames?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsAltitude { get; } + public Double GetSunAndShadowSettingsAltitude(int index, Double defaultValue = default) => SunAndShadowSettingsAltitude?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsAzimuth { get; } + public Double GetSunAndShadowSettingsAzimuth(int index, Double defaultValue = default) => SunAndShadowSettingsAzimuth?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsRelativeToView { get; } + public Boolean GetSunAndShadowSettingsRelativeToView(int index, Boolean defaultValue = default) => SunAndShadowSettingsRelativeToView?.ElementAtOrDefault(index, defaultValue) ?? defaultValue; + public IArray SunAndShadowSettingsViewIndex { get; } + public int GetSunAndShadowSettingsViewIndex(int index) => SunAndShadowSettingsViewIndex?.ElementAtOrDefault(index, EntityRelation.None) ?? EntityRelation.None; + public int NumSunAndShadowSettings => SunAndShadowSettingsEntityTable?.NumRows ?? 0; + public IArray SunAndShadowSettingsList { get; } + public SunAndShadowSettings GetSunAndShadowSettings(int n) + { + if (n < 0) return null; + var r = new SunAndShadowSettings(); + r.Document = Document; + r.Index = n; + r.SunAndShadowType = SunAndShadowSettingsSunAndShadowType.ElementAtOrDefault(n); + r.UsesDST = SunAndShadowSettingsUsesDST.ElementAtOrDefault(n); + r.ActiveFrameTime = SunAndShadowSettingsActiveFrameTime.ElementAtOrDefault(n); + r.StartDateAndTime = SunAndShadowSettingsStartDateAndTime.ElementAtOrDefault(n); + r.EndDateAndTime = SunAndShadowSettingsEndDateAndTime.ElementAtOrDefault(n); + r.ActiveFrame = SunAndShadowSettingsActiveFrame.ElementAtOrDefault(n); + r.NumberOfFrames = SunAndShadowSettingsNumberOfFrames.ElementAtOrDefault(n); + r.Altitude = SunAndShadowSettingsAltitude.ElementAtOrDefault(n); + r.Azimuth = SunAndShadowSettingsAzimuth.ElementAtOrDefault(n); + r.RelativeToView = SunAndShadowSettingsRelativeToView.ElementAtOrDefault(n); + r._View = new Relation(GetSunAndShadowSettingsViewIndex(n), GetView); + return r; + } + // All entity collections public Dictionary> AllEntities => new Dictionary>() { {"Vim.Asset", AssetList.ToEnumerable()}, @@ -3930,6 +4272,9 @@ public Building GetBuilding(int n) {"Vim.ViewInViewSheet", ViewInViewSheetList.ToEnumerable()}, {"Vim.Site", SiteList.ToEnumerable()}, {"Vim.Building", BuildingList.ToEnumerable()}, + {"Vim.LightType", LightTypeList.ToEnumerable()}, + {"Vim.LightSource", LightSourceList.ToEnumerable()}, + {"Vim.SunAndShadowSettings", SunAndShadowSettingsList.ToEnumerable()}, }; // Entity types from table names @@ -3988,6 +4333,9 @@ public Building GetBuilding(int n) {"Vim.ViewInViewSheet", typeof(ViewInViewSheet)}, {"Vim.Site", typeof(Site)}, {"Vim.Building", typeof(Building)}, + {"Vim.LightType", typeof(LightType)}, + {"Vim.LightSource", typeof(LightSource)}, + {"Vim.SunAndShadowSettings", typeof(SunAndShadowSettings)}, }; public DocumentModel(Document d, bool inParallel = true) { @@ -4048,6 +4396,9 @@ public DocumentModel(Document d, bool inParallel = true) ViewInViewSheetEntityTable = Document.GetTable("Vim.ViewInViewSheet"); SiteEntityTable = Document.GetTable("Vim.Site"); BuildingEntityTable = Document.GetTable("Vim.Building"); + LightTypeEntityTable = Document.GetTable("Vim.LightType"); + LightSourceEntityTable = Document.GetTable("Vim.LightSource"); + SunAndShadowSettingsEntityTable = Document.GetTable("Vim.SunAndShadowSettings"); // Initialize entity arrays AssetBufferName = AssetEntityTable?.GetStringColumnValues("string:BufferName") ?? Array.Empty().ToIArray(); @@ -4287,6 +4638,52 @@ public DocumentModel(Document d, bool inParallel = true) BuildingElevation = BuildingEntityTable?.GetDataColumnValues("double:Elevation") ?? Array.Empty().ToIArray(); BuildingTerrainElevation = BuildingEntityTable?.GetDataColumnValues("double:TerrainElevation") ?? Array.Empty().ToIArray(); BuildingAddress = BuildingEntityTable?.GetStringColumnValues("string:Address") ?? Array.Empty().ToIArray(); + LightTypeLightShapeStyle = LightTypeEntityTable?.GetDataColumnValues("int:LightShapeStyle") ?? Array.Empty().ToIArray(); + LightTypeEmitLength = LightTypeEntityTable?.GetDataColumnValues("double:EmitLength") ?? Array.Empty().ToIArray(); + LightTypeEmitWidth = LightTypeEntityTable?.GetDataColumnValues("double:EmitWidth") ?? Array.Empty().ToIArray(); + LightTypeEmitDiameter = LightTypeEntityTable?.GetDataColumnValues("double:EmitDiameter") ?? Array.Empty().ToIArray(); + LightTypeLightDistributionStyle = LightTypeEntityTable?.GetDataColumnValues("int:LightDistributionStyle") ?? Array.Empty().ToIArray(); + LightTypeSpotBeamAngle = LightTypeEntityTable?.GetDataColumnValues("double:SpotBeamAngle") ?? Array.Empty().ToIArray(); + LightTypeSpotFieldAngle = LightTypeEntityTable?.GetDataColumnValues("double:SpotFieldAngle") ?? Array.Empty().ToIArray(); + LightTypeTiltAngle = LightTypeEntityTable?.GetDataColumnValues("double:TiltAngle") ?? Array.Empty().ToIArray(); + LightTypePhotometricWebFileName = LightTypeEntityTable?.GetStringColumnValues("string:PhotometricWebFileName") ?? Array.Empty().ToIArray(); + LightTypeInitialIntensityType = LightTypeEntityTable?.GetDataColumnValues("int:InitialIntensityType") ?? Array.Empty().ToIArray(); + LightTypeLuminosity = LightTypeEntityTable?.GetDataColumnValues("double:Luminosity") ?? Array.Empty().ToIArray(); + LightTypeFlux = LightTypeEntityTable?.GetDataColumnValues("double:Flux") ?? Array.Empty().ToIArray(); + LightTypeWattage = LightTypeEntityTable?.GetDataColumnValues("double:Wattage") ?? Array.Empty().ToIArray(); + LightTypeEfficacy = LightTypeEntityTable?.GetDataColumnValues("double:Efficacy") ?? Array.Empty().ToIArray(); + LightTypeIlluminance = LightTypeEntityTable?.GetDataColumnValues("double:Illuminance") ?? Array.Empty().ToIArray(); + LightTypeIlluminanceDistance = LightTypeEntityTable?.GetDataColumnValues("double:IlluminanceDistance") ?? Array.Empty().ToIArray(); + LightTypeInitialColorTemperature = LightTypeEntityTable?.GetDataColumnValues("double:InitialColorTemperature") ?? Array.Empty().ToIArray(); + LightTypeColorFilter_X = LightTypeEntityTable?.GetDataColumnValues("double:ColorFilter.X") ?? Array.Empty().ToIArray(); + LightTypeColorFilter_Y = LightTypeEntityTable?.GetDataColumnValues("double:ColorFilter.Y") ?? Array.Empty().ToIArray(); + LightTypeColorFilter_Z = LightTypeEntityTable?.GetDataColumnValues("double:ColorFilter.Z") ?? Array.Empty().ToIArray(); + LightTypeLossFactor = LightTypeEntityTable?.GetDataColumnValues("double:LossFactor") ?? Array.Empty().ToIArray(); + LightTypeDimmingColor = LightTypeEntityTable?.GetDataColumnValues("int:DimmingColor") ?? Array.Empty().ToIArray(); + LightSourceOrigin_X = LightSourceEntityTable?.GetDataColumnValues("double:Origin.X") ?? Array.Empty().ToIArray(); + LightSourceOrigin_Y = LightSourceEntityTable?.GetDataColumnValues("double:Origin.Y") ?? Array.Empty().ToIArray(); + LightSourceOrigin_Z = LightSourceEntityTable?.GetDataColumnValues("double:Origin.Z") ?? Array.Empty().ToIArray(); + LightSourceBasisX_X = LightSourceEntityTable?.GetDataColumnValues("double:BasisX.X") ?? Array.Empty().ToIArray(); + LightSourceBasisX_Y = LightSourceEntityTable?.GetDataColumnValues("double:BasisX.Y") ?? Array.Empty().ToIArray(); + LightSourceBasisX_Z = LightSourceEntityTable?.GetDataColumnValues("double:BasisX.Z") ?? Array.Empty().ToIArray(); + LightSourceBasisY_X = LightSourceEntityTable?.GetDataColumnValues("double:BasisY.X") ?? Array.Empty().ToIArray(); + LightSourceBasisY_Y = LightSourceEntityTable?.GetDataColumnValues("double:BasisY.Y") ?? Array.Empty().ToIArray(); + LightSourceBasisY_Z = LightSourceEntityTable?.GetDataColumnValues("double:BasisY.Z") ?? Array.Empty().ToIArray(); + LightSourceBasisZ_X = LightSourceEntityTable?.GetDataColumnValues("double:BasisZ.X") ?? Array.Empty().ToIArray(); + LightSourceBasisZ_Y = LightSourceEntityTable?.GetDataColumnValues("double:BasisZ.Y") ?? Array.Empty().ToIArray(); + LightSourceBasisZ_Z = LightSourceEntityTable?.GetDataColumnValues("double:BasisZ.Z") ?? Array.Empty().ToIArray(); + LightSourceHasLightSourceTransform = LightSourceEntityTable?.GetDataColumnValues("byte:HasLightSourceTransform") ?? Array.Empty().ToIArray(); + LightSourceIsOn = LightSourceEntityTable?.GetDataColumnValues("byte:IsOn") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsSunAndShadowType = SunAndShadowSettingsEntityTable?.GetStringColumnValues("string:SunAndShadowType") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsUsesDST = SunAndShadowSettingsEntityTable?.GetDataColumnValues("byte:UsesDST") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsActiveFrameTime = SunAndShadowSettingsEntityTable?.GetStringColumnValues("string:ActiveFrameTime") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsStartDateAndTime = SunAndShadowSettingsEntityTable?.GetStringColumnValues("string:StartDateAndTime") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsEndDateAndTime = SunAndShadowSettingsEntityTable?.GetStringColumnValues("string:EndDateAndTime") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsActiveFrame = SunAndShadowSettingsEntityTable?.GetDataColumnValues("int:ActiveFrame") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsNumberOfFrames = SunAndShadowSettingsEntityTable?.GetDataColumnValues("int:NumberOfFrames") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsAltitude = SunAndShadowSettingsEntityTable?.GetDataColumnValues("double:Altitude") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsAzimuth = SunAndShadowSettingsEntityTable?.GetDataColumnValues("double:Azimuth") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsRelativeToView = SunAndShadowSettingsEntityTable?.GetDataColumnValues("byte:RelativeToView") ?? Array.Empty().ToIArray(); // Initialize entity relational columns ParameterDescriptorDisplayUnitIndex = ParameterDescriptorEntityTable?.GetIndexColumnValues("index:Vim.DisplayUnit:DisplayUnit") ?? Array.Empty().ToIArray(); @@ -4389,6 +4786,11 @@ public DocumentModel(Document d, bool inParallel = true) SiteElementIndex = SiteEntityTable?.GetIndexColumnValues("index:Vim.Element:Element") ?? Array.Empty().ToIArray(); BuildingSiteIndex = BuildingEntityTable?.GetIndexColumnValues("index:Vim.Site:Site") ?? Array.Empty().ToIArray(); BuildingElementIndex = BuildingEntityTable?.GetIndexColumnValues("index:Vim.Element:Element") ?? Array.Empty().ToIArray(); + LightTypePhotometricWebFileIndex = LightTypeEntityTable?.GetIndexColumnValues("index:Vim.Asset:PhotometricWebFile") ?? Array.Empty().ToIArray(); + LightTypeFamilyTypeIndex = LightTypeEntityTable?.GetIndexColumnValues("index:Vim.FamilyType:FamilyType") ?? Array.Empty().ToIArray(); + LightSourceLightTypeIndex = LightSourceEntityTable?.GetIndexColumnValues("index:Vim.LightType:LightType") ?? Array.Empty().ToIArray(); + LightSourceElementIndex = LightSourceEntityTable?.GetIndexColumnValues("index:Vim.Element:Element") ?? Array.Empty().ToIArray(); + SunAndShadowSettingsViewIndex = SunAndShadowSettingsEntityTable?.GetIndexColumnValues("index:Vim.View:View") ?? Array.Empty().ToIArray(); // Initialize entity collections AssetList = NumAsset.Select(i => GetAsset(i)); @@ -4445,6 +4847,9 @@ public DocumentModel(Document d, bool inParallel = true) ViewInViewSheetList = NumViewInViewSheet.Select(i => GetViewInViewSheet(i)); SiteList = NumSite.Select(i => GetSite(i)); BuildingList = NumBuilding.Select(i => GetBuilding(i)); + LightTypeList = NumLightType.Select(i => GetLightType(i)); + LightSourceList = NumLightSource.Select(i => GetLightSource(i)); + SunAndShadowSettingsList = NumSunAndShadowSettings.Select(i => GetSunAndShadowSettings(i)); // Initialize element index maps ElementIndexMaps = new ElementIndexMaps(this, inParallel); @@ -4526,6 +4931,9 @@ public EntityTableSet(SerializableEntityTable[] rawTables, string[] stringTable, Tables[TableNames.ViewInViewSheet] = ViewInViewSheetTable = new ViewInViewSheetTable(GetSerializableTableOrEmpty(TableNames.ViewInViewSheet), stringTable, this); Tables[TableNames.Site] = SiteTable = new SiteTable(GetSerializableTableOrEmpty(TableNames.Site), stringTable, this); Tables[TableNames.Building] = BuildingTable = new BuildingTable(GetSerializableTableOrEmpty(TableNames.Building), stringTable, this); + Tables[TableNames.LightType] = LightTypeTable = new LightTypeTable(GetSerializableTableOrEmpty(TableNames.LightType), stringTable, this); + Tables[TableNames.LightSource] = LightSourceTable = new LightSourceTable(GetSerializableTableOrEmpty(TableNames.LightSource), stringTable, this); + Tables[TableNames.SunAndShadowSettings] = SunAndShadowSettingsTable = new SunAndShadowSettingsTable(GetSerializableTableOrEmpty(TableNames.SunAndShadowSettings), stringTable, this); // Initialize element index maps ElementIndexMaps = new ElementIndexMaps(this, inParallel); @@ -4640,6 +5048,12 @@ public EntityTableSet(SerializableEntityTable[] rawTables, string[] stringTable, public Site GetSite(int index) => SiteTable?.Get(index); public BuildingTable BuildingTable { get; } // can be null public Building GetBuilding(int index) => BuildingTable?.Get(index); + public LightTypeTable LightTypeTable { get; } // can be null + public LightType GetLightType(int index) => LightTypeTable?.Get(index); + public LightSourceTable LightSourceTable { get; } // can be null + public LightSource GetLightSource(int index) => LightSourceTable?.Get(index); + public SunAndShadowSettingsTable SunAndShadowSettingsTable { get; } // can be null + public SunAndShadowSettings GetSunAndShadowSettings(int index) => SunAndShadowSettingsTable?.Get(index); public static HashSet GetElementKindTableNames() => new HashSet() @@ -8120,6 +8534,307 @@ public IEnumerator GetEnumerator() } } // class BuildingTable + public partial class LightTypeTable : EntityTable_v2, IEnumerable + { + + public const string TableName = TableNames.LightType; + + public EntityTableSet ParentTableSet { get; } // can be null + + public LightTypeTable(SerializableEntityTable rawTable, string[] stringTable, EntityTableSet parentTableSet = null) : base(rawTable, stringTable) + { + ParentTableSet = parentTableSet; + Column_LightShapeStyle = GetDataColumnValues("int:LightShapeStyle") ?? Array.Empty(); + Column_EmitLength = GetDataColumnValues("double:EmitLength") ?? Array.Empty(); + Column_EmitWidth = GetDataColumnValues("double:EmitWidth") ?? Array.Empty(); + Column_EmitDiameter = GetDataColumnValues("double:EmitDiameter") ?? Array.Empty(); + Column_LightDistributionStyle = GetDataColumnValues("int:LightDistributionStyle") ?? Array.Empty(); + Column_SpotBeamAngle = GetDataColumnValues("double:SpotBeamAngle") ?? Array.Empty(); + Column_SpotFieldAngle = GetDataColumnValues("double:SpotFieldAngle") ?? Array.Empty(); + Column_TiltAngle = GetDataColumnValues("double:TiltAngle") ?? Array.Empty(); + Column_PhotometricWebFileName = GetStringColumnValues("string:PhotometricWebFileName") ?? Array.Empty(); + Column_InitialIntensityType = GetDataColumnValues("int:InitialIntensityType") ?? Array.Empty(); + Column_Luminosity = GetDataColumnValues("double:Luminosity") ?? Array.Empty(); + Column_Flux = GetDataColumnValues("double:Flux") ?? Array.Empty(); + Column_Wattage = GetDataColumnValues("double:Wattage") ?? Array.Empty(); + Column_Efficacy = GetDataColumnValues("double:Efficacy") ?? Array.Empty(); + Column_Illuminance = GetDataColumnValues("double:Illuminance") ?? Array.Empty(); + Column_IlluminanceDistance = GetDataColumnValues("double:IlluminanceDistance") ?? Array.Empty(); + Column_InitialColorTemperature = GetDataColumnValues("double:InitialColorTemperature") ?? Array.Empty(); + Column_ColorFilter_X = GetDataColumnValues("double:ColorFilter.X") ?? Array.Empty(); + Column_ColorFilter_Y = GetDataColumnValues("double:ColorFilter.Y") ?? Array.Empty(); + Column_ColorFilter_Z = GetDataColumnValues("double:ColorFilter.Z") ?? Array.Empty(); + Column_LossFactor = GetDataColumnValues("double:LossFactor") ?? Array.Empty(); + Column_DimmingColor = GetDataColumnValues("int:DimmingColor") ?? Array.Empty(); + Column_PhotometricWebFileIndex = GetIndexColumnValues("index:Vim.Asset:PhotometricWebFile") ?? Array.Empty(); + Column_FamilyTypeIndex = GetIndexColumnValues("index:Vim.FamilyType:FamilyType") ?? Array.Empty(); + } + + public Int32[] Column_LightShapeStyle { get; } + public Int32 GetLightShapeStyle(int index, Int32 @default = default) => Column_LightShapeStyle.ElementAtOrDefault(index, @default); + public Double[] Column_EmitLength { get; } + public Double GetEmitLength(int index, Double @default = default) => Column_EmitLength.ElementAtOrDefault(index, @default); + public Double[] Column_EmitWidth { get; } + public Double GetEmitWidth(int index, Double @default = default) => Column_EmitWidth.ElementAtOrDefault(index, @default); + public Double[] Column_EmitDiameter { get; } + public Double GetEmitDiameter(int index, Double @default = default) => Column_EmitDiameter.ElementAtOrDefault(index, @default); + public Int32[] Column_LightDistributionStyle { get; } + public Int32 GetLightDistributionStyle(int index, Int32 @default = default) => Column_LightDistributionStyle.ElementAtOrDefault(index, @default); + public Double[] Column_SpotBeamAngle { get; } + public Double GetSpotBeamAngle(int index, Double @default = default) => Column_SpotBeamAngle.ElementAtOrDefault(index, @default); + public Double[] Column_SpotFieldAngle { get; } + public Double GetSpotFieldAngle(int index, Double @default = default) => Column_SpotFieldAngle.ElementAtOrDefault(index, @default); + public Double[] Column_TiltAngle { get; } + public Double GetTiltAngle(int index, Double @default = default) => Column_TiltAngle.ElementAtOrDefault(index, @default); + public String[] Column_PhotometricWebFileName { get; } + public String GetPhotometricWebFileName(int index, String @default = "") => Column_PhotometricWebFileName.ElementAtOrDefault(index, @default); + public Int32[] Column_InitialIntensityType { get; } + public Int32 GetInitialIntensityType(int index, Int32 @default = default) => Column_InitialIntensityType.ElementAtOrDefault(index, @default); + public Double[] Column_Luminosity { get; } + public Double GetLuminosity(int index, Double @default = default) => Column_Luminosity.ElementAtOrDefault(index, @default); + public Double[] Column_Flux { get; } + public Double GetFlux(int index, Double @default = default) => Column_Flux.ElementAtOrDefault(index, @default); + public Double[] Column_Wattage { get; } + public Double GetWattage(int index, Double @default = default) => Column_Wattage.ElementAtOrDefault(index, @default); + public Double[] Column_Efficacy { get; } + public Double GetEfficacy(int index, Double @default = default) => Column_Efficacy.ElementAtOrDefault(index, @default); + public Double[] Column_Illuminance { get; } + public Double GetIlluminance(int index, Double @default = default) => Column_Illuminance.ElementAtOrDefault(index, @default); + public Double[] Column_IlluminanceDistance { get; } + public Double GetIlluminanceDistance(int index, Double @default = default) => Column_IlluminanceDistance.ElementAtOrDefault(index, @default); + public Double[] Column_InitialColorTemperature { get; } + public Double GetInitialColorTemperature(int index, Double @default = default) => Column_InitialColorTemperature.ElementAtOrDefault(index, @default); + public Double[] Column_ColorFilter_X { get; } + public Double GetColorFilter_X(int index, Double @default = default) => Column_ColorFilter_X.ElementAtOrDefault(index, @default); + public Double[] Column_ColorFilter_Y { get; } + public Double GetColorFilter_Y(int index, Double @default = default) => Column_ColorFilter_Y.ElementAtOrDefault(index, @default); + public Double[] Column_ColorFilter_Z { get; } + public Double GetColorFilter_Z(int index, Double @default = default) => Column_ColorFilter_Z.ElementAtOrDefault(index, @default); + public Double[] Column_LossFactor { get; } + public Double GetLossFactor(int index, Double @default = default) => Column_LossFactor.ElementAtOrDefault(index, @default); + public Int32[] Column_DimmingColor { get; } + public Int32 GetDimmingColor(int index, Int32 @default = default) => Column_DimmingColor.ElementAtOrDefault(index, @default); + public int[] Column_PhotometricWebFileIndex { get; } + public int GetPhotometricWebFileIndex(int index) => Column_PhotometricWebFileIndex.ElementAtOrDefault(index, EntityRelation.None); + public Asset GetPhotometricWebFile(int index) => _GetReferencedPhotometricWebFile(GetPhotometricWebFileIndex(index)); + private Asset _GetReferencedPhotometricWebFile(int referencedIndex) => ParentTableSet.GetAsset(referencedIndex); + public int[] Column_FamilyTypeIndex { get; } + public int GetFamilyTypeIndex(int index) => Column_FamilyTypeIndex.ElementAtOrDefault(index, EntityRelation.None); + public FamilyType GetFamilyType(int index) => _GetReferencedFamilyType(GetFamilyTypeIndex(index)); + private FamilyType _GetReferencedFamilyType(int referencedIndex) => ParentTableSet.GetFamilyType(referencedIndex); + // Object Getter + public LightType Get(int index) + { + if (index < 0) return null; + var r = new LightType(); + r.Index = index; + r.LightShapeStyle = GetLightShapeStyle(index); + r.EmitLength = GetEmitLength(index); + r.EmitWidth = GetEmitWidth(index); + r.EmitDiameter = GetEmitDiameter(index); + r.LightDistributionStyle = GetLightDistributionStyle(index); + r.SpotBeamAngle = GetSpotBeamAngle(index); + r.SpotFieldAngle = GetSpotFieldAngle(index); + r.TiltAngle = GetTiltAngle(index); + r.PhotometricWebFileName = GetPhotometricWebFileName(index); + r.InitialIntensityType = GetInitialIntensityType(index); + r.Luminosity = GetLuminosity(index); + r.Flux = GetFlux(index); + r.Wattage = GetWattage(index); + r.Efficacy = GetEfficacy(index); + r.Illuminance = GetIlluminance(index); + r.IlluminanceDistance = GetIlluminanceDistance(index); + r.InitialColorTemperature = GetInitialColorTemperature(index); + r.ColorFilter_X = GetColorFilter_X(index); + r.ColorFilter_Y = GetColorFilter_Y(index); + r.ColorFilter_Z = GetColorFilter_Z(index); + r.LossFactor = GetLossFactor(index); + r.DimmingColor = GetDimmingColor(index); + r._PhotometricWebFile = new Relation(GetPhotometricWebFileIndex(index), _GetReferencedPhotometricWebFile); + r._FamilyType = new Relation(GetFamilyTypeIndex(index), _GetReferencedFamilyType); + return r; + } + // Enumerator + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + public IEnumerator GetEnumerator() + { + for (var i = 0; i < RowCount; ++i) + yield return Get(i); + } + } // class LightTypeTable + + public partial class LightSourceTable : EntityTable_v2, IEnumerable + { + + public const string TableName = TableNames.LightSource; + + public EntityTableSet ParentTableSet { get; } // can be null + + public LightSourceTable(SerializableEntityTable rawTable, string[] stringTable, EntityTableSet parentTableSet = null) : base(rawTable, stringTable) + { + ParentTableSet = parentTableSet; + Column_Origin_X = GetDataColumnValues("double:Origin.X") ?? Array.Empty(); + Column_Origin_Y = GetDataColumnValues("double:Origin.Y") ?? Array.Empty(); + Column_Origin_Z = GetDataColumnValues("double:Origin.Z") ?? Array.Empty(); + Column_BasisX_X = GetDataColumnValues("double:BasisX.X") ?? Array.Empty(); + Column_BasisX_Y = GetDataColumnValues("double:BasisX.Y") ?? Array.Empty(); + Column_BasisX_Z = GetDataColumnValues("double:BasisX.Z") ?? Array.Empty(); + Column_BasisY_X = GetDataColumnValues("double:BasisY.X") ?? Array.Empty(); + Column_BasisY_Y = GetDataColumnValues("double:BasisY.Y") ?? Array.Empty(); + Column_BasisY_Z = GetDataColumnValues("double:BasisY.Z") ?? Array.Empty(); + Column_BasisZ_X = GetDataColumnValues("double:BasisZ.X") ?? Array.Empty(); + Column_BasisZ_Y = GetDataColumnValues("double:BasisZ.Y") ?? Array.Empty(); + Column_BasisZ_Z = GetDataColumnValues("double:BasisZ.Z") ?? Array.Empty(); + Column_HasLightSourceTransform = GetDataColumnValues("byte:HasLightSourceTransform") ?? Array.Empty(); + Column_IsOn = GetDataColumnValues("byte:IsOn") ?? Array.Empty(); + Column_LightTypeIndex = GetIndexColumnValues("index:Vim.LightType:LightType") ?? Array.Empty(); + Column_ElementIndex = GetIndexColumnValues("index:Vim.Element:Element") ?? Array.Empty(); + } + + public Double[] Column_Origin_X { get; } + public Double GetOrigin_X(int index, Double @default = default) => Column_Origin_X.ElementAtOrDefault(index, @default); + public Double[] Column_Origin_Y { get; } + public Double GetOrigin_Y(int index, Double @default = default) => Column_Origin_Y.ElementAtOrDefault(index, @default); + public Double[] Column_Origin_Z { get; } + public Double GetOrigin_Z(int index, Double @default = default) => Column_Origin_Z.ElementAtOrDefault(index, @default); + public Double[] Column_BasisX_X { get; } + public Double GetBasisX_X(int index, Double @default = default) => Column_BasisX_X.ElementAtOrDefault(index, @default); + public Double[] Column_BasisX_Y { get; } + public Double GetBasisX_Y(int index, Double @default = default) => Column_BasisX_Y.ElementAtOrDefault(index, @default); + public Double[] Column_BasisX_Z { get; } + public Double GetBasisX_Z(int index, Double @default = default) => Column_BasisX_Z.ElementAtOrDefault(index, @default); + public Double[] Column_BasisY_X { get; } + public Double GetBasisY_X(int index, Double @default = default) => Column_BasisY_X.ElementAtOrDefault(index, @default); + public Double[] Column_BasisY_Y { get; } + public Double GetBasisY_Y(int index, Double @default = default) => Column_BasisY_Y.ElementAtOrDefault(index, @default); + public Double[] Column_BasisY_Z { get; } + public Double GetBasisY_Z(int index, Double @default = default) => Column_BasisY_Z.ElementAtOrDefault(index, @default); + public Double[] Column_BasisZ_X { get; } + public Double GetBasisZ_X(int index, Double @default = default) => Column_BasisZ_X.ElementAtOrDefault(index, @default); + public Double[] Column_BasisZ_Y { get; } + public Double GetBasisZ_Y(int index, Double @default = default) => Column_BasisZ_Y.ElementAtOrDefault(index, @default); + public Double[] Column_BasisZ_Z { get; } + public Double GetBasisZ_Z(int index, Double @default = default) => Column_BasisZ_Z.ElementAtOrDefault(index, @default); + public Boolean[] Column_HasLightSourceTransform { get; } + public Boolean GetHasLightSourceTransform(int index, Boolean @default = default) => Column_HasLightSourceTransform.ElementAtOrDefault(index, @default); + public Boolean[] Column_IsOn { get; } + public Boolean GetIsOn(int index, Boolean @default = default) => Column_IsOn.ElementAtOrDefault(index, @default); + public int[] Column_LightTypeIndex { get; } + public int GetLightTypeIndex(int index) => Column_LightTypeIndex.ElementAtOrDefault(index, EntityRelation.None); + public LightType GetLightType(int index) => _GetReferencedLightType(GetLightTypeIndex(index)); + private LightType _GetReferencedLightType(int referencedIndex) => ParentTableSet.GetLightType(referencedIndex); + public int[] Column_ElementIndex { get; } + public int GetElementIndex(int index) => Column_ElementIndex.ElementAtOrDefault(index, EntityRelation.None); + public Element GetElement(int index) => _GetReferencedElement(GetElementIndex(index)); + private Element _GetReferencedElement(int referencedIndex) => ParentTableSet.GetElement(referencedIndex); + // Object Getter + public LightSource Get(int index) + { + if (index < 0) return null; + var r = new LightSource(); + r.Index = index; + r.Origin_X = GetOrigin_X(index); + r.Origin_Y = GetOrigin_Y(index); + r.Origin_Z = GetOrigin_Z(index); + r.BasisX_X = GetBasisX_X(index); + r.BasisX_Y = GetBasisX_Y(index); + r.BasisX_Z = GetBasisX_Z(index); + r.BasisY_X = GetBasisY_X(index); + r.BasisY_Y = GetBasisY_Y(index); + r.BasisY_Z = GetBasisY_Z(index); + r.BasisZ_X = GetBasisZ_X(index); + r.BasisZ_Y = GetBasisZ_Y(index); + r.BasisZ_Z = GetBasisZ_Z(index); + r.HasLightSourceTransform = GetHasLightSourceTransform(index); + r.IsOn = GetIsOn(index); + r._LightType = new Relation(GetLightTypeIndex(index), _GetReferencedLightType); + r._Element = new Relation(GetElementIndex(index), _GetReferencedElement); + return r; + } + // Enumerator + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + public IEnumerator GetEnumerator() + { + for (var i = 0; i < RowCount; ++i) + yield return Get(i); + } + } // class LightSourceTable + + public partial class SunAndShadowSettingsTable : EntityTable_v2, IEnumerable + { + + public const string TableName = TableNames.SunAndShadowSettings; + + public EntityTableSet ParentTableSet { get; } // can be null + + public SunAndShadowSettingsTable(SerializableEntityTable rawTable, string[] stringTable, EntityTableSet parentTableSet = null) : base(rawTable, stringTable) + { + ParentTableSet = parentTableSet; + Column_SunAndShadowType = GetStringColumnValues("string:SunAndShadowType") ?? Array.Empty(); + Column_UsesDST = GetDataColumnValues("byte:UsesDST") ?? Array.Empty(); + Column_ActiveFrameTime = GetStringColumnValues("string:ActiveFrameTime") ?? Array.Empty(); + Column_StartDateAndTime = GetStringColumnValues("string:StartDateAndTime") ?? Array.Empty(); + Column_EndDateAndTime = GetStringColumnValues("string:EndDateAndTime") ?? Array.Empty(); + Column_ActiveFrame = GetDataColumnValues("int:ActiveFrame") ?? Array.Empty(); + Column_NumberOfFrames = GetDataColumnValues("int:NumberOfFrames") ?? Array.Empty(); + Column_Altitude = GetDataColumnValues("double:Altitude") ?? Array.Empty(); + Column_Azimuth = GetDataColumnValues("double:Azimuth") ?? Array.Empty(); + Column_RelativeToView = GetDataColumnValues("byte:RelativeToView") ?? Array.Empty(); + Column_ViewIndex = GetIndexColumnValues("index:Vim.View:View") ?? Array.Empty(); + } + + public String[] Column_SunAndShadowType { get; } + public String GetSunAndShadowType(int index, String @default = "") => Column_SunAndShadowType.ElementAtOrDefault(index, @default); + public Boolean[] Column_UsesDST { get; } + public Boolean GetUsesDST(int index, Boolean @default = default) => Column_UsesDST.ElementAtOrDefault(index, @default); + public String[] Column_ActiveFrameTime { get; } + public String GetActiveFrameTime(int index, String @default = "") => Column_ActiveFrameTime.ElementAtOrDefault(index, @default); + public String[] Column_StartDateAndTime { get; } + public String GetStartDateAndTime(int index, String @default = "") => Column_StartDateAndTime.ElementAtOrDefault(index, @default); + public String[] Column_EndDateAndTime { get; } + public String GetEndDateAndTime(int index, String @default = "") => Column_EndDateAndTime.ElementAtOrDefault(index, @default); + public Int32[] Column_ActiveFrame { get; } + public Int32 GetActiveFrame(int index, Int32 @default = default) => Column_ActiveFrame.ElementAtOrDefault(index, @default); + public Int32[] Column_NumberOfFrames { get; } + public Int32 GetNumberOfFrames(int index, Int32 @default = default) => Column_NumberOfFrames.ElementAtOrDefault(index, @default); + public Double[] Column_Altitude { get; } + public Double GetAltitude(int index, Double @default = default) => Column_Altitude.ElementAtOrDefault(index, @default); + public Double[] Column_Azimuth { get; } + public Double GetAzimuth(int index, Double @default = default) => Column_Azimuth.ElementAtOrDefault(index, @default); + public Boolean[] Column_RelativeToView { get; } + public Boolean GetRelativeToView(int index, Boolean @default = default) => Column_RelativeToView.ElementAtOrDefault(index, @default); + public int[] Column_ViewIndex { get; } + public int GetViewIndex(int index) => Column_ViewIndex.ElementAtOrDefault(index, EntityRelation.None); + public View GetView(int index) => _GetReferencedView(GetViewIndex(index)); + private View _GetReferencedView(int referencedIndex) => ParentTableSet.GetView(referencedIndex); + // Object Getter + public SunAndShadowSettings Get(int index) + { + if (index < 0) return null; + var r = new SunAndShadowSettings(); + r.Index = index; + r.SunAndShadowType = GetSunAndShadowType(index); + r.UsesDST = GetUsesDST(index); + r.ActiveFrameTime = GetActiveFrameTime(index); + r.StartDateAndTime = GetStartDateAndTime(index); + r.EndDateAndTime = GetEndDateAndTime(index); + r.ActiveFrame = GetActiveFrame(index); + r.NumberOfFrames = GetNumberOfFrames(index); + r.Altitude = GetAltitude(index); + r.Azimuth = GetAzimuth(index); + r.RelativeToView = GetRelativeToView(index); + r._View = new Relation(GetViewIndex(index), _GetReferencedView); + return r; + } + // Enumerator + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + public IEnumerator GetEnumerator() + { + for (var i = 0; i < RowCount; ++i) + yield return Get(i); + } + } // class SunAndShadowSettingsTable + public static class DocumentBuilderExtensions { public static EntityTableBuilder ToAssetTableBuilder(this EntitySetBuilder entitySet) @@ -10185,6 +10900,282 @@ public static EntityTableBuilder ToBuildingTableBuilder(this EntitySetBuilder entitySet) + { + var tb = new EntityTableBuilder(TableNames.LightType); + var entities = entitySet.Entities; + var entityCount = entities.Count; + { + var columnData = new Int32[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].LightShapeStyle; } + tb.AddDataColumn("int:LightShapeStyle", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].EmitLength; } + tb.AddDataColumn("double:EmitLength", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].EmitWidth; } + tb.AddDataColumn("double:EmitWidth", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].EmitDiameter; } + tb.AddDataColumn("double:EmitDiameter", columnData); + } + { + var columnData = new Int32[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].LightDistributionStyle; } + tb.AddDataColumn("int:LightDistributionStyle", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].SpotBeamAngle; } + tb.AddDataColumn("double:SpotBeamAngle", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].SpotFieldAngle; } + tb.AddDataColumn("double:SpotFieldAngle", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].TiltAngle; } + tb.AddDataColumn("double:TiltAngle", columnData); + } + { + var columnData = new String[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].PhotometricWebFileName; } + tb.AddStringColumn("string:PhotometricWebFileName", columnData); + } + { + var columnData = new Int32[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].InitialIntensityType; } + tb.AddDataColumn("int:InitialIntensityType", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Luminosity; } + tb.AddDataColumn("double:Luminosity", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Flux; } + tb.AddDataColumn("double:Flux", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Wattage; } + tb.AddDataColumn("double:Wattage", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Efficacy; } + tb.AddDataColumn("double:Efficacy", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Illuminance; } + tb.AddDataColumn("double:Illuminance", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].IlluminanceDistance; } + tb.AddDataColumn("double:IlluminanceDistance", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].InitialColorTemperature; } + tb.AddDataColumn("double:InitialColorTemperature", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].ColorFilter_X; } + tb.AddDataColumn("double:ColorFilter.X", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].ColorFilter_Y; } + tb.AddDataColumn("double:ColorFilter.Y", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].ColorFilter_Z; } + tb.AddDataColumn("double:ColorFilter.Z", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].LossFactor; } + tb.AddDataColumn("double:LossFactor", columnData); + } + { + var columnData = new Int32[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].DimmingColor; } + tb.AddDataColumn("int:DimmingColor", columnData); + } + { + var columnData = new int[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i]._PhotometricWebFile?.Index ?? EntityRelation.None; } + tb.AddIndexColumn("index:Vim.Asset:PhotometricWebFile", columnData); + } + { + var columnData = new int[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i]._FamilyType?.Index ?? EntityRelation.None; } + tb.AddIndexColumn("index:Vim.FamilyType:FamilyType", columnData); + } + return tb; + } + public static EntityTableBuilder ToLightSourceTableBuilder(this EntitySetBuilder entitySet) + { + var tb = new EntityTableBuilder(TableNames.LightSource); + var entities = entitySet.Entities; + var entityCount = entities.Count; + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Origin_X; } + tb.AddDataColumn("double:Origin.X", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Origin_Y; } + tb.AddDataColumn("double:Origin.Y", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Origin_Z; } + tb.AddDataColumn("double:Origin.Z", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisX_X; } + tb.AddDataColumn("double:BasisX.X", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisX_Y; } + tb.AddDataColumn("double:BasisX.Y", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisX_Z; } + tb.AddDataColumn("double:BasisX.Z", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisY_X; } + tb.AddDataColumn("double:BasisY.X", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisY_Y; } + tb.AddDataColumn("double:BasisY.Y", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisY_Z; } + tb.AddDataColumn("double:BasisY.Z", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisZ_X; } + tb.AddDataColumn("double:BasisZ.X", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisZ_Y; } + tb.AddDataColumn("double:BasisZ.Y", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].BasisZ_Z; } + tb.AddDataColumn("double:BasisZ.Z", columnData); + } + { + var columnData = new Boolean[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].HasLightSourceTransform; } + tb.AddDataColumn("byte:HasLightSourceTransform", columnData); + } + { + var columnData = new Boolean[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].IsOn; } + tb.AddDataColumn("byte:IsOn", columnData); + } + { + var columnData = new int[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i]._LightType?.Index ?? EntityRelation.None; } + tb.AddIndexColumn("index:Vim.LightType:LightType", columnData); + } + { + var columnData = new int[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i]._Element?.Index ?? EntityRelation.None; } + tb.AddIndexColumn("index:Vim.Element:Element", columnData); + } + return tb; + } + public static EntityTableBuilder ToSunAndShadowSettingsTableBuilder(this EntitySetBuilder entitySet) + { + var tb = new EntityTableBuilder(TableNames.SunAndShadowSettings); + var entities = entitySet.Entities; + var entityCount = entities.Count; + { + var columnData = new String[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].SunAndShadowType; } + tb.AddStringColumn("string:SunAndShadowType", columnData); + } + { + var columnData = new Boolean[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].UsesDST; } + tb.AddDataColumn("byte:UsesDST", columnData); + } + { + var columnData = new String[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].ActiveFrameTime; } + tb.AddStringColumn("string:ActiveFrameTime", columnData); + } + { + var columnData = new String[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].StartDateAndTime; } + tb.AddStringColumn("string:StartDateAndTime", columnData); + } + { + var columnData = new String[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].EndDateAndTime; } + tb.AddStringColumn("string:EndDateAndTime", columnData); + } + { + var columnData = new Int32[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].ActiveFrame; } + tb.AddDataColumn("int:ActiveFrame", columnData); + } + { + var columnData = new Int32[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].NumberOfFrames; } + tb.AddDataColumn("int:NumberOfFrames", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Altitude; } + tb.AddDataColumn("double:Altitude", columnData); + } + { + var columnData = new Double[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].Azimuth; } + tb.AddDataColumn("double:Azimuth", columnData); + } + { + var columnData = new Boolean[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i].RelativeToView; } + tb.AddDataColumn("byte:RelativeToView", columnData); + } + { + var columnData = new int[entityCount]; + for (var i = 0; i < columnData.Length; ++i) { columnData[i] = entities[i]._View?.Index ?? EntityRelation.None; } + tb.AddIndexColumn("index:Vim.View:View", columnData); + } + return tb; + } } // DocumentBuilderExtensions public partial class ObjectModelBuilder @@ -10243,6 +11234,9 @@ public partial class ObjectModelBuilder public readonly EntitySetBuilder ViewInViewSheetBuilder = new EntitySetBuilder(TableNames.ViewInViewSheet); public readonly EntitySetBuilder SiteBuilder = new EntitySetBuilder(TableNames.Site); public readonly EntitySetBuilder BuildingBuilder = new EntitySetBuilder(TableNames.Building); + public readonly EntitySetBuilder LightTypeBuilder = new EntitySetBuilder(TableNames.LightType); + public readonly EntitySetBuilder LightSourceBuilder = new EntitySetBuilder(TableNames.LightSource); + public readonly EntitySetBuilder SunAndShadowSettingsBuilder = new EntitySetBuilder(TableNames.SunAndShadowSettings); public DocumentBuilder AddEntityTableSets(DocumentBuilder db) { @@ -10300,6 +11294,9 @@ public DocumentBuilder AddEntityTableSets(DocumentBuilder db) db.Tables.Add(ViewInViewSheetBuilder.EntityTableName, ViewInViewSheetBuilder.ToViewInViewSheetTableBuilder()); db.Tables.Add(SiteBuilder.EntityTableName, SiteBuilder.ToSiteTableBuilder()); db.Tables.Add(BuildingBuilder.EntityTableName, BuildingBuilder.ToBuildingTableBuilder()); + db.Tables.Add(LightTypeBuilder.EntityTableName, LightTypeBuilder.ToLightTypeTableBuilder()); + db.Tables.Add(LightSourceBuilder.EntityTableName, LightSourceBuilder.ToLightSourceTableBuilder()); + db.Tables.Add(SunAndShadowSettingsBuilder.EntityTableName, SunAndShadowSettingsBuilder.ToSunAndShadowSettingsTableBuilder()); return db; } // AddEntityTableSets @@ -10360,6 +11357,9 @@ public void Clear() ViewInViewSheetBuilder.Clear(); SiteBuilder.Clear(); BuildingBuilder.Clear(); + LightTypeBuilder.Clear(); + LightSourceBuilder.Clear(); + SunAndShadowSettingsBuilder.Clear(); } // Clear } // ObjectModelBuilder } // namespace diff --git a/src/ts/src/objectModel.ts b/src/ts/src/objectModel.ts index c0a5ea4f..6ce4a4e7 100644 --- a/src/ts/src/objectModel.ts +++ b/src/ts/src/objectModel.ts @@ -10713,6 +10713,1112 @@ export class BuildingTable implements IBuildingTable { } +export interface ILightType { + index: number + lightShapeStyle?: number + emitLength?: number + emitWidth?: number + emitDiameter?: number + lightDistributionStyle?: number + spotBeamAngle?: number + spotFieldAngle?: number + tiltAngle?: number + photometricWebFileName?: string + initialIntensityType?: number + luminosity?: number + flux?: number + wattage?: number + efficacy?: number + illuminance?: number + illuminanceDistance?: number + initialColorTemperature?: number + colorFilter_X?: number + colorFilter_Y?: number + colorFilter_Z?: number + lossFactor?: number + dimmingColor?: number + + photometricWebFileIndex?: number + photometricWebFile?: IAsset + familyTypeIndex?: number + familyType?: IFamilyType +} + +export interface ILightTypeTable { + getCount(): Promise + get(lightTypeIndex: number): Promise + getAll(): Promise + + getLightShapeStyle(lightTypeIndex: number): Promise + getAllLightShapeStyle(): Promise + getEmitLength(lightTypeIndex: number): Promise + getAllEmitLength(): Promise + getEmitWidth(lightTypeIndex: number): Promise + getAllEmitWidth(): Promise + getEmitDiameter(lightTypeIndex: number): Promise + getAllEmitDiameter(): Promise + getLightDistributionStyle(lightTypeIndex: number): Promise + getAllLightDistributionStyle(): Promise + getSpotBeamAngle(lightTypeIndex: number): Promise + getAllSpotBeamAngle(): Promise + getSpotFieldAngle(lightTypeIndex: number): Promise + getAllSpotFieldAngle(): Promise + getTiltAngle(lightTypeIndex: number): Promise + getAllTiltAngle(): Promise + getPhotometricWebFileName(lightTypeIndex: number): Promise + getAllPhotometricWebFileName(): Promise + getInitialIntensityType(lightTypeIndex: number): Promise + getAllInitialIntensityType(): Promise + getLuminosity(lightTypeIndex: number): Promise + getAllLuminosity(): Promise + getFlux(lightTypeIndex: number): Promise + getAllFlux(): Promise + getWattage(lightTypeIndex: number): Promise + getAllWattage(): Promise + getEfficacy(lightTypeIndex: number): Promise + getAllEfficacy(): Promise + getIlluminance(lightTypeIndex: number): Promise + getAllIlluminance(): Promise + getIlluminanceDistance(lightTypeIndex: number): Promise + getAllIlluminanceDistance(): Promise + getInitialColorTemperature(lightTypeIndex: number): Promise + getAllInitialColorTemperature(): Promise + getColorFilter_X(lightTypeIndex: number): Promise + getAllColorFilter_X(): Promise + getColorFilter_Y(lightTypeIndex: number): Promise + getAllColorFilter_Y(): Promise + getColorFilter_Z(lightTypeIndex: number): Promise + getAllColorFilter_Z(): Promise + getLossFactor(lightTypeIndex: number): Promise + getAllLossFactor(): Promise + getDimmingColor(lightTypeIndex: number): Promise + getAllDimmingColor(): Promise + + getPhotometricWebFileIndex(lightTypeIndex: number): Promise + getAllPhotometricWebFileIndex(): Promise + getPhotometricWebFile(lightTypeIndex: number): Promise + getFamilyTypeIndex(lightTypeIndex: number): Promise + getAllFamilyTypeIndex(): Promise + getFamilyType(lightTypeIndex: number): Promise +} + +export class LightType implements ILightType { + index: number + lightShapeStyle?: number + emitLength?: number + emitWidth?: number + emitDiameter?: number + lightDistributionStyle?: number + spotBeamAngle?: number + spotFieldAngle?: number + tiltAngle?: number + photometricWebFileName?: string + initialIntensityType?: number + luminosity?: number + flux?: number + wattage?: number + efficacy?: number + illuminance?: number + illuminanceDistance?: number + initialColorTemperature?: number + colorFilter_X?: number + colorFilter_Y?: number + colorFilter_Z?: number + lossFactor?: number + dimmingColor?: number + + photometricWebFileIndex?: number + photometricWebFile?: IAsset + familyTypeIndex?: number + familyType?: IFamilyType + + static async createFromTable(table: ILightTypeTable, index: number): Promise { + let result = new LightType() + result.index = index + + await Promise.all([ + table.getLightShapeStyle(index).then(v => result.lightShapeStyle = v), + table.getEmitLength(index).then(v => result.emitLength = v), + table.getEmitWidth(index).then(v => result.emitWidth = v), + table.getEmitDiameter(index).then(v => result.emitDiameter = v), + table.getLightDistributionStyle(index).then(v => result.lightDistributionStyle = v), + table.getSpotBeamAngle(index).then(v => result.spotBeamAngle = v), + table.getSpotFieldAngle(index).then(v => result.spotFieldAngle = v), + table.getTiltAngle(index).then(v => result.tiltAngle = v), + table.getPhotometricWebFileName(index).then(v => result.photometricWebFileName = v), + table.getInitialIntensityType(index).then(v => result.initialIntensityType = v), + table.getLuminosity(index).then(v => result.luminosity = v), + table.getFlux(index).then(v => result.flux = v), + table.getWattage(index).then(v => result.wattage = v), + table.getEfficacy(index).then(v => result.efficacy = v), + table.getIlluminance(index).then(v => result.illuminance = v), + table.getIlluminanceDistance(index).then(v => result.illuminanceDistance = v), + table.getInitialColorTemperature(index).then(v => result.initialColorTemperature = v), + table.getColorFilter_X(index).then(v => result.colorFilter_X = v), + table.getColorFilter_Y(index).then(v => result.colorFilter_Y = v), + table.getColorFilter_Z(index).then(v => result.colorFilter_Z = v), + table.getLossFactor(index).then(v => result.lossFactor = v), + table.getDimmingColor(index).then(v => result.dimmingColor = v), + table.getPhotometricWebFileIndex(index).then(v => result.photometricWebFileIndex = v), + table.getFamilyTypeIndex(index).then(v => result.familyTypeIndex = v), + ]) + + return result + } +} + +export class LightTypeTable implements ILightTypeTable { + private document: VimDocument + private entityTable: EntityTable + + static async createFromDocument(document: VimDocument): Promise { + const entity = await document.entities.getBfast("Vim.LightType") + + if (!entity) { + return undefined + } + + let table = new LightTypeTable() + table.document = document + table.entityTable = new EntityTable(entity, document.strings) + + return table + } + + getCount(): Promise { + return this.entityTable.getCount() + } + + async get(lightTypeIndex: number): Promise { + return await LightType.createFromTable(this, lightTypeIndex) + } + + async getAll(): Promise { + const localTable = await this.entityTable.getLocal() + + let lightShapeStyle: number[] | undefined + let emitLength: number[] | undefined + let emitWidth: number[] | undefined + let emitDiameter: number[] | undefined + let lightDistributionStyle: number[] | undefined + let spotBeamAngle: number[] | undefined + let spotFieldAngle: number[] | undefined + let tiltAngle: number[] | undefined + let photometricWebFileName: string[] | undefined + let initialIntensityType: number[] | undefined + let luminosity: number[] | undefined + let flux: number[] | undefined + let wattage: number[] | undefined + let efficacy: number[] | undefined + let illuminance: number[] | undefined + let illuminanceDistance: number[] | undefined + let initialColorTemperature: number[] | undefined + let colorFilter_X: number[] | undefined + let colorFilter_Y: number[] | undefined + let colorFilter_Z: number[] | undefined + let lossFactor: number[] | undefined + let dimmingColor: number[] | undefined + let photometricWebFileIndex: number[] | undefined + let familyTypeIndex: number[] | undefined + + await Promise.all([ + (async () => { lightShapeStyle = (await localTable.getNumberArray("int:LightShapeStyle")) })(), + (async () => { emitLength = (await localTable.getNumberArray("double:EmitLength")) })(), + (async () => { emitWidth = (await localTable.getNumberArray("double:EmitWidth")) })(), + (async () => { emitDiameter = (await localTable.getNumberArray("double:EmitDiameter")) })(), + (async () => { lightDistributionStyle = (await localTable.getNumberArray("int:LightDistributionStyle")) })(), + (async () => { spotBeamAngle = (await localTable.getNumberArray("double:SpotBeamAngle")) })(), + (async () => { spotFieldAngle = (await localTable.getNumberArray("double:SpotFieldAngle")) })(), + (async () => { tiltAngle = (await localTable.getNumberArray("double:TiltAngle")) })(), + (async () => { photometricWebFileName = (await localTable.getStringArray("string:PhotometricWebFileName")) })(), + (async () => { initialIntensityType = (await localTable.getNumberArray("int:InitialIntensityType")) })(), + (async () => { luminosity = (await localTable.getNumberArray("double:Luminosity")) })(), + (async () => { flux = (await localTable.getNumberArray("double:Flux")) })(), + (async () => { wattage = (await localTable.getNumberArray("double:Wattage")) })(), + (async () => { efficacy = (await localTable.getNumberArray("double:Efficacy")) })(), + (async () => { illuminance = (await localTable.getNumberArray("double:Illuminance")) })(), + (async () => { illuminanceDistance = (await localTable.getNumberArray("double:IlluminanceDistance")) })(), + (async () => { initialColorTemperature = (await localTable.getNumberArray("double:InitialColorTemperature")) })(), + (async () => { colorFilter_X = (await localTable.getNumberArray("double:ColorFilter.X")) })(), + (async () => { colorFilter_Y = (await localTable.getNumberArray("double:ColorFilter.Y")) })(), + (async () => { colorFilter_Z = (await localTable.getNumberArray("double:ColorFilter.Z")) })(), + (async () => { lossFactor = (await localTable.getNumberArray("double:LossFactor")) })(), + (async () => { dimmingColor = (await localTable.getNumberArray("int:DimmingColor")) })(), + (async () => { photometricWebFileIndex = (await localTable.getNumberArray("index:Vim.Asset:PhotometricWebFile")) })(), + (async () => { familyTypeIndex = (await localTable.getNumberArray("index:Vim.FamilyType:FamilyType")) })(), + ]) + + let lightType: ILightType[] = [] + + const rowCount = await this.getCount() + for (let i = 0; i < rowCount; i++) { + lightType.push({ + index: i, + lightShapeStyle: lightShapeStyle ? lightShapeStyle[i] : undefined, + emitLength: emitLength ? emitLength[i] : undefined, + emitWidth: emitWidth ? emitWidth[i] : undefined, + emitDiameter: emitDiameter ? emitDiameter[i] : undefined, + lightDistributionStyle: lightDistributionStyle ? lightDistributionStyle[i] : undefined, + spotBeamAngle: spotBeamAngle ? spotBeamAngle[i] : undefined, + spotFieldAngle: spotFieldAngle ? spotFieldAngle[i] : undefined, + tiltAngle: tiltAngle ? tiltAngle[i] : undefined, + photometricWebFileName: photometricWebFileName ? photometricWebFileName[i] : undefined, + initialIntensityType: initialIntensityType ? initialIntensityType[i] : undefined, + luminosity: luminosity ? luminosity[i] : undefined, + flux: flux ? flux[i] : undefined, + wattage: wattage ? wattage[i] : undefined, + efficacy: efficacy ? efficacy[i] : undefined, + illuminance: illuminance ? illuminance[i] : undefined, + illuminanceDistance: illuminanceDistance ? illuminanceDistance[i] : undefined, + initialColorTemperature: initialColorTemperature ? initialColorTemperature[i] : undefined, + colorFilter_X: colorFilter_X ? colorFilter_X[i] : undefined, + colorFilter_Y: colorFilter_Y ? colorFilter_Y[i] : undefined, + colorFilter_Z: colorFilter_Z ? colorFilter_Z[i] : undefined, + lossFactor: lossFactor ? lossFactor[i] : undefined, + dimmingColor: dimmingColor ? dimmingColor[i] : undefined, + photometricWebFileIndex: photometricWebFileIndex ? photometricWebFileIndex[i] : undefined, + familyTypeIndex: familyTypeIndex ? familyTypeIndex[i] : undefined + }) + } + + return lightType + } + + async getLightShapeStyle(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "int:LightShapeStyle")) + } + + async getAllLightShapeStyle(): Promise { + return (await this.entityTable.getNumberArray("int:LightShapeStyle")) + } + + async getEmitLength(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:EmitLength")) + } + + async getAllEmitLength(): Promise { + return (await this.entityTable.getNumberArray("double:EmitLength")) + } + + async getEmitWidth(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:EmitWidth")) + } + + async getAllEmitWidth(): Promise { + return (await this.entityTable.getNumberArray("double:EmitWidth")) + } + + async getEmitDiameter(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:EmitDiameter")) + } + + async getAllEmitDiameter(): Promise { + return (await this.entityTable.getNumberArray("double:EmitDiameter")) + } + + async getLightDistributionStyle(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "int:LightDistributionStyle")) + } + + async getAllLightDistributionStyle(): Promise { + return (await this.entityTable.getNumberArray("int:LightDistributionStyle")) + } + + async getSpotBeamAngle(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:SpotBeamAngle")) + } + + async getAllSpotBeamAngle(): Promise { + return (await this.entityTable.getNumberArray("double:SpotBeamAngle")) + } + + async getSpotFieldAngle(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:SpotFieldAngle")) + } + + async getAllSpotFieldAngle(): Promise { + return (await this.entityTable.getNumberArray("double:SpotFieldAngle")) + } + + async getTiltAngle(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:TiltAngle")) + } + + async getAllTiltAngle(): Promise { + return (await this.entityTable.getNumberArray("double:TiltAngle")) + } + + async getPhotometricWebFileName(lightTypeIndex: number): Promise { + return (await this.entityTable.getString(lightTypeIndex, "string:PhotometricWebFileName")) + } + + async getAllPhotometricWebFileName(): Promise { + return (await this.entityTable.getStringArray("string:PhotometricWebFileName")) + } + + async getInitialIntensityType(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "int:InitialIntensityType")) + } + + async getAllInitialIntensityType(): Promise { + return (await this.entityTable.getNumberArray("int:InitialIntensityType")) + } + + async getLuminosity(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:Luminosity")) + } + + async getAllLuminosity(): Promise { + return (await this.entityTable.getNumberArray("double:Luminosity")) + } + + async getFlux(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:Flux")) + } + + async getAllFlux(): Promise { + return (await this.entityTable.getNumberArray("double:Flux")) + } + + async getWattage(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:Wattage")) + } + + async getAllWattage(): Promise { + return (await this.entityTable.getNumberArray("double:Wattage")) + } + + async getEfficacy(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:Efficacy")) + } + + async getAllEfficacy(): Promise { + return (await this.entityTable.getNumberArray("double:Efficacy")) + } + + async getIlluminance(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:Illuminance")) + } + + async getAllIlluminance(): Promise { + return (await this.entityTable.getNumberArray("double:Illuminance")) + } + + async getIlluminanceDistance(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:IlluminanceDistance")) + } + + async getAllIlluminanceDistance(): Promise { + return (await this.entityTable.getNumberArray("double:IlluminanceDistance")) + } + + async getInitialColorTemperature(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:InitialColorTemperature")) + } + + async getAllInitialColorTemperature(): Promise { + return (await this.entityTable.getNumberArray("double:InitialColorTemperature")) + } + + async getColorFilter_X(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:ColorFilter.X")) + } + + async getAllColorFilter_X(): Promise { + return (await this.entityTable.getNumberArray("double:ColorFilter.X")) + } + + async getColorFilter_Y(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:ColorFilter.Y")) + } + + async getAllColorFilter_Y(): Promise { + return (await this.entityTable.getNumberArray("double:ColorFilter.Y")) + } + + async getColorFilter_Z(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:ColorFilter.Z")) + } + + async getAllColorFilter_Z(): Promise { + return (await this.entityTable.getNumberArray("double:ColorFilter.Z")) + } + + async getLossFactor(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "double:LossFactor")) + } + + async getAllLossFactor(): Promise { + return (await this.entityTable.getNumberArray("double:LossFactor")) + } + + async getDimmingColor(lightTypeIndex: number): Promise { + return (await this.entityTable.getNumber(lightTypeIndex, "int:DimmingColor")) + } + + async getAllDimmingColor(): Promise { + return (await this.entityTable.getNumberArray("int:DimmingColor")) + } + + async getPhotometricWebFileIndex(lightTypeIndex: number): Promise { + return await this.entityTable.getNumber(lightTypeIndex, "index:Vim.Asset:PhotometricWebFile") + } + + async getAllPhotometricWebFileIndex(): Promise { + return await this.entityTable.getNumberArray("index:Vim.Asset:PhotometricWebFile") + } + + async getPhotometricWebFile(lightTypeIndex: number): Promise { + const index = await this.getPhotometricWebFileIndex(lightTypeIndex) + + if (index === undefined) { + return undefined + } + + return await this.document.asset?.get(index) + } + + async getFamilyTypeIndex(lightTypeIndex: number): Promise { + return await this.entityTable.getNumber(lightTypeIndex, "index:Vim.FamilyType:FamilyType") + } + + async getAllFamilyTypeIndex(): Promise { + return await this.entityTable.getNumberArray("index:Vim.FamilyType:FamilyType") + } + + async getFamilyType(lightTypeIndex: number): Promise { + const index = await this.getFamilyTypeIndex(lightTypeIndex) + + if (index === undefined) { + return undefined + } + + return await this.document.familyType?.get(index) + } + +} + +export interface ILightSource { + index: number + origin_X?: number + origin_Y?: number + origin_Z?: number + basisX_X?: number + basisX_Y?: number + basisX_Z?: number + basisY_X?: number + basisY_Y?: number + basisY_Z?: number + basisZ_X?: number + basisZ_Y?: number + basisZ_Z?: number + hasLightSourceTransform?: boolean + isOn?: boolean + + lightTypeIndex?: number + lightType?: ILightType + elementIndex?: number + element?: IElement +} + +export interface ILightSourceTable { + getCount(): Promise + get(lightSourceIndex: number): Promise + getAll(): Promise + + getOrigin_X(lightSourceIndex: number): Promise + getAllOrigin_X(): Promise + getOrigin_Y(lightSourceIndex: number): Promise + getAllOrigin_Y(): Promise + getOrigin_Z(lightSourceIndex: number): Promise + getAllOrigin_Z(): Promise + getBasisX_X(lightSourceIndex: number): Promise + getAllBasisX_X(): Promise + getBasisX_Y(lightSourceIndex: number): Promise + getAllBasisX_Y(): Promise + getBasisX_Z(lightSourceIndex: number): Promise + getAllBasisX_Z(): Promise + getBasisY_X(lightSourceIndex: number): Promise + getAllBasisY_X(): Promise + getBasisY_Y(lightSourceIndex: number): Promise + getAllBasisY_Y(): Promise + getBasisY_Z(lightSourceIndex: number): Promise + getAllBasisY_Z(): Promise + getBasisZ_X(lightSourceIndex: number): Promise + getAllBasisZ_X(): Promise + getBasisZ_Y(lightSourceIndex: number): Promise + getAllBasisZ_Y(): Promise + getBasisZ_Z(lightSourceIndex: number): Promise + getAllBasisZ_Z(): Promise + getHasLightSourceTransform(lightSourceIndex: number): Promise + getAllHasLightSourceTransform(): Promise + getIsOn(lightSourceIndex: number): Promise + getAllIsOn(): Promise + + getLightTypeIndex(lightSourceIndex: number): Promise + getAllLightTypeIndex(): Promise + getLightType(lightSourceIndex: number): Promise + getElementIndex(lightSourceIndex: number): Promise + getAllElementIndex(): Promise + getElement(lightSourceIndex: number): Promise +} + +export class LightSource implements ILightSource { + index: number + origin_X?: number + origin_Y?: number + origin_Z?: number + basisX_X?: number + basisX_Y?: number + basisX_Z?: number + basisY_X?: number + basisY_Y?: number + basisY_Z?: number + basisZ_X?: number + basisZ_Y?: number + basisZ_Z?: number + hasLightSourceTransform?: boolean + isOn?: boolean + + lightTypeIndex?: number + lightType?: ILightType + elementIndex?: number + element?: IElement + + static async createFromTable(table: ILightSourceTable, index: number): Promise { + let result = new LightSource() + result.index = index + + await Promise.all([ + table.getOrigin_X(index).then(v => result.origin_X = v), + table.getOrigin_Y(index).then(v => result.origin_Y = v), + table.getOrigin_Z(index).then(v => result.origin_Z = v), + table.getBasisX_X(index).then(v => result.basisX_X = v), + table.getBasisX_Y(index).then(v => result.basisX_Y = v), + table.getBasisX_Z(index).then(v => result.basisX_Z = v), + table.getBasisY_X(index).then(v => result.basisY_X = v), + table.getBasisY_Y(index).then(v => result.basisY_Y = v), + table.getBasisY_Z(index).then(v => result.basisY_Z = v), + table.getBasisZ_X(index).then(v => result.basisZ_X = v), + table.getBasisZ_Y(index).then(v => result.basisZ_Y = v), + table.getBasisZ_Z(index).then(v => result.basisZ_Z = v), + table.getHasLightSourceTransform(index).then(v => result.hasLightSourceTransform = v), + table.getIsOn(index).then(v => result.isOn = v), + table.getLightTypeIndex(index).then(v => result.lightTypeIndex = v), + table.getElementIndex(index).then(v => result.elementIndex = v), + ]) + + return result + } +} + +export class LightSourceTable implements ILightSourceTable { + private document: VimDocument + private entityTable: EntityTable + + static async createFromDocument(document: VimDocument): Promise { + const entity = await document.entities.getBfast("Vim.LightSource") + + if (!entity) { + return undefined + } + + let table = new LightSourceTable() + table.document = document + table.entityTable = new EntityTable(entity, document.strings) + + return table + } + + getCount(): Promise { + return this.entityTable.getCount() + } + + async get(lightSourceIndex: number): Promise { + return await LightSource.createFromTable(this, lightSourceIndex) + } + + async getAll(): Promise { + const localTable = await this.entityTable.getLocal() + + let origin_X: number[] | undefined + let origin_Y: number[] | undefined + let origin_Z: number[] | undefined + let basisX_X: number[] | undefined + let basisX_Y: number[] | undefined + let basisX_Z: number[] | undefined + let basisY_X: number[] | undefined + let basisY_Y: number[] | undefined + let basisY_Z: number[] | undefined + let basisZ_X: number[] | undefined + let basisZ_Y: number[] | undefined + let basisZ_Z: number[] | undefined + let hasLightSourceTransform: boolean[] | undefined + let isOn: boolean[] | undefined + let lightTypeIndex: number[] | undefined + let elementIndex: number[] | undefined + + await Promise.all([ + (async () => { origin_X = (await localTable.getNumberArray("double:Origin.X")) })(), + (async () => { origin_Y = (await localTable.getNumberArray("double:Origin.Y")) })(), + (async () => { origin_Z = (await localTable.getNumberArray("double:Origin.Z")) })(), + (async () => { basisX_X = (await localTable.getNumberArray("double:BasisX.X")) })(), + (async () => { basisX_Y = (await localTable.getNumberArray("double:BasisX.Y")) })(), + (async () => { basisX_Z = (await localTable.getNumberArray("double:BasisX.Z")) })(), + (async () => { basisY_X = (await localTable.getNumberArray("double:BasisY.X")) })(), + (async () => { basisY_Y = (await localTable.getNumberArray("double:BasisY.Y")) })(), + (async () => { basisY_Z = (await localTable.getNumberArray("double:BasisY.Z")) })(), + (async () => { basisZ_X = (await localTable.getNumberArray("double:BasisZ.X")) })(), + (async () => { basisZ_Y = (await localTable.getNumberArray("double:BasisZ.Y")) })(), + (async () => { basisZ_Z = (await localTable.getNumberArray("double:BasisZ.Z")) })(), + (async () => { hasLightSourceTransform = (await localTable.getBooleanArray("byte:HasLightSourceTransform")) })(), + (async () => { isOn = (await localTable.getBooleanArray("byte:IsOn")) })(), + (async () => { lightTypeIndex = (await localTable.getNumberArray("index:Vim.LightType:LightType")) })(), + (async () => { elementIndex = (await localTable.getNumberArray("index:Vim.Element:Element")) })(), + ]) + + let lightSource: ILightSource[] = [] + + const rowCount = await this.getCount() + for (let i = 0; i < rowCount; i++) { + lightSource.push({ + index: i, + origin_X: origin_X ? origin_X[i] : undefined, + origin_Y: origin_Y ? origin_Y[i] : undefined, + origin_Z: origin_Z ? origin_Z[i] : undefined, + basisX_X: basisX_X ? basisX_X[i] : undefined, + basisX_Y: basisX_Y ? basisX_Y[i] : undefined, + basisX_Z: basisX_Z ? basisX_Z[i] : undefined, + basisY_X: basisY_X ? basisY_X[i] : undefined, + basisY_Y: basisY_Y ? basisY_Y[i] : undefined, + basisY_Z: basisY_Z ? basisY_Z[i] : undefined, + basisZ_X: basisZ_X ? basisZ_X[i] : undefined, + basisZ_Y: basisZ_Y ? basisZ_Y[i] : undefined, + basisZ_Z: basisZ_Z ? basisZ_Z[i] : undefined, + hasLightSourceTransform: hasLightSourceTransform ? hasLightSourceTransform[i] : undefined, + isOn: isOn ? isOn[i] : undefined, + lightTypeIndex: lightTypeIndex ? lightTypeIndex[i] : undefined, + elementIndex: elementIndex ? elementIndex[i] : undefined + }) + } + + return lightSource + } + + async getOrigin_X(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:Origin.X")) + } + + async getAllOrigin_X(): Promise { + return (await this.entityTable.getNumberArray("double:Origin.X")) + } + + async getOrigin_Y(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:Origin.Y")) + } + + async getAllOrigin_Y(): Promise { + return (await this.entityTable.getNumberArray("double:Origin.Y")) + } + + async getOrigin_Z(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:Origin.Z")) + } + + async getAllOrigin_Z(): Promise { + return (await this.entityTable.getNumberArray("double:Origin.Z")) + } + + async getBasisX_X(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisX.X")) + } + + async getAllBasisX_X(): Promise { + return (await this.entityTable.getNumberArray("double:BasisX.X")) + } + + async getBasisX_Y(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisX.Y")) + } + + async getAllBasisX_Y(): Promise { + return (await this.entityTable.getNumberArray("double:BasisX.Y")) + } + + async getBasisX_Z(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisX.Z")) + } + + async getAllBasisX_Z(): Promise { + return (await this.entityTable.getNumberArray("double:BasisX.Z")) + } + + async getBasisY_X(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisY.X")) + } + + async getAllBasisY_X(): Promise { + return (await this.entityTable.getNumberArray("double:BasisY.X")) + } + + async getBasisY_Y(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisY.Y")) + } + + async getAllBasisY_Y(): Promise { + return (await this.entityTable.getNumberArray("double:BasisY.Y")) + } + + async getBasisY_Z(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisY.Z")) + } + + async getAllBasisY_Z(): Promise { + return (await this.entityTable.getNumberArray("double:BasisY.Z")) + } + + async getBasisZ_X(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisZ.X")) + } + + async getAllBasisZ_X(): Promise { + return (await this.entityTable.getNumberArray("double:BasisZ.X")) + } + + async getBasisZ_Y(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisZ.Y")) + } + + async getAllBasisZ_Y(): Promise { + return (await this.entityTable.getNumberArray("double:BasisZ.Y")) + } + + async getBasisZ_Z(lightSourceIndex: number): Promise { + return (await this.entityTable.getNumber(lightSourceIndex, "double:BasisZ.Z")) + } + + async getAllBasisZ_Z(): Promise { + return (await this.entityTable.getNumberArray("double:BasisZ.Z")) + } + + async getHasLightSourceTransform(lightSourceIndex: number): Promise { + return (await this.entityTable.getBoolean(lightSourceIndex, "byte:HasLightSourceTransform")) + } + + async getAllHasLightSourceTransform(): Promise { + return (await this.entityTable.getBooleanArray("byte:HasLightSourceTransform")) + } + + async getIsOn(lightSourceIndex: number): Promise { + return (await this.entityTable.getBoolean(lightSourceIndex, "byte:IsOn")) + } + + async getAllIsOn(): Promise { + return (await this.entityTable.getBooleanArray("byte:IsOn")) + } + + async getLightTypeIndex(lightSourceIndex: number): Promise { + return await this.entityTable.getNumber(lightSourceIndex, "index:Vim.LightType:LightType") + } + + async getAllLightTypeIndex(): Promise { + return await this.entityTable.getNumberArray("index:Vim.LightType:LightType") + } + + async getLightType(lightSourceIndex: number): Promise { + const index = await this.getLightTypeIndex(lightSourceIndex) + + if (index === undefined) { + return undefined + } + + return await this.document.lightType?.get(index) + } + + async getElementIndex(lightSourceIndex: number): Promise { + return await this.entityTable.getNumber(lightSourceIndex, "index:Vim.Element:Element") + } + + async getAllElementIndex(): Promise { + return await this.entityTable.getNumberArray("index:Vim.Element:Element") + } + + async getElement(lightSourceIndex: number): Promise { + const index = await this.getElementIndex(lightSourceIndex) + + if (index === undefined) { + return undefined + } + + return await this.document.element?.get(index) + } + +} + +export interface ISunAndShadowSettings { + index: number + sunAndShadowType?: string + usesDST?: boolean + activeFrameTime?: string + startDateAndTime?: string + endDateAndTime?: string + activeFrame?: number + numberOfFrames?: number + altitude?: number + azimuth?: number + relativeToView?: boolean + + viewIndex?: number + view?: IView +} + +export interface ISunAndShadowSettingsTable { + getCount(): Promise + get(sunAndShadowSettingsIndex: number): Promise + getAll(): Promise + + getSunAndShadowType(sunAndShadowSettingsIndex: number): Promise + getAllSunAndShadowType(): Promise + getUsesDST(sunAndShadowSettingsIndex: number): Promise + getAllUsesDST(): Promise + getActiveFrameTime(sunAndShadowSettingsIndex: number): Promise + getAllActiveFrameTime(): Promise + getStartDateAndTime(sunAndShadowSettingsIndex: number): Promise + getAllStartDateAndTime(): Promise + getEndDateAndTime(sunAndShadowSettingsIndex: number): Promise + getAllEndDateAndTime(): Promise + getActiveFrame(sunAndShadowSettingsIndex: number): Promise + getAllActiveFrame(): Promise + getNumberOfFrames(sunAndShadowSettingsIndex: number): Promise + getAllNumberOfFrames(): Promise + getAltitude(sunAndShadowSettingsIndex: number): Promise + getAllAltitude(): Promise + getAzimuth(sunAndShadowSettingsIndex: number): Promise + getAllAzimuth(): Promise + getRelativeToView(sunAndShadowSettingsIndex: number): Promise + getAllRelativeToView(): Promise + + getViewIndex(sunAndShadowSettingsIndex: number): Promise + getAllViewIndex(): Promise + getView(sunAndShadowSettingsIndex: number): Promise +} + +export class SunAndShadowSettings implements ISunAndShadowSettings { + index: number + sunAndShadowType?: string + usesDST?: boolean + activeFrameTime?: string + startDateAndTime?: string + endDateAndTime?: string + activeFrame?: number + numberOfFrames?: number + altitude?: number + azimuth?: number + relativeToView?: boolean + + viewIndex?: number + view?: IView + + static async createFromTable(table: ISunAndShadowSettingsTable, index: number): Promise { + let result = new SunAndShadowSettings() + result.index = index + + await Promise.all([ + table.getSunAndShadowType(index).then(v => result.sunAndShadowType = v), + table.getUsesDST(index).then(v => result.usesDST = v), + table.getActiveFrameTime(index).then(v => result.activeFrameTime = v), + table.getStartDateAndTime(index).then(v => result.startDateAndTime = v), + table.getEndDateAndTime(index).then(v => result.endDateAndTime = v), + table.getActiveFrame(index).then(v => result.activeFrame = v), + table.getNumberOfFrames(index).then(v => result.numberOfFrames = v), + table.getAltitude(index).then(v => result.altitude = v), + table.getAzimuth(index).then(v => result.azimuth = v), + table.getRelativeToView(index).then(v => result.relativeToView = v), + table.getViewIndex(index).then(v => result.viewIndex = v), + ]) + + return result + } +} + +export class SunAndShadowSettingsTable implements ISunAndShadowSettingsTable { + private document: VimDocument + private entityTable: EntityTable + + static async createFromDocument(document: VimDocument): Promise { + const entity = await document.entities.getBfast("Vim.SunAndShadowSettings") + + if (!entity) { + return undefined + } + + let table = new SunAndShadowSettingsTable() + table.document = document + table.entityTable = new EntityTable(entity, document.strings) + + return table + } + + getCount(): Promise { + return this.entityTable.getCount() + } + + async get(sunAndShadowSettingsIndex: number): Promise { + return await SunAndShadowSettings.createFromTable(this, sunAndShadowSettingsIndex) + } + + async getAll(): Promise { + const localTable = await this.entityTable.getLocal() + + let sunAndShadowType: string[] | undefined + let usesDST: boolean[] | undefined + let activeFrameTime: string[] | undefined + let startDateAndTime: string[] | undefined + let endDateAndTime: string[] | undefined + let activeFrame: number[] | undefined + let numberOfFrames: number[] | undefined + let altitude: number[] | undefined + let azimuth: number[] | undefined + let relativeToView: boolean[] | undefined + let viewIndex: number[] | undefined + + await Promise.all([ + (async () => { sunAndShadowType = (await localTable.getStringArray("string:SunAndShadowType")) })(), + (async () => { usesDST = (await localTable.getBooleanArray("byte:UsesDST")) })(), + (async () => { activeFrameTime = (await localTable.getStringArray("string:ActiveFrameTime")) })(), + (async () => { startDateAndTime = (await localTable.getStringArray("string:StartDateAndTime")) })(), + (async () => { endDateAndTime = (await localTable.getStringArray("string:EndDateAndTime")) })(), + (async () => { activeFrame = (await localTable.getNumberArray("int:ActiveFrame")) })(), + (async () => { numberOfFrames = (await localTable.getNumberArray("int:NumberOfFrames")) })(), + (async () => { altitude = (await localTable.getNumberArray("double:Altitude")) })(), + (async () => { azimuth = (await localTable.getNumberArray("double:Azimuth")) })(), + (async () => { relativeToView = (await localTable.getBooleanArray("byte:RelativeToView")) })(), + (async () => { viewIndex = (await localTable.getNumberArray("index:Vim.View:View")) })(), + ]) + + let sunAndShadowSettings: ISunAndShadowSettings[] = [] + + const rowCount = await this.getCount() + for (let i = 0; i < rowCount; i++) { + sunAndShadowSettings.push({ + index: i, + sunAndShadowType: sunAndShadowType ? sunAndShadowType[i] : undefined, + usesDST: usesDST ? usesDST[i] : undefined, + activeFrameTime: activeFrameTime ? activeFrameTime[i] : undefined, + startDateAndTime: startDateAndTime ? startDateAndTime[i] : undefined, + endDateAndTime: endDateAndTime ? endDateAndTime[i] : undefined, + activeFrame: activeFrame ? activeFrame[i] : undefined, + numberOfFrames: numberOfFrames ? numberOfFrames[i] : undefined, + altitude: altitude ? altitude[i] : undefined, + azimuth: azimuth ? azimuth[i] : undefined, + relativeToView: relativeToView ? relativeToView[i] : undefined, + viewIndex: viewIndex ? viewIndex[i] : undefined + }) + } + + return sunAndShadowSettings + } + + async getSunAndShadowType(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getString(sunAndShadowSettingsIndex, "string:SunAndShadowType")) + } + + async getAllSunAndShadowType(): Promise { + return (await this.entityTable.getStringArray("string:SunAndShadowType")) + } + + async getUsesDST(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getBoolean(sunAndShadowSettingsIndex, "byte:UsesDST")) + } + + async getAllUsesDST(): Promise { + return (await this.entityTable.getBooleanArray("byte:UsesDST")) + } + + async getActiveFrameTime(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getString(sunAndShadowSettingsIndex, "string:ActiveFrameTime")) + } + + async getAllActiveFrameTime(): Promise { + return (await this.entityTable.getStringArray("string:ActiveFrameTime")) + } + + async getStartDateAndTime(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getString(sunAndShadowSettingsIndex, "string:StartDateAndTime")) + } + + async getAllStartDateAndTime(): Promise { + return (await this.entityTable.getStringArray("string:StartDateAndTime")) + } + + async getEndDateAndTime(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getString(sunAndShadowSettingsIndex, "string:EndDateAndTime")) + } + + async getAllEndDateAndTime(): Promise { + return (await this.entityTable.getStringArray("string:EndDateAndTime")) + } + + async getActiveFrame(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getNumber(sunAndShadowSettingsIndex, "int:ActiveFrame")) + } + + async getAllActiveFrame(): Promise { + return (await this.entityTable.getNumberArray("int:ActiveFrame")) + } + + async getNumberOfFrames(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getNumber(sunAndShadowSettingsIndex, "int:NumberOfFrames")) + } + + async getAllNumberOfFrames(): Promise { + return (await this.entityTable.getNumberArray("int:NumberOfFrames")) + } + + async getAltitude(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getNumber(sunAndShadowSettingsIndex, "double:Altitude")) + } + + async getAllAltitude(): Promise { + return (await this.entityTable.getNumberArray("double:Altitude")) + } + + async getAzimuth(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getNumber(sunAndShadowSettingsIndex, "double:Azimuth")) + } + + async getAllAzimuth(): Promise { + return (await this.entityTable.getNumberArray("double:Azimuth")) + } + + async getRelativeToView(sunAndShadowSettingsIndex: number): Promise { + return (await this.entityTable.getBoolean(sunAndShadowSettingsIndex, "byte:RelativeToView")) + } + + async getAllRelativeToView(): Promise { + return (await this.entityTable.getBooleanArray("byte:RelativeToView")) + } + + async getViewIndex(sunAndShadowSettingsIndex: number): Promise { + return await this.entityTable.getNumber(sunAndShadowSettingsIndex, "index:Vim.View:View") + } + + async getAllViewIndex(): Promise { + return await this.entityTable.getNumberArray("index:Vim.View:View") + } + + async getView(sunAndShadowSettingsIndex: number): Promise { + const index = await this.getViewIndex(sunAndShadowSettingsIndex) + + if (index === undefined) { + return undefined + } + + return await this.document.view?.get(index) + } + +} + export class VimDocument { asset: IAssetTable | undefined displayUnit: IDisplayUnitTable | undefined @@ -10768,6 +11874,9 @@ export class VimDocument { viewInViewSheet: IViewInViewSheetTable | undefined site: ISiteTable | undefined building: IBuildingTable | undefined + lightType: ILightTypeTable | undefined + lightSource: ILightSourceTable | undefined + sunAndShadowSettings: ISunAndShadowSettingsTable | undefined entities: BFast strings: string[] | undefined @@ -10839,6 +11948,9 @@ export class VimDocument { doc.viewInViewSheet = await ViewInViewSheetTable.createFromDocument(doc) doc.site = await SiteTable.createFromDocument(doc) doc.building = await BuildingTable.createFromDocument(doc) + doc.lightType = await LightTypeTable.createFromDocument(doc) + doc.lightSource = await LightSourceTable.createFromDocument(doc) + doc.sunAndShadowSettings = await SunAndShadowSettingsTable.createFromDocument(doc) return doc }