diff --git a/extern/rerun b/extern/rerun index 5bf9c4a..42eeab2 160000 --- a/extern/rerun +++ b/extern/rerun @@ -1 +1 @@ -Subproject commit 5bf9c4a6027ce525a11c35dc9ff43e77324c3e6d +Subproject commit 42eeab2eecfb2f7dd5aab5f501bf54b358162a55 diff --git a/src/Rerun.Net.CodeGen/Emitters/ComponentEmitter.cs b/src/Rerun.Net.CodeGen/Emitters/ComponentEmitter.cs index d2c6a6e..3bb75ff 100644 --- a/src/Rerun.Net.CodeGen/Emitters/ComponentEmitter.cs +++ b/src/Rerun.Net.CodeGen/Emitters/ComponentEmitter.cs @@ -147,11 +147,12 @@ private string EmitEnumComponent(FbsEnum e) return sb.ToString(); } - /// Qualify datatype references to avoid name collisions with component names. + /// Qualify datatype references with the Datatypes. prefix so the + /// blueprint namespace rewrite in Program.cs can unambiguously fully-qualify them. private static string QualifyDatatypeRef(FbsReference r, string componentName) { var shortName = GetShortName(r.FullyQualifiedName); - if (shortName == componentName && r.FullyQualifiedName.Contains("datatypes")) + if (r.FullyQualifiedName.Contains("datatypes")) return $"Datatypes.{shortName}"; return shortName; } diff --git a/src/Rerun.Net.CodeGen/Emitters/DatatypeEmitter.cs b/src/Rerun.Net.CodeGen/Emitters/DatatypeEmitter.cs index 2e8c9e4..44f9ed1 100644 --- a/src/Rerun.Net.CodeGen/Emitters/DatatypeEmitter.cs +++ b/src/Rerun.Net.CodeGen/Emitters/DatatypeEmitter.cs @@ -4,6 +4,13 @@ namespace Rerun.Net.CodeGen.Emitters; internal class DatatypeEmitter : EmitterBase { + private readonly TypeRegistry? _registry; + + public DatatypeEmitter(TypeRegistry? registry = null) + { + _registry = registry; + } + // Primitive-wrapper datatypes that clash with System types. // Components referencing them can optionally inline the primitive Arrow directly. internal static readonly Dictionary PrimitiveWrapperTypes = new() @@ -274,6 +281,14 @@ private string EmitTable(FbsTable t) sb.AppendLine($" foreach (var v in data) {f.Name}Builder.Append(v.{fPropName});"); sb.AppendLine($" var {f.Name}Array = (IArrowArray){f.Name}Builder.Build();"); break; + case FbsReference r when _registry?.Resolve(r.FullyQualifiedName) is FbsEnum enumType: + // Enum-typed reference field: cast to underlying primitive and use a primitive Arrow builder. + var enumPrimCs = MapPrimitiveToCSharp(enumType.UnderlyingType); + var enumPrimBuilder = MapPrimitiveToArrowBuilder(enumType.UnderlyingType); + sb.AppendLine($" var {f.Name}Builder = new {enumPrimBuilder}();"); + sb.AppendLine($" foreach (var v in data) {f.Name}Builder.Append(({enumPrimCs})v.{fPropName});"); + sb.AppendLine($" var {f.Name}Array = (IArrowArray){f.Name}Builder.Build();"); + break; case FbsReference r: var innerName = GetShortName(r.FullyQualifiedName); sb.AppendLine($" var {f.Name}Tmp = new {innerName}[data.Length];"); diff --git a/src/Rerun.Net.CodeGen/FbsParser.cs b/src/Rerun.Net.CodeGen/FbsParser.cs index cbf975c..3619418 100644 --- a/src/Rerun.Net.CodeGen/FbsParser.cs +++ b/src/Rerun.Net.CodeGen/FbsParser.cs @@ -140,15 +140,15 @@ private static string CollectBlock(string[] lines, ref int i) return kind switch { - "struct" => new FbsStruct(name, ns, ParseFields(body), attrs, doc), - "table" => new FbsTable(name, ns, ParseFields(body), attrs, doc), + "struct" => new FbsStruct(name, ns, ParseFields(body, ns), attrs, doc), + "table" => new FbsTable(name, ns, ParseFields(body, ns), attrs, doc), "enum" => new FbsEnum(name, ns, underlying, ParseEnumValues(body), attrs, doc), "union" => new FbsUnion(name, ns, ParseUnionVariants(body), attrs, doc), _ => null, }; } - private List ParseFields(string body) + private List ParseFields(string body, string currentNamespace) { var fields = new List(); var docBuffer = new List(); @@ -185,20 +185,20 @@ private List ParseFields(string body) fieldAttrs.Remove("order"); } - var fieldType = ParseFieldType(typeStr); + var fieldType = ParseFieldType(typeStr, currentNamespace); fields.Add(new FbsField(fieldName, fieldType, fieldAttrs, nullable, order, doc)); } return fields.OrderBy(f => f.Order).ToList(); } - private FbsFieldType ParseFieldType(string typeStr) + private FbsFieldType ParseFieldType(string typeStr, string currentNamespace = "") { // Fixed array: [type: N] var fixedMatch = Regex.Match(typeStr, @"^\[(\w+)\s*:\s*(\d+)\]$"); if (fixedMatch.Success) { - var elemType = ParseFieldType(fixedMatch.Groups[1].Value); + var elemType = ParseFieldType(fixedMatch.Groups[1].Value, currentNamespace); return new FbsFixedArray(elemType, int.Parse(fixedMatch.Groups[2].Value)); } @@ -206,7 +206,7 @@ private FbsFieldType ParseFieldType(string typeStr) var arrayMatch = Regex.Match(typeStr, @"^\[(.+)\]$"); if (arrayMatch.Success) { - var elemType = ParseFieldType(arrayMatch.Groups[1].Value); + var elemType = ParseFieldType(arrayMatch.Groups[1].Value, currentNamespace); return new FbsArray(elemType); } @@ -214,7 +214,9 @@ private FbsFieldType ParseFieldType(string typeStr) if (Primitives.Contains(typeStr)) return new FbsPrimitive(typeStr); - // Qualified reference + // Reference: qualify same-namespace shorthand with the current namespace. + if (!typeStr.Contains('.') && currentNamespace.Length > 0) + return new FbsReference($"{currentNamespace}.{typeStr}"); return new FbsReference(typeStr); } diff --git a/src/Rerun.Net.CodeGen/Program.cs b/src/Rerun.Net.CodeGen/Program.cs index 1e0ad26..17cf733 100644 --- a/src/Rerun.Net.CodeGen/Program.cs +++ b/src/Rerun.Net.CodeGen/Program.cs @@ -1,3 +1,4 @@ +using System.Text.RegularExpressions; using Rerun.Net.CodeGen; using Rerun.Net.CodeGen.Emitters; @@ -44,7 +45,7 @@ } } -var datatypeEmitter = new DatatypeEmitter(); +var datatypeEmitter = new DatatypeEmitter(registry); var componentEmitter = new ComponentEmitter(); var archetypeEmitter = new ArchetypeEmitter(); @@ -138,6 +139,43 @@ bool ArchetypeHasMissingComponent(FbsTable arch) } } +// Sets of all known type short-names per category, used by the blueprint +// post-processor to fully-qualify cross-namespace references. +var coreDatatypeNames = registry.GetByNamespace("rerun.datatypes") + .Select(t => t.Name).ToHashSet(); +var coreComponentNames = registry.GetByNamespace("rerun.components") + .Select(t => t.Name).ToHashSet(); +var bpDatatypeNames = registry.GetByNamespace("rerun.blueprint.datatypes") + .Select(t => t.Name).ToHashSet(); +var bpComponentNames = registry.GetByNamespace("rerun.blueprint.components") + .Select(t => t.Name).ToHashSet(); + +// Inside Rerun.Net.Blueprint.* the unqualified names "Datatypes" and "Components" +// resolve to the closer Rerun.Net.Blueprint.{Datatypes,Components} sibling, which +// shadows the matching core namespaces. Rewrite every "Datatypes.X" / "Components.X" +// reference to a fully-qualified global:: path so the resolution is unambiguous. +var qualifiedRefRegex = new Regex(@"\b(Datatypes|Components)\.([A-Z]\w*)"); +string FullyQualifyBlueprintRefs(string code) => qualifiedRefRegex.Replace(code, m => +{ + var category = m.Groups[1].Value; + var name = m.Groups[2].Value; + if (category == "Datatypes") + { + if (bpDatatypeNames.Contains(name)) + return $"global::Rerun.Net.Blueprint.Datatypes.{name}"; + if (coreDatatypeNames.Contains(name)) + return $"global::Rerun.Net.Datatypes.{name}"; + } + else + { + if (bpComponentNames.Contains(name)) + return $"global::Rerun.Net.Blueprint.Components.{name}"; + if (coreComponentNames.Contains(name)) + return $"global::Rerun.Net.Components.{name}"; + } + return m.Value; +}); + // Generate blueprint types — same emitters, different namespace mapping var bpNamespaces = new[] { ("rerun.blueprint.datatypes", "Blueprint/Datatypes", datatypeEmitter), @@ -172,6 +210,10 @@ bool ArchetypeHasMissingComponent(FbsTable arch) .Replace("namespace Rerun.Net.Archetypes;", "using Rerun.Net.Components;\nusing Rerun.Net.Blueprint.Components;\n\nnamespace Rerun.Net.Blueprint.Archetypes;"); + // Fully-qualify cross-namespace type references so blueprint sibling + // namespaces don't shadow the core ones. + code = FullyQualifyBlueprintRefs(code); + var outFile = Path.Combine(outputPath, subDir, $"{type.Name}.g.cs"); Directory.CreateDirectory(Path.GetDirectoryName(outFile)!); File.WriteAllText(outFile, code); diff --git a/src/Rerun.Net/Blueprint/Archetypes/ActiveVisualizers.g.cs b/src/Rerun.Net/Blueprint/Archetypes/ActiveVisualizers.g.cs index ba6f67e..c1de96a 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/ActiveVisualizers.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/ActiveVisualizers.g.cs @@ -25,13 +25,13 @@ public sealed partial class ActiveVisualizers : IAsComponents public ComponentBatch InstructionIds { get; private set; } - public ActiveVisualizers(ReadOnlySpan instruction_ids) + public ActiveVisualizers(ReadOnlySpan instruction_ids) { InstructionIds = ComponentBatch.FromLoggable(instruction_ids, new ComponentDescriptor(ArchetypeName, "ActiveVisualizers:instruction_ids", "rerun.blueprint.components.VisualizerInstructionId")); } - public ActiveVisualizers(params Components.VisualizerInstructionId[] instruction_ids) : this(instruction_ids.AsSpan()) { } + public ActiveVisualizers(params global::Rerun.Net.Blueprint.Components.VisualizerInstructionId[] instruction_ids) : this(instruction_ids.AsSpan()) { } /// Create an empty ActiveVisualizers for partial updates. Use With*() to set fields. public static ActiveVisualizers UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/Background.g.cs b/src/Rerun.Net/Blueprint/Archetypes/Background.g.cs new file mode 100644 index 0000000..6ba2e1f --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/Background.g.cs @@ -0,0 +1,54 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration for the background of a spatial view. +/// +public sealed partial class Background : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.Background"; + + public ComponentBatch Kind { get; private set; } + public ComponentBatch? Color { get; private set; } + + public Background(ReadOnlySpan kind) + { + Kind = ComponentBatch.FromLoggable(kind, + new ComponentDescriptor(ArchetypeName, "Background:kind", "rerun.blueprint.components.BackgroundKind")); + } + + public Background(params global::Rerun.Net.Blueprint.Components.BackgroundKind[] kind) : this(kind.AsSpan()) { } + + public Background WithColor(ReadOnlySpan color) + { + Color = ComponentBatch.FromLoggable(color, + new ComponentDescriptor(ArchetypeName, "Background:color", "rerun.components.Color")); + return this; + } + + public Background WithColor(params global::Rerun.Net.Components.Color[] color) => WithColor(color.AsSpan()); + + /// Create an empty Background for partial updates. Use With*() to set fields. + public static Background UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static Background ClearFields() => new(); + + private Background() { } + + public IReadOnlyList AsBatches() + { + var batches = new List(2); + batches.Add(Kind); + if (Color != null) batches.Add(Color); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/ContainerBlueprint.g.cs b/src/Rerun.Net/Blueprint/Archetypes/ContainerBlueprint.g.cs new file mode 100644 index 0000000..7a1bc1e --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/ContainerBlueprint.g.cs @@ -0,0 +1,120 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// The description of a container. +/// +public sealed partial class ContainerBlueprint : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.ContainerBlueprint"; + + public ComponentBatch ContainerKind { get; private set; } + public ComponentBatch? DisplayName { get; private set; } + public ComponentBatch? Contents { get; private set; } + public ComponentBatch? ColShares { get; private set; } + public ComponentBatch? RowShares { get; private set; } + public ComponentBatch? ActiveTab { get; private set; } + public ComponentBatch? Visible { get; private set; } + public ComponentBatch? GridColumns { get; private set; } + + public ContainerBlueprint(ReadOnlySpan container_kind) + { + ContainerKind = ComponentBatch.FromLoggable(container_kind, + new ComponentDescriptor(ArchetypeName, "ContainerBlueprint:container_kind", "rerun.blueprint.components.ContainerKind")); + } + + public ContainerBlueprint(params global::Rerun.Net.Blueprint.Components.ContainerKind[] container_kind) : this(container_kind.AsSpan()) { } + + public ContainerBlueprint WithDisplayName(ReadOnlySpan display_name) + { + DisplayName = ComponentBatch.FromLoggable(display_name, + new ComponentDescriptor(ArchetypeName, "ContainerBlueprint:display_name", "rerun.components.Name")); + return this; + } + + public ContainerBlueprint WithDisplayName(params global::Rerun.Net.Components.Name[] display_name) => WithDisplayName(display_name.AsSpan()); + + public ContainerBlueprint WithContents(ReadOnlySpan contents) + { + Contents = ComponentBatch.FromLoggable(contents, + new ComponentDescriptor(ArchetypeName, "ContainerBlueprint:contents", "rerun.blueprint.components.IncludedContent")); + return this; + } + + public ContainerBlueprint WithContents(params global::Rerun.Net.Blueprint.Components.IncludedContent[] contents) => WithContents(contents.AsSpan()); + + public ContainerBlueprint WithColShares(ReadOnlySpan col_shares) + { + ColShares = ComponentBatch.FromLoggable(col_shares, + new ComponentDescriptor(ArchetypeName, "ContainerBlueprint:col_shares", "rerun.blueprint.components.ColumnShare")); + return this; + } + + public ContainerBlueprint WithColShares(params global::Rerun.Net.Blueprint.Components.ColumnShare[] col_shares) => WithColShares(col_shares.AsSpan()); + + public ContainerBlueprint WithRowShares(ReadOnlySpan row_shares) + { + RowShares = ComponentBatch.FromLoggable(row_shares, + new ComponentDescriptor(ArchetypeName, "ContainerBlueprint:row_shares", "rerun.blueprint.components.RowShare")); + return this; + } + + public ContainerBlueprint WithRowShares(params global::Rerun.Net.Blueprint.Components.RowShare[] row_shares) => WithRowShares(row_shares.AsSpan()); + + public ContainerBlueprint WithActiveTab(ReadOnlySpan active_tab) + { + ActiveTab = ComponentBatch.FromLoggable(active_tab, + new ComponentDescriptor(ArchetypeName, "ContainerBlueprint:active_tab", "rerun.blueprint.components.ActiveTab")); + return this; + } + + public ContainerBlueprint WithActiveTab(params global::Rerun.Net.Blueprint.Components.ActiveTab[] active_tab) => WithActiveTab(active_tab.AsSpan()); + + public ContainerBlueprint WithVisible(ReadOnlySpan visible) + { + Visible = ComponentBatch.FromLoggable(visible, + new ComponentDescriptor(ArchetypeName, "ContainerBlueprint:visible", "rerun.components.Visible")); + return this; + } + + public ContainerBlueprint WithVisible(params global::Rerun.Net.Components.Visible[] visible) => WithVisible(visible.AsSpan()); + + public ContainerBlueprint WithGridColumns(ReadOnlySpan grid_columns) + { + GridColumns = ComponentBatch.FromLoggable(grid_columns, + new ComponentDescriptor(ArchetypeName, "ContainerBlueprint:grid_columns", "rerun.blueprint.components.GridColumns")); + return this; + } + + public ContainerBlueprint WithGridColumns(params global::Rerun.Net.Blueprint.Components.GridColumns[] grid_columns) => WithGridColumns(grid_columns.AsSpan()); + + /// Create an empty ContainerBlueprint for partial updates. Use With*() to set fields. + public static ContainerBlueprint UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static ContainerBlueprint ClearFields() => new(); + + private ContainerBlueprint() { } + + public IReadOnlyList AsBatches() + { + var batches = new List(8); + batches.Add(ContainerKind); + if (DisplayName != null) batches.Add(DisplayName); + if (Contents != null) batches.Add(Contents); + if (ColShares != null) batches.Add(ColShares); + if (RowShares != null) batches.Add(RowShares); + if (ActiveTab != null) batches.Add(ActiveTab); + if (Visible != null) batches.Add(Visible); + if (GridColumns != null) batches.Add(GridColumns); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/DataframeQuery.g.cs b/src/Rerun.Net/Blueprint/Archetypes/DataframeQuery.g.cs new file mode 100644 index 0000000..2d3d9ab --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/DataframeQuery.g.cs @@ -0,0 +1,110 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// The query for the dataframe view. +/// +public sealed partial class DataframeQuery : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.DataframeQuery"; + + public ComponentBatch? Timeline { get; private set; } + public ComponentBatch? FilterByRange { get; private set; } + public ComponentBatch? FilterIsNotNull { get; private set; } + public ComponentBatch? ApplyLatestAt { get; private set; } + public ComponentBatch? Select { get; private set; } + public ComponentBatch? EntityOrder { get; private set; } + public ComponentBatch? AutoScroll { get; private set; } + + public DataframeQuery() { } + + public DataframeQuery WithTimeline(ReadOnlySpan timeline) + { + Timeline = ComponentBatch.FromLoggable(timeline, + new ComponentDescriptor(ArchetypeName, "DataframeQuery:timeline", "rerun.blueprint.components.TimelineName")); + return this; + } + + public DataframeQuery WithTimeline(params global::Rerun.Net.Blueprint.Components.TimelineName[] timeline) => WithTimeline(timeline.AsSpan()); + + public DataframeQuery WithFilterByRange(ReadOnlySpan filter_by_range) + { + FilterByRange = ComponentBatch.FromLoggable(filter_by_range, + new ComponentDescriptor(ArchetypeName, "DataframeQuery:filter_by_range", "rerun.blueprint.components.FilterByRange")); + return this; + } + + public DataframeQuery WithFilterByRange(params global::Rerun.Net.Blueprint.Components.FilterByRange[] filter_by_range) => WithFilterByRange(filter_by_range.AsSpan()); + + public DataframeQuery WithFilterIsNotNull(ReadOnlySpan filter_is_not_null) + { + FilterIsNotNull = ComponentBatch.FromLoggable(filter_is_not_null, + new ComponentDescriptor(ArchetypeName, "DataframeQuery:filter_is_not_null", "rerun.blueprint.components.FilterIsNotNull")); + return this; + } + + public DataframeQuery WithFilterIsNotNull(params global::Rerun.Net.Blueprint.Components.FilterIsNotNull[] filter_is_not_null) => WithFilterIsNotNull(filter_is_not_null.AsSpan()); + + public DataframeQuery WithApplyLatestAt(ReadOnlySpan apply_latest_at) + { + ApplyLatestAt = ComponentBatch.FromLoggable(apply_latest_at, + new ComponentDescriptor(ArchetypeName, "DataframeQuery:apply_latest_at", "rerun.blueprint.components.ApplyLatestAt")); + return this; + } + + public DataframeQuery WithApplyLatestAt(params global::Rerun.Net.Blueprint.Components.ApplyLatestAt[] apply_latest_at) => WithApplyLatestAt(apply_latest_at.AsSpan()); + + public DataframeQuery WithSelect(ReadOnlySpan select) + { + Select = ComponentBatch.FromLoggable(select, + new ComponentDescriptor(ArchetypeName, "DataframeQuery:select", "rerun.blueprint.components.SelectedColumns")); + return this; + } + + public DataframeQuery WithSelect(params global::Rerun.Net.Blueprint.Components.SelectedColumns[] select) => WithSelect(select.AsSpan()); + + public DataframeQuery WithEntityOrder(ReadOnlySpan entity_order) + { + EntityOrder = ComponentBatch.FromLoggable(entity_order, + new ComponentDescriptor(ArchetypeName, "DataframeQuery:entity_order", "rerun.blueprint.components.ColumnOrder")); + return this; + } + + public DataframeQuery WithEntityOrder(params global::Rerun.Net.Blueprint.Components.ColumnOrder[] entity_order) => WithEntityOrder(entity_order.AsSpan()); + + public DataframeQuery WithAutoScroll(ReadOnlySpan auto_scroll) + { + AutoScroll = ComponentBatch.FromLoggable(auto_scroll, + new ComponentDescriptor(ArchetypeName, "DataframeQuery:auto_scroll", "rerun.blueprint.components.AutoScroll")); + return this; + } + + public DataframeQuery WithAutoScroll(params global::Rerun.Net.Blueprint.Components.AutoScroll[] auto_scroll) => WithAutoScroll(auto_scroll.AsSpan()); + + /// Create an empty DataframeQuery for partial updates. Use With*() to set fields. + public static DataframeQuery UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static DataframeQuery ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(7); + if (Timeline != null) batches.Add(Timeline); + if (FilterByRange != null) batches.Add(FilterByRange); + if (FilterIsNotNull != null) batches.Add(FilterIsNotNull); + if (ApplyLatestAt != null) batches.Add(ApplyLatestAt); + if (Select != null) batches.Add(Select); + if (EntityOrder != null) batches.Add(EntityOrder); + if (AutoScroll != null) batches.Add(AutoScroll); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/EntityBehavior.g.cs b/src/Rerun.Net/Blueprint/Archetypes/EntityBehavior.g.cs new file mode 100644 index 0000000..d31f028 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/EntityBehavior.g.cs @@ -0,0 +1,58 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// General visualization behavior of an entity. +/// +/// TODO(#6541): Fields of this archetype currently only have an effect when logged in the blueprint store. +/// +/// +public sealed partial class EntityBehavior : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.EntityBehavior"; + + public ComponentBatch? Interactive { get; private set; } + public ComponentBatch? Visible { get; private set; } + + public EntityBehavior() { } + + public EntityBehavior WithInteractive(ReadOnlySpan interactive) + { + Interactive = ComponentBatch.FromLoggable(interactive, + new ComponentDescriptor(ArchetypeName, "EntityBehavior:interactive", "rerun.components.Interactive")); + return this; + } + + public EntityBehavior WithInteractive(params global::Rerun.Net.Components.Interactive[] interactive) => WithInteractive(interactive.AsSpan()); + + public EntityBehavior WithVisible(ReadOnlySpan visible) + { + Visible = ComponentBatch.FromLoggable(visible, + new ComponentDescriptor(ArchetypeName, "EntityBehavior:visible", "rerun.components.Visible")); + return this; + } + + public EntityBehavior WithVisible(params global::Rerun.Net.Components.Visible[] visible) => WithVisible(visible.AsSpan()); + + /// Create an empty EntityBehavior for partial updates. Use With*() to set fields. + public static EntityBehavior UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static EntityBehavior ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(2); + if (Interactive != null) batches.Add(Interactive); + if (Visible != null) batches.Add(Visible); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/EyeControls3D.g.cs b/src/Rerun.Net/Blueprint/Archetypes/EyeControls3D.g.cs new file mode 100644 index 0000000..b8afae4 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/EyeControls3D.g.cs @@ -0,0 +1,112 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// The controls for the 3D eye in a spatial 3D view. +/// +/// This configures the camera through which the 3D scene is viewed. +/// +public sealed partial class EyeControls3D : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.EyeControls3D"; + + public ComponentBatch? Kind { get; private set; } + public ComponentBatch? Position { get; private set; } + public ComponentBatch? LookTarget { get; private set; } + public ComponentBatch? EyeUp { get; private set; } + public ComponentBatch? Speed { get; private set; } + public ComponentBatch? TrackingEntity { get; private set; } + public ComponentBatch? SpinSpeed { get; private set; } + + public EyeControls3D() { } + + public EyeControls3D WithKind(ReadOnlySpan kind) + { + Kind = ComponentBatch.FromLoggable(kind, + new ComponentDescriptor(ArchetypeName, "EyeControls3D:kind", "rerun.blueprint.components.Eye3DKind")); + return this; + } + + public EyeControls3D WithKind(params global::Rerun.Net.Blueprint.Components.Eye3DKind[] kind) => WithKind(kind.AsSpan()); + + public EyeControls3D WithPosition(ReadOnlySpan position) + { + Position = ComponentBatch.FromLoggable(position, + new ComponentDescriptor(ArchetypeName, "EyeControls3D:position", "rerun.components.Position3D")); + return this; + } + + public EyeControls3D WithPosition(params global::Rerun.Net.Components.Position3D[] position) => WithPosition(position.AsSpan()); + + public EyeControls3D WithLookTarget(ReadOnlySpan look_target) + { + LookTarget = ComponentBatch.FromLoggable(look_target, + new ComponentDescriptor(ArchetypeName, "EyeControls3D:look_target", "rerun.components.Position3D")); + return this; + } + + public EyeControls3D WithLookTarget(params global::Rerun.Net.Components.Position3D[] look_target) => WithLookTarget(look_target.AsSpan()); + + public EyeControls3D WithEyeUp(ReadOnlySpan eye_up) + { + EyeUp = ComponentBatch.FromLoggable(eye_up, + new ComponentDescriptor(ArchetypeName, "EyeControls3D:eye_up", "rerun.components.Vector3D")); + return this; + } + + public EyeControls3D WithEyeUp(params global::Rerun.Net.Components.Vector3D[] eye_up) => WithEyeUp(eye_up.AsSpan()); + + public EyeControls3D WithSpeed(ReadOnlySpan speed) + { + Speed = ComponentBatch.FromLoggable(speed, + new ComponentDescriptor(ArchetypeName, "EyeControls3D:speed", "rerun.components.LinearSpeed")); + return this; + } + + public EyeControls3D WithSpeed(params global::Rerun.Net.Components.LinearSpeed[] speed) => WithSpeed(speed.AsSpan()); + + public EyeControls3D WithTrackingEntity(ReadOnlySpan tracking_entity) + { + TrackingEntity = ComponentBatch.FromLoggable(tracking_entity, + new ComponentDescriptor(ArchetypeName, "EyeControls3D:tracking_entity", "rerun.components.EntityPath")); + return this; + } + + public EyeControls3D WithTrackingEntity(params global::Rerun.Net.Components.EntityPath[] tracking_entity) => WithTrackingEntity(tracking_entity.AsSpan()); + + public EyeControls3D WithSpinSpeed(ReadOnlySpan spin_speed) + { + SpinSpeed = ComponentBatch.FromLoggable(spin_speed, + new ComponentDescriptor(ArchetypeName, "EyeControls3D:spin_speed", "rerun.blueprint.components.AngularSpeed")); + return this; + } + + public EyeControls3D WithSpinSpeed(params global::Rerun.Net.Blueprint.Components.AngularSpeed[] spin_speed) => WithSpinSpeed(spin_speed.AsSpan()); + + /// Create an empty EyeControls3D for partial updates. Use With*() to set fields. + public static EyeControls3D UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static EyeControls3D ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(7); + if (Kind != null) batches.Add(Kind); + if (Position != null) batches.Add(Position); + if (LookTarget != null) batches.Add(LookTarget); + if (EyeUp != null) batches.Add(EyeUp); + if (Speed != null) batches.Add(Speed); + if (TrackingEntity != null) batches.Add(TrackingEntity); + if (SpinSpeed != null) batches.Add(SpinSpeed); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/GraphBackground.g.cs b/src/Rerun.Net/Blueprint/Archetypes/GraphBackground.g.cs new file mode 100644 index 0000000..980024c --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/GraphBackground.g.cs @@ -0,0 +1,44 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration of a background in a graph view. +/// +public sealed partial class GraphBackground : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.GraphBackground"; + + public ComponentBatch? Color { get; private set; } + + public GraphBackground() { } + + public GraphBackground WithColor(ReadOnlySpan color) + { + Color = ComponentBatch.FromLoggable(color, + new ComponentDescriptor(ArchetypeName, "GraphBackground:color", "rerun.components.Color")); + return this; + } + + public GraphBackground WithColor(params global::Rerun.Net.Components.Color[] color) => WithColor(color.AsSpan()); + + /// Create an empty GraphBackground for partial updates. Use With*() to set fields. + public static GraphBackground UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static GraphBackground ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(1); + if (Color != null) batches.Add(Color); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/LineGrid3D.g.cs b/src/Rerun.Net/Blueprint/Archetypes/LineGrid3D.g.cs new file mode 100644 index 0000000..9fbdea1 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/LineGrid3D.g.cs @@ -0,0 +1,88 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration for the 3D line grid. +/// +public sealed partial class LineGrid3D : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.LineGrid3D"; + + public ComponentBatch? Visible { get; private set; } + public ComponentBatch? Spacing { get; private set; } + public ComponentBatch? Plane { get; private set; } + public ComponentBatch? StrokeWidth { get; private set; } + public ComponentBatch? Color { get; private set; } + + public LineGrid3D() { } + + public LineGrid3D WithVisible(ReadOnlySpan visible) + { + Visible = ComponentBatch.FromLoggable(visible, + new ComponentDescriptor(ArchetypeName, "LineGrid3D:visible", "rerun.components.Visible")); + return this; + } + + public LineGrid3D WithVisible(params global::Rerun.Net.Components.Visible[] visible) => WithVisible(visible.AsSpan()); + + public LineGrid3D WithSpacing(ReadOnlySpan spacing) + { + Spacing = ComponentBatch.FromLoggable(spacing, + new ComponentDescriptor(ArchetypeName, "LineGrid3D:spacing", "rerun.blueprint.components.GridSpacing")); + return this; + } + + public LineGrid3D WithSpacing(params global::Rerun.Net.Blueprint.Components.GridSpacing[] spacing) => WithSpacing(spacing.AsSpan()); + + public LineGrid3D WithPlane(ReadOnlySpan plane) + { + Plane = ComponentBatch.FromLoggable(plane, + new ComponentDescriptor(ArchetypeName, "LineGrid3D:plane", "rerun.components.Plane3D")); + return this; + } + + public LineGrid3D WithPlane(params global::Rerun.Net.Components.Plane3D[] plane) => WithPlane(plane.AsSpan()); + + public LineGrid3D WithStrokeWidth(ReadOnlySpan stroke_width) + { + StrokeWidth = ComponentBatch.FromLoggable(stroke_width, + new ComponentDescriptor(ArchetypeName, "LineGrid3D:stroke_width", "rerun.components.StrokeWidth")); + return this; + } + + public LineGrid3D WithStrokeWidth(params global::Rerun.Net.Components.StrokeWidth[] stroke_width) => WithStrokeWidth(stroke_width.AsSpan()); + + public LineGrid3D WithColor(ReadOnlySpan color) + { + Color = ComponentBatch.FromLoggable(color, + new ComponentDescriptor(ArchetypeName, "LineGrid3D:color", "rerun.components.Color")); + return this; + } + + public LineGrid3D WithColor(params global::Rerun.Net.Components.Color[] color) => WithColor(color.AsSpan()); + + /// Create an empty LineGrid3D for partial updates. Use With*() to set fields. + public static LineGrid3D UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static LineGrid3D ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(5); + if (Visible != null) batches.Add(Visible); + if (Spacing != null) batches.Add(Spacing); + if (Plane != null) batches.Add(Plane); + if (StrokeWidth != null) batches.Add(StrokeWidth); + if (Color != null) batches.Add(Color); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/MapBackground.g.cs b/src/Rerun.Net/Blueprint/Archetypes/MapBackground.g.cs index cbe63be..e5cc896 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/MapBackground.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/MapBackground.g.cs @@ -20,14 +20,14 @@ public sealed partial class MapBackground : IAsComponents public MapBackground() { } - public MapBackground WithProvider(ReadOnlySpan provider) + public MapBackground WithProvider(ReadOnlySpan provider) { Provider = ComponentBatch.FromLoggable(provider, new ComponentDescriptor(ArchetypeName, "MapBackground:provider", "rerun.blueprint.components.MapProvider")); return this; } - public MapBackground WithProvider(params Components.MapProvider[] provider) => WithProvider(provider.AsSpan()); + public MapBackground WithProvider(params global::Rerun.Net.Blueprint.Components.MapProvider[] provider) => WithProvider(provider.AsSpan()); /// Create an empty MapBackground for partial updates. Use With*() to set fields. public static MapBackground UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/MapZoom.g.cs b/src/Rerun.Net/Blueprint/Archetypes/MapZoom.g.cs index 3a16bd4..1e548da 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/MapZoom.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/MapZoom.g.cs @@ -17,14 +17,14 @@ public sealed partial class MapZoom : IAsComponents public MapZoom() { } - public MapZoom WithZoom(ReadOnlySpan zoom) + public MapZoom WithZoom(ReadOnlySpan zoom) { Zoom = ComponentBatch.FromLoggable(zoom, new ComponentDescriptor(ArchetypeName, "MapZoom:zoom", "rerun.blueprint.components.ZoomLevel")); return this; } - public MapZoom WithZoom(params Components.ZoomLevel[] zoom) => WithZoom(zoom.AsSpan()); + public MapZoom WithZoom(params global::Rerun.Net.Blueprint.Components.ZoomLevel[] zoom) => WithZoom(zoom.AsSpan()); /// Create an empty MapZoom for partial updates. Use With*() to set fields. public static MapZoom UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/NearClipPlane.g.cs b/src/Rerun.Net/Blueprint/Archetypes/NearClipPlane.g.cs index 2fb38a3..d4ec3c9 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/NearClipPlane.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/NearClipPlane.g.cs @@ -20,14 +20,14 @@ public sealed partial class NearClipPlane : IAsComponents public NearClipPlane() { } - public NearClipPlane WithNearClipPlaneValue(ReadOnlySpan near_clip_plane) + public NearClipPlane WithNearClipPlaneValue(ReadOnlySpan near_clip_plane) { NearClipPlaneValue = ComponentBatch.FromLoggable(near_clip_plane, new ComponentDescriptor(ArchetypeName, "NearClipPlane:near_clip_plane", "rerun.blueprint.components.NearClipPlane")); return this; } - public NearClipPlane WithNearClipPlaneValue(params Components.NearClipPlane[] near_clip_plane) => WithNearClipPlaneValue(near_clip_plane.AsSpan()); + public NearClipPlane WithNearClipPlaneValue(params global::Rerun.Net.Blueprint.Components.NearClipPlane[] near_clip_plane) => WithNearClipPlaneValue(near_clip_plane.AsSpan()); /// Create an empty NearClipPlane for partial updates. Use With*() to set fields. public static NearClipPlane UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/PanelBlueprint.g.cs b/src/Rerun.Net/Blueprint/Archetypes/PanelBlueprint.g.cs index 238a72d..3a08b21 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/PanelBlueprint.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/PanelBlueprint.g.cs @@ -20,14 +20,14 @@ public sealed partial class PanelBlueprint : IAsComponents public PanelBlueprint() { } - public PanelBlueprint WithState(ReadOnlySpan state) + public PanelBlueprint WithState(ReadOnlySpan state) { State = ComponentBatch.FromLoggable(state, new ComponentDescriptor(ArchetypeName, "PanelBlueprint:state", "rerun.blueprint.components.PanelState")); return this; } - public PanelBlueprint WithState(params Components.PanelState[] state) => WithState(state.AsSpan()); + public PanelBlueprint WithState(params global::Rerun.Net.Blueprint.Components.PanelState[] state) => WithState(state.AsSpan()); /// Create an empty PanelBlueprint for partial updates. Use With*() to set fields. public static PanelBlueprint UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/PlotBackground.g.cs b/src/Rerun.Net/Blueprint/Archetypes/PlotBackground.g.cs new file mode 100644 index 0000000..5ce4d36 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/PlotBackground.g.cs @@ -0,0 +1,55 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration of a background in a plot view. +/// +public sealed partial class PlotBackground : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.PlotBackground"; + + public ComponentBatch? Color { get; private set; } + public ComponentBatch? ShowGrid { get; private set; } + + public PlotBackground() { } + + public PlotBackground WithColor(ReadOnlySpan color) + { + Color = ComponentBatch.FromLoggable(color, + new ComponentDescriptor(ArchetypeName, "PlotBackground:color", "rerun.components.Color")); + return this; + } + + public PlotBackground WithColor(params global::Rerun.Net.Components.Color[] color) => WithColor(color.AsSpan()); + + public PlotBackground WithShowGrid(ReadOnlySpan show_grid) + { + ShowGrid = ComponentBatch.FromLoggable(show_grid, + new ComponentDescriptor(ArchetypeName, "PlotBackground:show_grid", "rerun.blueprint.components.Enabled")); + return this; + } + + public PlotBackground WithShowGrid(params global::Rerun.Net.Blueprint.Components.Enabled[] show_grid) => WithShowGrid(show_grid.AsSpan()); + + /// Create an empty PlotBackground for partial updates. Use With*() to set fields. + public static PlotBackground UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static PlotBackground ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(2); + if (Color != null) batches.Add(Color); + if (ShowGrid != null) batches.Add(ShowGrid); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/PlotLegend.g.cs b/src/Rerun.Net/Blueprint/Archetypes/PlotLegend.g.cs new file mode 100644 index 0000000..faf1807 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/PlotLegend.g.cs @@ -0,0 +1,55 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration for the legend of a plot. +/// +public sealed partial class PlotLegend : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.PlotLegend"; + + public ComponentBatch? Corner { get; private set; } + public ComponentBatch? Visible { get; private set; } + + public PlotLegend() { } + + public PlotLegend WithCorner(ReadOnlySpan corner) + { + Corner = ComponentBatch.FromLoggable(corner, + new ComponentDescriptor(ArchetypeName, "PlotLegend:corner", "rerun.blueprint.components.Corner2D")); + return this; + } + + public PlotLegend WithCorner(params global::Rerun.Net.Blueprint.Components.Corner2D[] corner) => WithCorner(corner.AsSpan()); + + public PlotLegend WithVisible(ReadOnlySpan visible) + { + Visible = ComponentBatch.FromLoggable(visible, + new ComponentDescriptor(ArchetypeName, "PlotLegend:visible", "rerun.components.Visible")); + return this; + } + + public PlotLegend WithVisible(params global::Rerun.Net.Components.Visible[] visible) => WithVisible(visible.AsSpan()); + + /// Create an empty PlotLegend for partial updates. Use With*() to set fields. + public static PlotLegend UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static PlotLegend ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(2); + if (Corner != null) batches.Add(Corner); + if (Visible != null) batches.Add(Visible); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/ScalarAxis.g.cs b/src/Rerun.Net/Blueprint/Archetypes/ScalarAxis.g.cs new file mode 100644 index 0000000..e9f9c88 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/ScalarAxis.g.cs @@ -0,0 +1,55 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration for the scalar (Y) axis of a plot. +/// +public sealed partial class ScalarAxis : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.ScalarAxis"; + + public ComponentBatch? Range { get; private set; } + public ComponentBatch? ZoomLock { get; private set; } + + public ScalarAxis() { } + + public ScalarAxis WithRange(ReadOnlySpan range) + { + Range = ComponentBatch.FromLoggable(range, + new ComponentDescriptor(ArchetypeName, "ScalarAxis:range", "rerun.components.Range1D")); + return this; + } + + public ScalarAxis WithRange(params global::Rerun.Net.Components.Range1D[] range) => WithRange(range.AsSpan()); + + public ScalarAxis WithZoomLock(ReadOnlySpan zoom_lock) + { + ZoomLock = ComponentBatch.FromLoggable(zoom_lock, + new ComponentDescriptor(ArchetypeName, "ScalarAxis:zoom_lock", "rerun.blueprint.components.LockRangeDuringZoom")); + return this; + } + + public ScalarAxis WithZoomLock(params global::Rerun.Net.Blueprint.Components.LockRangeDuringZoom[] zoom_lock) => WithZoomLock(zoom_lock.AsSpan()); + + /// Create an empty ScalarAxis for partial updates. Use With*() to set fields. + public static ScalarAxis UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static ScalarAxis ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(2); + if (Range != null) batches.Add(Range); + if (ZoomLock != null) batches.Add(ZoomLock); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/SpatialInformation.g.cs b/src/Rerun.Net/Blueprint/Archetypes/SpatialInformation.g.cs new file mode 100644 index 0000000..f0b13fb --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/SpatialInformation.g.cs @@ -0,0 +1,66 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// This configures extra drawing config for the 3D view. +/// +public sealed partial class SpatialInformation : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.SpatialInformation"; + + public ComponentBatch? TargetFrame { get; private set; } + public ComponentBatch? ShowAxes { get; private set; } + public ComponentBatch? ShowBoundingBox { get; private set; } + + public SpatialInformation() { } + + public SpatialInformation WithTargetFrame(ReadOnlySpan target_frame) + { + TargetFrame = ComponentBatch.FromLoggable(target_frame, + new ComponentDescriptor(ArchetypeName, "SpatialInformation:target_frame", "rerun.components.TransformFrameId")); + return this; + } + + public SpatialInformation WithTargetFrame(params global::Rerun.Net.Components.TransformFrameId[] target_frame) => WithTargetFrame(target_frame.AsSpan()); + + public SpatialInformation WithShowAxes(ReadOnlySpan show_axes) + { + ShowAxes = ComponentBatch.FromLoggable(show_axes, + new ComponentDescriptor(ArchetypeName, "SpatialInformation:show_axes", "rerun.blueprint.components.Enabled")); + return this; + } + + public SpatialInformation WithShowAxes(params global::Rerun.Net.Blueprint.Components.Enabled[] show_axes) => WithShowAxes(show_axes.AsSpan()); + + public SpatialInformation WithShowBoundingBox(ReadOnlySpan show_bounding_box) + { + ShowBoundingBox = ComponentBatch.FromLoggable(show_bounding_box, + new ComponentDescriptor(ArchetypeName, "SpatialInformation:show_bounding_box", "rerun.blueprint.components.Enabled")); + return this; + } + + public SpatialInformation WithShowBoundingBox(params global::Rerun.Net.Blueprint.Components.Enabled[] show_bounding_box) => WithShowBoundingBox(show_bounding_box.AsSpan()); + + /// Create an empty SpatialInformation for partial updates. Use With*() to set fields. + public static SpatialInformation UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static SpatialInformation ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(3); + if (TargetFrame != null) batches.Add(TargetFrame); + if (ShowAxes != null) batches.Add(ShowAxes); + if (ShowBoundingBox != null) batches.Add(ShowBoundingBox); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/TensorScalarMapping.g.cs b/src/Rerun.Net/Blueprint/Archetypes/TensorScalarMapping.g.cs new file mode 100644 index 0000000..5b84ed6 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/TensorScalarMapping.g.cs @@ -0,0 +1,66 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configures how tensor scalars are mapped to color. +/// +public sealed partial class TensorScalarMapping : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.TensorScalarMapping"; + + public ComponentBatch? MagFilter { get; private set; } + public ComponentBatch? Colormap { get; private set; } + public ComponentBatch? Gamma { get; private set; } + + public TensorScalarMapping() { } + + public TensorScalarMapping WithMagFilter(ReadOnlySpan mag_filter) + { + MagFilter = ComponentBatch.FromLoggable(mag_filter, + new ComponentDescriptor(ArchetypeName, "TensorScalarMapping:mag_filter", "rerun.components.MagnificationFilter")); + return this; + } + + public TensorScalarMapping WithMagFilter(params global::Rerun.Net.Components.MagnificationFilter[] mag_filter) => WithMagFilter(mag_filter.AsSpan()); + + public TensorScalarMapping WithColormap(ReadOnlySpan colormap) + { + Colormap = ComponentBatch.FromLoggable(colormap, + new ComponentDescriptor(ArchetypeName, "TensorScalarMapping:colormap", "rerun.components.Colormap")); + return this; + } + + public TensorScalarMapping WithColormap(params global::Rerun.Net.Components.Colormap[] colormap) => WithColormap(colormap.AsSpan()); + + public TensorScalarMapping WithGamma(ReadOnlySpan gamma) + { + Gamma = ComponentBatch.FromLoggable(gamma, + new ComponentDescriptor(ArchetypeName, "TensorScalarMapping:gamma", "rerun.components.GammaCorrection")); + return this; + } + + public TensorScalarMapping WithGamma(params global::Rerun.Net.Components.GammaCorrection[] gamma) => WithGamma(gamma.AsSpan()); + + /// Create an empty TensorScalarMapping for partial updates. Use With*() to set fields. + public static TensorScalarMapping UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static TensorScalarMapping ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(3); + if (MagFilter != null) batches.Add(MagFilter); + if (Colormap != null) batches.Add(Colormap); + if (Gamma != null) batches.Add(Gamma); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/TensorSliceSelection.g.cs b/src/Rerun.Net/Blueprint/Archetypes/TensorSliceSelection.g.cs new file mode 100644 index 0000000..8eea5dc --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/TensorSliceSelection.g.cs @@ -0,0 +1,77 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Specifies a 2D slice of a tensor. +/// +public sealed partial class TensorSliceSelection : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.TensorSliceSelection"; + + public ComponentBatch? Width { get; private set; } + public ComponentBatch? Height { get; private set; } + public ComponentBatch? Indices { get; private set; } + public ComponentBatch? Slider { get; private set; } + + public TensorSliceSelection() { } + + public TensorSliceSelection WithWidth(ReadOnlySpan width) + { + Width = ComponentBatch.FromLoggable(width, + new ComponentDescriptor(ArchetypeName, "TensorSliceSelection:width", "rerun.components.TensorWidthDimension")); + return this; + } + + public TensorSliceSelection WithWidth(params global::Rerun.Net.Components.TensorWidthDimension[] width) => WithWidth(width.AsSpan()); + + public TensorSliceSelection WithHeight(ReadOnlySpan height) + { + Height = ComponentBatch.FromLoggable(height, + new ComponentDescriptor(ArchetypeName, "TensorSliceSelection:height", "rerun.components.TensorHeightDimension")); + return this; + } + + public TensorSliceSelection WithHeight(params global::Rerun.Net.Components.TensorHeightDimension[] height) => WithHeight(height.AsSpan()); + + public TensorSliceSelection WithIndices(ReadOnlySpan indices) + { + Indices = ComponentBatch.FromLoggable(indices, + new ComponentDescriptor(ArchetypeName, "TensorSliceSelection:indices", "rerun.components.TensorDimensionIndexSelection")); + return this; + } + + public TensorSliceSelection WithIndices(params global::Rerun.Net.Components.TensorDimensionIndexSelection[] indices) => WithIndices(indices.AsSpan()); + + public TensorSliceSelection WithSlider(ReadOnlySpan slider) + { + Slider = ComponentBatch.FromLoggable(slider, + new ComponentDescriptor(ArchetypeName, "TensorSliceSelection:slider", "rerun.blueprint.components.TensorDimensionIndexSlider")); + return this; + } + + public TensorSliceSelection WithSlider(params global::Rerun.Net.Blueprint.Components.TensorDimensionIndexSlider[] slider) => WithSlider(slider.AsSpan()); + + /// Create an empty TensorSliceSelection for partial updates. Use With*() to set fields. + public static TensorSliceSelection UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static TensorSliceSelection ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(4); + if (Width != null) batches.Add(Width); + if (Height != null) batches.Add(Height); + if (Indices != null) batches.Add(Indices); + if (Slider != null) batches.Add(Slider); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/TensorViewFit.g.cs b/src/Rerun.Net/Blueprint/Archetypes/TensorViewFit.g.cs index 1d1dc6c..4bd30b0 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/TensorViewFit.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/TensorViewFit.g.cs @@ -20,14 +20,14 @@ public sealed partial class TensorViewFit : IAsComponents public TensorViewFit() { } - public TensorViewFit WithScaling(ReadOnlySpan scaling) + public TensorViewFit WithScaling(ReadOnlySpan scaling) { Scaling = ComponentBatch.FromLoggable(scaling, new ComponentDescriptor(ArchetypeName, "TensorViewFit:scaling", "rerun.blueprint.components.ViewFit")); return this; } - public TensorViewFit WithScaling(params Components.ViewFit[] scaling) => WithScaling(scaling.AsSpan()); + public TensorViewFit WithScaling(params global::Rerun.Net.Blueprint.Components.ViewFit[] scaling) => WithScaling(scaling.AsSpan()); /// Create an empty TensorViewFit for partial updates. Use With*() to set fields. public static TensorViewFit UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/TextLogColumns.g.cs b/src/Rerun.Net/Blueprint/Archetypes/TextLogColumns.g.cs new file mode 100644 index 0000000..729d9fd --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/TextLogColumns.g.cs @@ -0,0 +1,55 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration of the text log columns. +/// +public sealed partial class TextLogColumns : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.TextLogColumns"; + + public ComponentBatch? TimelineColumns { get; private set; } + public ComponentBatch? TextLogColumnsValue { get; private set; } + + public TextLogColumns() { } + + public TextLogColumns WithTimelineColumns(ReadOnlySpan timeline_columns) + { + TimelineColumns = ComponentBatch.FromLoggable(timeline_columns, + new ComponentDescriptor(ArchetypeName, "TextLogColumns:timeline_columns", "rerun.blueprint.components.TimelineColumn")); + return this; + } + + public TextLogColumns WithTimelineColumns(params global::Rerun.Net.Blueprint.Components.TimelineColumn[] timeline_columns) => WithTimelineColumns(timeline_columns.AsSpan()); + + public TextLogColumns WithTextLogColumnsValue(ReadOnlySpan text_log_columns) + { + TextLogColumnsValue = ComponentBatch.FromLoggable(text_log_columns, + new ComponentDescriptor(ArchetypeName, "TextLogColumns:text_log_columns", "rerun.blueprint.components.TextLogColumn")); + return this; + } + + public TextLogColumns WithTextLogColumnsValue(params global::Rerun.Net.Blueprint.Components.TextLogColumn[] text_log_columns) => WithTextLogColumnsValue(text_log_columns.AsSpan()); + + /// Create an empty TextLogColumns for partial updates. Use With*() to set fields. + public static TextLogColumns UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static TextLogColumns ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(2); + if (TimelineColumns != null) batches.Add(TimelineColumns); + if (TextLogColumnsValue != null) batches.Add(TextLogColumnsValue); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/TextLogFormat.g.cs b/src/Rerun.Net/Blueprint/Archetypes/TextLogFormat.g.cs index 2294adf..e10565a 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/TextLogFormat.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/TextLogFormat.g.cs @@ -20,14 +20,14 @@ public sealed partial class TextLogFormat : IAsComponents public TextLogFormat() { } - public TextLogFormat WithMonospaceBody(ReadOnlySpan monospace_body) + public TextLogFormat WithMonospaceBody(ReadOnlySpan monospace_body) { MonospaceBody = ComponentBatch.FromLoggable(monospace_body, new ComponentDescriptor(ArchetypeName, "TextLogFormat:monospace_body", "rerun.blueprint.components.Enabled")); return this; } - public TextLogFormat WithMonospaceBody(params Components.Enabled[] monospace_body) => WithMonospaceBody(monospace_body.AsSpan()); + public TextLogFormat WithMonospaceBody(params global::Rerun.Net.Blueprint.Components.Enabled[] monospace_body) => WithMonospaceBody(monospace_body.AsSpan()); /// Create an empty TextLogFormat for partial updates. Use With*() to set fields. public static TextLogFormat UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/TextLogRows.g.cs b/src/Rerun.Net/Blueprint/Archetypes/TextLogRows.g.cs new file mode 100644 index 0000000..ece0e0a --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/TextLogRows.g.cs @@ -0,0 +1,44 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration of the text log rows. +/// +public sealed partial class TextLogRows : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.TextLogRows"; + + public ComponentBatch? FilterByLogLevel { get; private set; } + + public TextLogRows() { } + + public TextLogRows WithFilterByLogLevel(ReadOnlySpan filter_by_log_level) + { + FilterByLogLevel = ComponentBatch.FromLoggable(filter_by_log_level, + new ComponentDescriptor(ArchetypeName, "TextLogRows:filter_by_log_level", "rerun.components.TextLogLevel")); + return this; + } + + public TextLogRows WithFilterByLogLevel(params global::Rerun.Net.Components.TextLogLevel[] filter_by_log_level) => WithFilterByLogLevel(filter_by_log_level.AsSpan()); + + /// Create an empty TextLogRows for partial updates. Use With*() to set fields. + public static TextLogRows UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static TextLogRows ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(1); + if (FilterByLogLevel != null) batches.Add(FilterByLogLevel); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/TimeAxis.g.cs b/src/Rerun.Net/Blueprint/Archetypes/TimeAxis.g.cs new file mode 100644 index 0000000..13127de --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/TimeAxis.g.cs @@ -0,0 +1,66 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configuration for the time (X) axis of a plot. +/// +public sealed partial class TimeAxis : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.TimeAxis"; + + public ComponentBatch? Link { get; private set; } + public ComponentBatch? ViewRange { get; private set; } + public ComponentBatch? ZoomLock { get; private set; } + + public TimeAxis() { } + + public TimeAxis WithLink(ReadOnlySpan link) + { + Link = ComponentBatch.FromLoggable(link, + new ComponentDescriptor(ArchetypeName, "TimeAxis:link", "rerun.blueprint.components.LinkAxis")); + return this; + } + + public TimeAxis WithLink(params global::Rerun.Net.Blueprint.Components.LinkAxis[] link) => WithLink(link.AsSpan()); + + public TimeAxis WithViewRange(ReadOnlySpan view_range) + { + ViewRange = ComponentBatch.FromLoggable(view_range, + new ComponentDescriptor(ArchetypeName, "TimeAxis:view_range", "rerun.blueprint.components.TimeRange")); + return this; + } + + public TimeAxis WithViewRange(params global::Rerun.Net.Blueprint.Components.TimeRange[] view_range) => WithViewRange(view_range.AsSpan()); + + public TimeAxis WithZoomLock(ReadOnlySpan zoom_lock) + { + ZoomLock = ComponentBatch.FromLoggable(zoom_lock, + new ComponentDescriptor(ArchetypeName, "TimeAxis:zoom_lock", "rerun.blueprint.components.LockRangeDuringZoom")); + return this; + } + + public TimeAxis WithZoomLock(params global::Rerun.Net.Blueprint.Components.LockRangeDuringZoom[] zoom_lock) => WithZoomLock(zoom_lock.AsSpan()); + + /// Create an empty TimeAxis for partial updates. Use With*() to set fields. + public static TimeAxis UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static TimeAxis ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(3); + if (Link != null) batches.Add(Link); + if (ViewRange != null) batches.Add(ViewRange); + if (ZoomLock != null) batches.Add(ZoomLock); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/TimePanelBlueprint.g.cs b/src/Rerun.Net/Blueprint/Archetypes/TimePanelBlueprint.g.cs new file mode 100644 index 0000000..1231c47 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/TimePanelBlueprint.g.cs @@ -0,0 +1,110 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Time panel specific state. +/// +public sealed partial class TimePanelBlueprint : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.TimePanelBlueprint"; + + public ComponentBatch? State { get; private set; } + public ComponentBatch? Timeline { get; private set; } + public ComponentBatch? PlaybackSpeed { get; private set; } + public ComponentBatch? Fps { get; private set; } + public ComponentBatch? PlayState { get; private set; } + public ComponentBatch? LoopMode { get; private set; } + public ComponentBatch? TimeSelection { get; private set; } + + public TimePanelBlueprint() { } + + public TimePanelBlueprint WithState(ReadOnlySpan state) + { + State = ComponentBatch.FromLoggable(state, + new ComponentDescriptor(ArchetypeName, "TimePanelBlueprint:state", "rerun.blueprint.components.PanelState")); + return this; + } + + public TimePanelBlueprint WithState(params global::Rerun.Net.Blueprint.Components.PanelState[] state) => WithState(state.AsSpan()); + + public TimePanelBlueprint WithTimeline(ReadOnlySpan timeline) + { + Timeline = ComponentBatch.FromLoggable(timeline, + new ComponentDescriptor(ArchetypeName, "TimePanelBlueprint:timeline", "rerun.blueprint.components.TimelineName")); + return this; + } + + public TimePanelBlueprint WithTimeline(params global::Rerun.Net.Blueprint.Components.TimelineName[] timeline) => WithTimeline(timeline.AsSpan()); + + public TimePanelBlueprint WithPlaybackSpeed(ReadOnlySpan playback_speed) + { + PlaybackSpeed = ComponentBatch.FromLoggable(playback_speed, + new ComponentDescriptor(ArchetypeName, "TimePanelBlueprint:playback_speed", "rerun.blueprint.components.PlaybackSpeed")); + return this; + } + + public TimePanelBlueprint WithPlaybackSpeed(params global::Rerun.Net.Blueprint.Components.PlaybackSpeed[] playback_speed) => WithPlaybackSpeed(playback_speed.AsSpan()); + + public TimePanelBlueprint WithFps(ReadOnlySpan fps) + { + Fps = ComponentBatch.FromLoggable(fps, + new ComponentDescriptor(ArchetypeName, "TimePanelBlueprint:fps", "rerun.blueprint.components.Fps")); + return this; + } + + public TimePanelBlueprint WithFps(params global::Rerun.Net.Blueprint.Components.Fps[] fps) => WithFps(fps.AsSpan()); + + public TimePanelBlueprint WithPlayState(ReadOnlySpan play_state) + { + PlayState = ComponentBatch.FromLoggable(play_state, + new ComponentDescriptor(ArchetypeName, "TimePanelBlueprint:play_state", "rerun.blueprint.components.PlayState")); + return this; + } + + public TimePanelBlueprint WithPlayState(params global::Rerun.Net.Blueprint.Components.PlayState[] play_state) => WithPlayState(play_state.AsSpan()); + + public TimePanelBlueprint WithLoopMode(ReadOnlySpan loop_mode) + { + LoopMode = ComponentBatch.FromLoggable(loop_mode, + new ComponentDescriptor(ArchetypeName, "TimePanelBlueprint:loop_mode", "rerun.blueprint.components.LoopMode")); + return this; + } + + public TimePanelBlueprint WithLoopMode(params global::Rerun.Net.Blueprint.Components.LoopMode[] loop_mode) => WithLoopMode(loop_mode.AsSpan()); + + public TimePanelBlueprint WithTimeSelection(ReadOnlySpan time_selection) + { + TimeSelection = ComponentBatch.FromLoggable(time_selection, + new ComponentDescriptor(ArchetypeName, "TimePanelBlueprint:time_selection", "rerun.blueprint.components.AbsoluteTimeRange")); + return this; + } + + public TimePanelBlueprint WithTimeSelection(params global::Rerun.Net.Blueprint.Components.AbsoluteTimeRange[] time_selection) => WithTimeSelection(time_selection.AsSpan()); + + /// Create an empty TimePanelBlueprint for partial updates. Use With*() to set fields. + public static TimePanelBlueprint UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static TimePanelBlueprint ClearFields() => new(); + + public IReadOnlyList AsBatches() + { + var batches = new List(7); + if (State != null) batches.Add(State); + if (Timeline != null) batches.Add(Timeline); + if (PlaybackSpeed != null) batches.Add(PlaybackSpeed); + if (Fps != null) batches.Add(Fps); + if (PlayState != null) batches.Add(PlayState); + if (LoopMode != null) batches.Add(LoopMode); + if (TimeSelection != null) batches.Add(TimeSelection); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/ViewBlueprint.g.cs b/src/Rerun.Net/Blueprint/Archetypes/ViewBlueprint.g.cs new file mode 100644 index 0000000..53e6782 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/ViewBlueprint.g.cs @@ -0,0 +1,76 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// The description of a single view. +/// +public sealed partial class ViewBlueprint : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.ViewBlueprint"; + + public ComponentBatch ClassIdentifier { get; private set; } + public ComponentBatch? DisplayName { get; private set; } + public ComponentBatch? SpaceOrigin { get; private set; } + public ComponentBatch? Visible { get; private set; } + + public ViewBlueprint(ReadOnlySpan class_identifier) + { + ClassIdentifier = ComponentBatch.FromLoggable(class_identifier, + new ComponentDescriptor(ArchetypeName, "ViewBlueprint:class_identifier", "rerun.blueprint.components.ViewClass")); + } + + public ViewBlueprint(params global::Rerun.Net.Blueprint.Components.ViewClass[] class_identifier) : this(class_identifier.AsSpan()) { } + + public ViewBlueprint WithDisplayName(ReadOnlySpan display_name) + { + DisplayName = ComponentBatch.FromLoggable(display_name, + new ComponentDescriptor(ArchetypeName, "ViewBlueprint:display_name", "rerun.components.Name")); + return this; + } + + public ViewBlueprint WithDisplayName(params global::Rerun.Net.Components.Name[] display_name) => WithDisplayName(display_name.AsSpan()); + + public ViewBlueprint WithSpaceOrigin(ReadOnlySpan space_origin) + { + SpaceOrigin = ComponentBatch.FromLoggable(space_origin, + new ComponentDescriptor(ArchetypeName, "ViewBlueprint:space_origin", "rerun.blueprint.components.ViewOrigin")); + return this; + } + + public ViewBlueprint WithSpaceOrigin(params global::Rerun.Net.Blueprint.Components.ViewOrigin[] space_origin) => WithSpaceOrigin(space_origin.AsSpan()); + + public ViewBlueprint WithVisible(ReadOnlySpan visible) + { + Visible = ComponentBatch.FromLoggable(visible, + new ComponentDescriptor(ArchetypeName, "ViewBlueprint:visible", "rerun.components.Visible")); + return this; + } + + public ViewBlueprint WithVisible(params global::Rerun.Net.Components.Visible[] visible) => WithVisible(visible.AsSpan()); + + /// Create an empty ViewBlueprint for partial updates. Use With*() to set fields. + public static ViewBlueprint UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static ViewBlueprint ClearFields() => new(); + + private ViewBlueprint() { } + + public IReadOnlyList AsBatches() + { + var batches = new List(4); + batches.Add(ClassIdentifier); + if (DisplayName != null) batches.Add(DisplayName); + if (SpaceOrigin != null) batches.Add(SpaceOrigin); + if (Visible != null) batches.Add(Visible); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/ViewContents.g.cs b/src/Rerun.Net/Blueprint/Archetypes/ViewContents.g.cs index 08ef655..0187a82 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/ViewContents.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/ViewContents.g.cs @@ -57,14 +57,14 @@ public sealed partial class ViewContents : IAsComponents public ViewContents() { } - public ViewContents WithQuery(ReadOnlySpan query) + public ViewContents WithQuery(ReadOnlySpan query) { Query = ComponentBatch.FromLoggable(query, new ComponentDescriptor(ArchetypeName, "ViewContents:query", "rerun.blueprint.components.QueryExpression")); return this; } - public ViewContents WithQuery(params Components.QueryExpression[] query) => WithQuery(query.AsSpan()); + public ViewContents WithQuery(params global::Rerun.Net.Blueprint.Components.QueryExpression[] query) => WithQuery(query.AsSpan()); /// Create an empty ViewContents for partial updates. Use With*() to set fields. public static ViewContents UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/ViewportBlueprint.g.cs b/src/Rerun.Net/Blueprint/Archetypes/ViewportBlueprint.g.cs index 65fe6dd..a401d80 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/ViewportBlueprint.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/ViewportBlueprint.g.cs @@ -24,50 +24,50 @@ public sealed partial class ViewportBlueprint : IAsComponents public ViewportBlueprint() { } - public ViewportBlueprint WithRootContainer(ReadOnlySpan root_container) + public ViewportBlueprint WithRootContainer(ReadOnlySpan root_container) { RootContainer = ComponentBatch.FromLoggable(root_container, new ComponentDescriptor(ArchetypeName, "ViewportBlueprint:root_container", "rerun.blueprint.components.RootContainer")); return this; } - public ViewportBlueprint WithRootContainer(params Components.RootContainer[] root_container) => WithRootContainer(root_container.AsSpan()); + public ViewportBlueprint WithRootContainer(params global::Rerun.Net.Blueprint.Components.RootContainer[] root_container) => WithRootContainer(root_container.AsSpan()); - public ViewportBlueprint WithMaximized(ReadOnlySpan maximized) + public ViewportBlueprint WithMaximized(ReadOnlySpan maximized) { Maximized = ComponentBatch.FromLoggable(maximized, new ComponentDescriptor(ArchetypeName, "ViewportBlueprint:maximized", "rerun.blueprint.components.ViewMaximized")); return this; } - public ViewportBlueprint WithMaximized(params Components.ViewMaximized[] maximized) => WithMaximized(maximized.AsSpan()); + public ViewportBlueprint WithMaximized(params global::Rerun.Net.Blueprint.Components.ViewMaximized[] maximized) => WithMaximized(maximized.AsSpan()); - public ViewportBlueprint WithAutoLayout(ReadOnlySpan auto_layout) + public ViewportBlueprint WithAutoLayout(ReadOnlySpan auto_layout) { AutoLayout = ComponentBatch.FromLoggable(auto_layout, new ComponentDescriptor(ArchetypeName, "ViewportBlueprint:auto_layout", "rerun.blueprint.components.AutoLayout")); return this; } - public ViewportBlueprint WithAutoLayout(params Components.AutoLayout[] auto_layout) => WithAutoLayout(auto_layout.AsSpan()); + public ViewportBlueprint WithAutoLayout(params global::Rerun.Net.Blueprint.Components.AutoLayout[] auto_layout) => WithAutoLayout(auto_layout.AsSpan()); - public ViewportBlueprint WithAutoViews(ReadOnlySpan auto_views) + public ViewportBlueprint WithAutoViews(ReadOnlySpan auto_views) { AutoViews = ComponentBatch.FromLoggable(auto_views, new ComponentDescriptor(ArchetypeName, "ViewportBlueprint:auto_views", "rerun.blueprint.components.AutoViews")); return this; } - public ViewportBlueprint WithAutoViews(params Components.AutoViews[] auto_views) => WithAutoViews(auto_views.AsSpan()); + public ViewportBlueprint WithAutoViews(params global::Rerun.Net.Blueprint.Components.AutoViews[] auto_views) => WithAutoViews(auto_views.AsSpan()); - public ViewportBlueprint WithPastViewerRecommendations(ReadOnlySpan past_viewer_recommendations) + public ViewportBlueprint WithPastViewerRecommendations(ReadOnlySpan past_viewer_recommendations) { PastViewerRecommendations = ComponentBatch.FromLoggable(past_viewer_recommendations, new ComponentDescriptor(ArchetypeName, "ViewportBlueprint:past_viewer_recommendations", "rerun.blueprint.components.ViewerRecommendationHash")); return this; } - public ViewportBlueprint WithPastViewerRecommendations(params Components.ViewerRecommendationHash[] past_viewer_recommendations) => WithPastViewerRecommendations(past_viewer_recommendations.AsSpan()); + public ViewportBlueprint WithPastViewerRecommendations(params global::Rerun.Net.Blueprint.Components.ViewerRecommendationHash[] past_viewer_recommendations) => WithPastViewerRecommendations(past_viewer_recommendations.AsSpan()); /// Create an empty ViewportBlueprint for partial updates. Use With*() to set fields. public static ViewportBlueprint UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/VisibleTimeRanges.g.cs b/src/Rerun.Net/Blueprint/Archetypes/VisibleTimeRanges.g.cs new file mode 100644 index 0000000..338de3b --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/VisibleTimeRanges.g.cs @@ -0,0 +1,51 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// Configures what range of each timeline is shown on a view. +/// +/// Whenever no visual time range applies, queries are done with "latest-at" semantics. +/// This means that the view will, starting from the time cursor position, +/// query the latest data available for each component type. +/// +/// The default visual time range depends on the type of view this property applies to: +/// - For time series views, the default is to show the entire timeline. +/// - For any other view, the default is to apply latest-at semantics. +/// +public sealed partial class VisibleTimeRanges : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.VisibleTimeRanges"; + + public ComponentBatch Ranges { get; private set; } + + public VisibleTimeRanges(ReadOnlySpan ranges) + { + Ranges = ComponentBatch.FromLoggable(ranges, + new ComponentDescriptor(ArchetypeName, "VisibleTimeRanges:ranges", "rerun.blueprint.components.VisibleTimeRange")); + } + + public VisibleTimeRanges(params global::Rerun.Net.Blueprint.Components.VisibleTimeRange[] ranges) : this(ranges.AsSpan()) { } + + /// Create an empty VisibleTimeRanges for partial updates. Use With*() to set fields. + public static VisibleTimeRanges UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static VisibleTimeRanges ClearFields() => new(); + + private VisibleTimeRanges() { } + + public IReadOnlyList AsBatches() + { + var batches = new List(1); + batches.Add(Ranges); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Archetypes/VisualBounds2D.g.cs b/src/Rerun.Net/Blueprint/Archetypes/VisualBounds2D.g.cs index 72b9ef9..4efa13a 100644 --- a/src/Rerun.Net/Blueprint/Archetypes/VisualBounds2D.g.cs +++ b/src/Rerun.Net/Blueprint/Archetypes/VisualBounds2D.g.cs @@ -24,13 +24,13 @@ public sealed partial class VisualBounds2D : IAsComponents public ComponentBatch Range { get; private set; } - public VisualBounds2D(ReadOnlySpan range) + public VisualBounds2D(ReadOnlySpan range) { Range = ComponentBatch.FromLoggable(range, new ComponentDescriptor(ArchetypeName, "VisualBounds2D:range", "rerun.blueprint.components.VisualBounds2D")); } - public VisualBounds2D(params Components.VisualBounds2D[] range) : this(range.AsSpan()) { } + public VisualBounds2D(params global::Rerun.Net.Blueprint.Components.VisualBounds2D[] range) : this(range.AsSpan()) { } /// Create an empty VisualBounds2D for partial updates. Use With*() to set fields. public static VisualBounds2D UpdateFields() => new(); diff --git a/src/Rerun.Net/Blueprint/Archetypes/VisualizerInstruction.g.cs b/src/Rerun.Net/Blueprint/Archetypes/VisualizerInstruction.g.cs new file mode 100644 index 0000000..a360f15 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Archetypes/VisualizerInstruction.g.cs @@ -0,0 +1,54 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Rerun.Net.Components; + +using Rerun.Net.Components; +using Rerun.Net.Blueprint.Components; + +namespace Rerun.Net.Blueprint.Archetypes; + +/// +/// A visualizer instruction for an entity. +/// +public sealed partial class VisualizerInstruction : IAsComponents +{ + private const string ArchetypeName = "rerun.blueprint.archetypes.VisualizerInstruction"; + + public ComponentBatch VisualizerType { get; private set; } + public ComponentBatch? ComponentMap { get; private set; } + + public VisualizerInstruction(ReadOnlySpan visualizer_type) + { + VisualizerType = ComponentBatch.FromLoggable(visualizer_type, + new ComponentDescriptor(ArchetypeName, "VisualizerInstruction:visualizer_type", "rerun.blueprint.components.VisualizerType")); + } + + public VisualizerInstruction(params global::Rerun.Net.Blueprint.Components.VisualizerType[] visualizer_type) : this(visualizer_type.AsSpan()) { } + + public VisualizerInstruction WithComponentMap(ReadOnlySpan component_map) + { + ComponentMap = ComponentBatch.FromLoggable(component_map, + new ComponentDescriptor(ArchetypeName, "VisualizerInstruction:component_map", "rerun.blueprint.components.VisualizerComponentMapping")); + return this; + } + + public VisualizerInstruction WithComponentMap(params global::Rerun.Net.Blueprint.Components.VisualizerComponentMapping[] component_map) => WithComponentMap(component_map.AsSpan()); + + /// Create an empty VisualizerInstruction for partial updates. Use With*() to set fields. + public static VisualizerInstruction UpdateFields() => new(); + + /// Clear all fields, then use With*() to set specific ones. + public static VisualizerInstruction ClearFields() => new(); + + private VisualizerInstruction() { } + + public IReadOnlyList AsBatches() + { + var batches = new List(2); + batches.Add(VisualizerType); + if (ComponentMap != null) batches.Add(ComponentMap); + return batches; + } +} diff --git a/src/Rerun.Net/Blueprint/Components/AbsoluteTimeRange.g.cs b/src/Rerun.Net/Blueprint/Components/AbsoluteTimeRange.g.cs new file mode 100644 index 0000000..5a65c9a --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/AbsoluteTimeRange.g.cs @@ -0,0 +1,27 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// A reference to a range of time. +/// +public readonly record struct AbsoluteTimeRange(global::Rerun.Net.Datatypes.AbsoluteTimeRange Range) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.AbsoluteTimeRange"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Datatypes.AbsoluteTimeRange[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].Range; + return global::Rerun.Net.Datatypes.AbsoluteTimeRange.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/ActiveTab.g.cs b/src/Rerun.Net/Blueprint/Components/ActiveTab.g.cs new file mode 100644 index 0000000..9c47339 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/ActiveTab.g.cs @@ -0,0 +1,27 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// The active tab in a tabbed container. +/// +public readonly record struct ActiveTab(global::Rerun.Net.Datatypes.EntityPath Tab) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.ActiveTab"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Datatypes.EntityPath[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].Tab; + return global::Rerun.Net.Datatypes.EntityPath.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/ColumnOrder.g.cs b/src/Rerun.Net/Blueprint/Components/ColumnOrder.g.cs new file mode 100644 index 0000000..6b2d292 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/ColumnOrder.g.cs @@ -0,0 +1,44 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// The order of component columns (which remain always grouped by entity path) in the dataframe view. +/// +/// Entities not in this list are appended at the end in their default order. +/// Entities in this list that are not present in the view are ignored. +/// +public readonly record struct ColumnOrder(global::Rerun.Net.Datatypes.EntityPath[] EntityPaths) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.ColumnOrder"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + // Flatten all inner arrays and build offsets for ListArray + var allItems = new System.Collections.Generic.List(); + var offsets = new Int32Array.Builder(); + offsets.Append(0); + foreach (var v in data) + { + foreach (var item in v.EntityPaths) + allItems.Add(item); + offsets.Append(allItems.Count); + } + var valuesArray = global::Rerun.Net.Datatypes.EntityPath.ToArrow(allItems.ToArray()); + var offsetsArray = offsets.Build(); + var listType = new Apache.Arrow.Types.ListType( + new Apache.Arrow.Field("item", valuesArray.Data.DataType, false)); + var listData = new ArrayData(listType, data.Length, 0, 0, + new[] { ArrowBuffer.Empty, offsetsArray.ValueBuffer }, + new[] { valuesArray.Data }); + return new ListArray(listData); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/ComponentColumnSelector.g.cs b/src/Rerun.Net/Blueprint/Components/ComponentColumnSelector.g.cs index 9cb631b..7b4f47e 100644 --- a/src/Rerun.Net/Blueprint/Components/ComponentColumnSelector.g.cs +++ b/src/Rerun.Net/Blueprint/Components/ComponentColumnSelector.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Blueprint.Components; -public readonly record struct ComponentColumnSelector(Datatypes.ComponentColumnSelector Selector) : ILoggable +public readonly record struct ComponentColumnSelector(global::Rerun.Net.Blueprint.Datatypes.ComponentColumnSelector Selector) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.ComponentColumnSelector"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Datatypes.ComponentColumnSelector[data.Length]; + var inner = new global::Rerun.Net.Blueprint.Datatypes.ComponentColumnSelector[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Selector; - return Datatypes.ComponentColumnSelector.ToArrow(inner); + return global::Rerun.Net.Blueprint.Datatypes.ComponentColumnSelector.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/FilterByRange.g.cs b/src/Rerun.Net/Blueprint/Components/FilterByRange.g.cs index 0a9e459..a091334 100644 --- a/src/Rerun.Net/Blueprint/Components/FilterByRange.g.cs +++ b/src/Rerun.Net/Blueprint/Components/FilterByRange.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Blueprint.Components; -public readonly record struct FilterByRange(Datatypes.FilterByRange Range) : ILoggable +public readonly record struct FilterByRange(global::Rerun.Net.Blueprint.Datatypes.FilterByRange Range) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.FilterByRange"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Datatypes.FilterByRange[data.Length]; + var inner = new global::Rerun.Net.Blueprint.Datatypes.FilterByRange[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Range; - return Datatypes.FilterByRange.ToArrow(inner); + return global::Rerun.Net.Blueprint.Datatypes.FilterByRange.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/FilterIsNotNull.g.cs b/src/Rerun.Net/Blueprint/Components/FilterIsNotNull.g.cs index aa41cd3..ab06649 100644 --- a/src/Rerun.Net/Blueprint/Components/FilterIsNotNull.g.cs +++ b/src/Rerun.Net/Blueprint/Components/FilterIsNotNull.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// Configuration for the filter is not null feature of the dataframe view. /// -public readonly record struct FilterIsNotNull(Datatypes.FilterIsNotNull FilterIsNotNullValue) : ILoggable +public readonly record struct FilterIsNotNull(global::Rerun.Net.Blueprint.Datatypes.FilterIsNotNull FilterIsNotNullValue) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.FilterIsNotNull"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Datatypes.FilterIsNotNull[data.Length]; + var inner = new global::Rerun.Net.Blueprint.Datatypes.FilterIsNotNull[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].FilterIsNotNullValue; - return Datatypes.FilterIsNotNull.ToArrow(inner); + return global::Rerun.Net.Blueprint.Datatypes.FilterIsNotNull.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/IncludedContent.g.cs b/src/Rerun.Net/Blueprint/Components/IncludedContent.g.cs new file mode 100644 index 0000000..043d1b9 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/IncludedContent.g.cs @@ -0,0 +1,27 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// All the contents in the container. +/// +public readonly record struct IncludedContent(global::Rerun.Net.Datatypes.EntityPath Contents) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.IncludedContent"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Datatypes.EntityPath[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].Contents; + return global::Rerun.Net.Datatypes.EntityPath.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/QueryExpression.g.cs b/src/Rerun.Net/Blueprint/Components/QueryExpression.g.cs index 32dca99..be2830e 100644 --- a/src/Rerun.Net/Blueprint/Components/QueryExpression.g.cs +++ b/src/Rerun.Net/Blueprint/Components/QueryExpression.g.cs @@ -22,15 +22,15 @@ namespace Rerun.Net.Blueprint.Components; /// (`/world/**` matches both `/world` and `/world/car/driver`). /// Other uses of `*` are not (yet) supported. /// -public readonly record struct QueryExpression(Utf8 Filter) : ILoggable +public readonly record struct QueryExpression(global::Rerun.Net.Datatypes.Utf8 Filter) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.QueryExpression"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new global::Rerun.Net.Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Filter; - return Utf8.ToArrow(inner); + return global::Rerun.Net.Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/RootContainer.g.cs b/src/Rerun.Net/Blueprint/Components/RootContainer.g.cs index fcd4cc3..b24d5e8 100644 --- a/src/Rerun.Net/Blueprint/Components/RootContainer.g.cs +++ b/src/Rerun.Net/Blueprint/Components/RootContainer.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// The container that sits at the root of a viewport. /// -public readonly record struct RootContainer(Uuid Id) : ILoggable +public readonly record struct RootContainer(global::Rerun.Net.Datatypes.Uuid Id) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.RootContainer"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Uuid[data.Length]; + var inner = new global::Rerun.Net.Datatypes.Uuid[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Id; - return Uuid.ToArrow(inner); + return global::Rerun.Net.Datatypes.Uuid.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/SelectedColumns.g.cs b/src/Rerun.Net/Blueprint/Components/SelectedColumns.g.cs index 2f6aa52..dcc8625 100644 --- a/src/Rerun.Net/Blueprint/Components/SelectedColumns.g.cs +++ b/src/Rerun.Net/Blueprint/Components/SelectedColumns.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Blueprint.Components; -public readonly record struct SelectedColumns(Datatypes.SelectedColumns SelectedColumnsValue) : ILoggable +public readonly record struct SelectedColumns(global::Rerun.Net.Blueprint.Datatypes.SelectedColumns SelectedColumnsValue) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.SelectedColumns"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Datatypes.SelectedColumns[data.Length]; + var inner = new global::Rerun.Net.Blueprint.Datatypes.SelectedColumns[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].SelectedColumnsValue; - return Datatypes.SelectedColumns.ToArrow(inner); + return global::Rerun.Net.Blueprint.Datatypes.SelectedColumns.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/TensorDimensionIndexSlider.g.cs b/src/Rerun.Net/Blueprint/Components/TensorDimensionIndexSlider.g.cs index 822c08e..fde1667 100644 --- a/src/Rerun.Net/Blueprint/Components/TensorDimensionIndexSlider.g.cs +++ b/src/Rerun.Net/Blueprint/Components/TensorDimensionIndexSlider.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// Show a slider for the index of some dimension of a slider. /// -public readonly record struct TensorDimensionIndexSlider(Datatypes.TensorDimensionIndexSlider Selection) : ILoggable +public readonly record struct TensorDimensionIndexSlider(global::Rerun.Net.Blueprint.Datatypes.TensorDimensionIndexSlider Selection) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.TensorDimensionIndexSlider"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Datatypes.TensorDimensionIndexSlider[data.Length]; + var inner = new global::Rerun.Net.Blueprint.Datatypes.TensorDimensionIndexSlider[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Selection; - return Datatypes.TensorDimensionIndexSlider.ToArrow(inner); + return global::Rerun.Net.Blueprint.Datatypes.TensorDimensionIndexSlider.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/TextLogColumn.g.cs b/src/Rerun.Net/Blueprint/Components/TextLogColumn.g.cs new file mode 100644 index 0000000..139d7af --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/TextLogColumn.g.cs @@ -0,0 +1,27 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// A text log column +/// +public readonly record struct TextLogColumn(global::Rerun.Net.Blueprint.Datatypes.TextLogColumn TextLogColumnValue) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.TextLogColumn"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Blueprint.Datatypes.TextLogColumn[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].TextLogColumnValue; + return global::Rerun.Net.Blueprint.Datatypes.TextLogColumn.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/TimeInt.g.cs b/src/Rerun.Net/Blueprint/Components/TimeInt.g.cs new file mode 100644 index 0000000..fad1a81 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/TimeInt.g.cs @@ -0,0 +1,27 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// A reference to a time. +/// +public readonly record struct TimeInt(global::Rerun.Net.Datatypes.TimeInt Time) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.TimeInt"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Datatypes.TimeInt[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].Time; + return global::Rerun.Net.Datatypes.TimeInt.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/TimeRange.g.cs b/src/Rerun.Net/Blueprint/Components/TimeRange.g.cs new file mode 100644 index 0000000..4d3cd5d --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/TimeRange.g.cs @@ -0,0 +1,27 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// A time range on an unspecified timeline using either relative or absolute boundaries. +/// +public readonly record struct TimeRange(global::Rerun.Net.Datatypes.TimeRange TimeRangeValue) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.TimeRange"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Datatypes.TimeRange[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].TimeRangeValue; + return global::Rerun.Net.Datatypes.TimeRange.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/TimelineColumn.g.cs b/src/Rerun.Net/Blueprint/Components/TimelineColumn.g.cs index daefa02..594b3c4 100644 --- a/src/Rerun.Net/Blueprint/Components/TimelineColumn.g.cs +++ b/src/Rerun.Net/Blueprint/Components/TimelineColumn.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// A timeline column in a text log table. /// -public readonly record struct TimelineColumn(Datatypes.TimelineColumn TimelineColumnValue) : ILoggable +public readonly record struct TimelineColumn(global::Rerun.Net.Blueprint.Datatypes.TimelineColumn TimelineColumnValue) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.TimelineColumn"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Datatypes.TimelineColumn[data.Length]; + var inner = new global::Rerun.Net.Blueprint.Datatypes.TimelineColumn[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].TimelineColumnValue; - return Datatypes.TimelineColumn.ToArrow(inner); + return global::Rerun.Net.Blueprint.Datatypes.TimelineColumn.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/TimelineName.g.cs b/src/Rerun.Net/Blueprint/Components/TimelineName.g.cs index 7ca65fb..f3e47b3 100644 --- a/src/Rerun.Net/Blueprint/Components/TimelineName.g.cs +++ b/src/Rerun.Net/Blueprint/Components/TimelineName.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// A timeline identified by its name. /// -public readonly record struct TimelineName(Utf8 Value) : ILoggable +public readonly record struct TimelineName(global::Rerun.Net.Datatypes.Utf8 Value) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.TimelineName"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new global::Rerun.Net.Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Value; - return Utf8.ToArrow(inner); + return global::Rerun.Net.Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/ViewClass.g.cs b/src/Rerun.Net/Blueprint/Components/ViewClass.g.cs index 2139637..383d947 100644 --- a/src/Rerun.Net/Blueprint/Components/ViewClass.g.cs +++ b/src/Rerun.Net/Blueprint/Components/ViewClass.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// The class identifier of view, e.g. `"2D"`, `"TextLog"`, …. /// -public readonly record struct ViewClass(Utf8 Value) : ILoggable +public readonly record struct ViewClass(global::Rerun.Net.Datatypes.Utf8 Value) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.ViewClass"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new global::Rerun.Net.Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Value; - return Utf8.ToArrow(inner); + return global::Rerun.Net.Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/ViewMaximized.g.cs b/src/Rerun.Net/Blueprint/Components/ViewMaximized.g.cs index 38d24ea..2cedc5f 100644 --- a/src/Rerun.Net/Blueprint/Components/ViewMaximized.g.cs +++ b/src/Rerun.Net/Blueprint/Components/ViewMaximized.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// Whether a view is maximized. /// -public readonly record struct ViewMaximized(Uuid ViewId) : ILoggable +public readonly record struct ViewMaximized(global::Rerun.Net.Datatypes.Uuid ViewId) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.ViewMaximized"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Uuid[data.Length]; + var inner = new global::Rerun.Net.Datatypes.Uuid[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].ViewId; - return Uuid.ToArrow(inner); + return global::Rerun.Net.Datatypes.Uuid.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/ViewOrigin.g.cs b/src/Rerun.Net/Blueprint/Components/ViewOrigin.g.cs new file mode 100644 index 0000000..c0c0c95 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/ViewOrigin.g.cs @@ -0,0 +1,27 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// The origin of a view. +/// +public readonly record struct ViewOrigin(global::Rerun.Net.Datatypes.EntityPath Value) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.ViewOrigin"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Datatypes.EntityPath[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].Value; + return global::Rerun.Net.Datatypes.EntityPath.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/VisibleTimeRange.g.cs b/src/Rerun.Net/Blueprint/Components/VisibleTimeRange.g.cs new file mode 100644 index 0000000..12dc595 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/VisibleTimeRange.g.cs @@ -0,0 +1,29 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// The range of values on a given timeline that will be included in a view's query. +/// +/// Refer to `VisibleTimeRanges` archetype for more information. +/// +public readonly record struct VisibleTimeRange(global::Rerun.Net.Datatypes.VisibleTimeRange Value) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.VisibleTimeRange"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Datatypes.VisibleTimeRange[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].Value; + return global::Rerun.Net.Datatypes.VisibleTimeRange.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/VisualBounds2D.g.cs b/src/Rerun.Net/Blueprint/Components/VisualBounds2D.g.cs index a8f66ad..8098b6a 100644 --- a/src/Rerun.Net/Blueprint/Components/VisualBounds2D.g.cs +++ b/src/Rerun.Net/Blueprint/Components/VisualBounds2D.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// Visual bounds in 2D space used for `Spatial2DView`. /// -public readonly record struct VisualBounds2D(Range2D Range2d) : ILoggable +public readonly record struct VisualBounds2D(global::Rerun.Net.Datatypes.Range2D Range2d) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.VisualBounds2D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Range2D[data.Length]; + var inner = new global::Rerun.Net.Datatypes.Range2D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Range2d; - return Range2D.ToArrow(inner); + return global::Rerun.Net.Datatypes.Range2D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/VisualizerComponentMapping.g.cs b/src/Rerun.Net/Blueprint/Components/VisualizerComponentMapping.g.cs new file mode 100644 index 0000000..6a61db1 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Components/VisualizerComponentMapping.g.cs @@ -0,0 +1,27 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Rerun.Net.Datatypes; + +using Rerun.Net.Datatypes; +using Rerun.Net.Components; + +namespace Rerun.Net.Blueprint.Components; + +/// +/// Associates components of an entity to components of a visualizer. +/// +public readonly record struct VisualizerComponentMapping(global::Rerun.Net.Blueprint.Datatypes.VisualizerComponentMapping Mapping) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.VisualizerComponentMapping"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var inner = new global::Rerun.Net.Blueprint.Datatypes.VisualizerComponentMapping[data.Length]; + for (var i = 0; i < data.Length; i++) + inner[i] = data[i].Mapping; + return global::Rerun.Net.Blueprint.Datatypes.VisualizerComponentMapping.ToArrow(inner); + } +} diff --git a/src/Rerun.Net/Blueprint/Components/VisualizerInstructionId.g.cs b/src/Rerun.Net/Blueprint/Components/VisualizerInstructionId.g.cs index 2dceda6..493696c 100644 --- a/src/Rerun.Net/Blueprint/Components/VisualizerInstructionId.g.cs +++ b/src/Rerun.Net/Blueprint/Components/VisualizerInstructionId.g.cs @@ -16,15 +16,15 @@ namespace Rerun.Net.Blueprint.Components; /// IDs are only guaranteed to be unique in the scope of a view. /// For details see [archetypes.ActiveVisualizers]. /// -public readonly record struct VisualizerInstructionId(Uuid Visualizer) : ILoggable +public readonly record struct VisualizerInstructionId(global::Rerun.Net.Datatypes.Uuid Visualizer) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.VisualizerInstructionId"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Uuid[data.Length]; + var inner = new global::Rerun.Net.Datatypes.Uuid[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Visualizer; - return Uuid.ToArrow(inner); + return global::Rerun.Net.Datatypes.Uuid.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Components/VisualizerType.g.cs b/src/Rerun.Net/Blueprint/Components/VisualizerType.g.cs index 19fb543..09e65d9 100644 --- a/src/Rerun.Net/Blueprint/Components/VisualizerType.g.cs +++ b/src/Rerun.Net/Blueprint/Components/VisualizerType.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Blueprint.Components; /// /// The type of the visualizer. /// -public readonly record struct VisualizerType(Utf8 VisualizerTypeValue) : ILoggable +public readonly record struct VisualizerType(global::Rerun.Net.Datatypes.Utf8 VisualizerTypeValue) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.components.VisualizerType"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new global::Rerun.Net.Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].VisualizerTypeValue; - return Utf8.ToArrow(inner); + return global::Rerun.Net.Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Blueprint/Datatypes/TextLogColumn.g.cs b/src/Rerun.Net/Blueprint/Datatypes/TextLogColumn.g.cs new file mode 100644 index 0000000..dbf7298 --- /dev/null +++ b/src/Rerun.Net/Blueprint/Datatypes/TextLogColumn.g.cs @@ -0,0 +1,35 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Apache.Arrow.Types; +using System.Linq; + +using Rerun.Net.Datatypes; + +namespace Rerun.Net.Blueprint.Datatypes; + +/// +/// A text log column. +/// +public readonly partial record struct TextLogColumn(bool Visible, TextLogColumnKind Kind) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.datatypes.TextLogColumn"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var visibleBuilder = new BooleanArray.Builder(); + foreach (var v in data) visibleBuilder.Append(v.Visible); + var visibleArray = (IArrowArray)visibleBuilder.Build(); + var kindBuilder = new UInt8Array.Builder(); + foreach (var v in data) kindBuilder.Append((byte)v.Kind); + var kindArray = (IArrowArray)kindBuilder.Build(); + var fields = new Apache.Arrow.Field[] { + new("visible", visibleArray.Data.DataType, false), + new("kind", kindArray.Data.DataType, false), + }; + var structType = new Apache.Arrow.Types.StructType(fields); + return new StructArray(structType, data.Length, new IArrowArray[] { visibleArray, kindArray }, ArrowBuffer.Empty); + } +} diff --git a/src/Rerun.Net/Blueprint/Datatypes/VisualizerComponentMapping.g.cs b/src/Rerun.Net/Blueprint/Datatypes/VisualizerComponentMapping.g.cs new file mode 100644 index 0000000..625549c --- /dev/null +++ b/src/Rerun.Net/Blueprint/Datatypes/VisualizerComponentMapping.g.cs @@ -0,0 +1,43 @@ +// +// DO NOT EDIT — generated by Rerun.Net.CodeGen +#pragma warning disable CS0542 // member names shall not match enclosing type + +using Apache.Arrow; +using Apache.Arrow.Types; +using System.Linq; + +using Rerun.Net.Datatypes; + +namespace Rerun.Net.Blueprint.Datatypes; + +/// +/// Associate components of an entity to components of a visualizer. +/// +public readonly partial record struct VisualizerComponentMapping(Utf8 Target, ComponentSourceKind SourceKind, string SourceComponent, string Selector) : ILoggable +{ + public static ComponentDescriptor Descriptor => new(null, null, "rerun.blueprint.datatypes.VisualizerComponentMapping"); + + public static IArrowArray ToArrow(ReadOnlySpan data) + { + var targetTmp = new Utf8[data.Length]; + for (var i = 0; i < data.Length; i++) targetTmp[i] = data[i].Target; + var targetArray = Utf8.ToArrow(targetTmp); + var source_kindBuilder = new UInt8Array.Builder(); + foreach (var v in data) source_kindBuilder.Append((byte)v.SourceKind); + var source_kindArray = (IArrowArray)source_kindBuilder.Build(); + var source_componentBuilder = new StringArray.Builder(); + foreach (var v in data) source_componentBuilder.Append(v.SourceComponent); + var source_componentArray = (IArrowArray)source_componentBuilder.Build(); + var selectorBuilder = new StringArray.Builder(); + foreach (var v in data) selectorBuilder.Append(v.Selector); + var selectorArray = (IArrowArray)selectorBuilder.Build(); + var fields = new Apache.Arrow.Field[] { + new("target", targetArray.Data.DataType, false), + new("source_kind", source_kindArray.Data.DataType, false), + new("source_component", source_componentArray.Data.DataType, false), + new("selector", selectorArray.Data.DataType, false), + }; + var structType = new Apache.Arrow.Types.StructType(fields); + return new StructArray(structType, data.Length, new IArrowArray[] { targetArray, source_kindArray, source_componentArray, selectorArray }, ArrowBuffer.Empty); + } +} diff --git a/src/Rerun.Net/Components/AlbedoFactor.g.cs b/src/Rerun.Net/Components/AlbedoFactor.g.cs index 340344c..065f591 100644 --- a/src/Rerun.Net/Components/AlbedoFactor.g.cs +++ b/src/Rerun.Net/Components/AlbedoFactor.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A color multiplier, usually applied to a whole entity, e.g. a mesh. /// -public readonly record struct AlbedoFactor(Rgba32 AlbedoFactorValue) : ILoggable +public readonly record struct AlbedoFactor(Datatypes.Rgba32 AlbedoFactorValue) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.AlbedoFactor"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Rgba32[data.Length]; + var inner = new Datatypes.Rgba32[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].AlbedoFactorValue; - return Rgba32.ToArrow(inner); + return Datatypes.Rgba32.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/AnnotationContext.g.cs b/src/Rerun.Net/Components/AnnotationContext.g.cs index 2245d98..6cfee7f 100644 --- a/src/Rerun.Net/Components/AnnotationContext.g.cs +++ b/src/Rerun.Net/Components/AnnotationContext.g.cs @@ -16,14 +16,14 @@ namespace Rerun.Net.Components; /// path-hierarchy when searching up through the ancestors of a given entity /// path. /// -public readonly record struct AnnotationContext(ClassDescriptionMapElem[] ClassMap) : ILoggable +public readonly record struct AnnotationContext(Datatypes.ClassDescriptionMapElem[] ClassMap) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.AnnotationContext"); public static IArrowArray ToArrow(ReadOnlySpan data) { // Flatten all inner arrays and build offsets for ListArray - var allItems = new System.Collections.Generic.List(); + var allItems = new System.Collections.Generic.List(); var offsets = new Int32Array.Builder(); offsets.Append(0); foreach (var v in data) @@ -32,7 +32,7 @@ public static IArrowArray ToArrow(ReadOnlySpan data) allItems.Add(item); offsets.Append(allItems.Count); } - var valuesArray = ClassDescriptionMapElem.ToArrow(allItems.ToArray()); + var valuesArray = Datatypes.ClassDescriptionMapElem.ToArrow(allItems.ToArray()); var offsetsArray = offsets.Build(); var listType = new Apache.Arrow.Types.ListType( new Apache.Arrow.Field("item", valuesArray.Data.DataType, false)); diff --git a/src/Rerun.Net/Components/ChannelMessageCounts.g.cs b/src/Rerun.Net/Components/ChannelMessageCounts.g.cs index 27a3cec..164258b 100644 --- a/src/Rerun.Net/Components/ChannelMessageCounts.g.cs +++ b/src/Rerun.Net/Components/ChannelMessageCounts.g.cs @@ -12,14 +12,14 @@ namespace Rerun.Net.Components; /// /// Used in MCAP statistics to track how many messages were recorded per channel. /// -public readonly record struct ChannelMessageCounts(ChannelCountPair[] Counts) : ILoggable +public readonly record struct ChannelMessageCounts(Datatypes.ChannelCountPair[] Counts) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.ChannelMessageCounts"); public static IArrowArray ToArrow(ReadOnlySpan data) { // Flatten all inner arrays and build offsets for ListArray - var allItems = new System.Collections.Generic.List(); + var allItems = new System.Collections.Generic.List(); var offsets = new Int32Array.Builder(); offsets.Append(0); foreach (var v in data) @@ -28,7 +28,7 @@ public static IArrowArray ToArrow(ReadOnlySpan data) allItems.Add(item); offsets.Append(allItems.Count); } - var valuesArray = ChannelCountPair.ToArrow(allItems.ToArray()); + var valuesArray = Datatypes.ChannelCountPair.ToArrow(allItems.ToArray()); var offsetsArray = offsets.Build(); var listType = new Apache.Arrow.Types.ListType( new Apache.Arrow.Field("item", valuesArray.Data.DataType, false)); diff --git a/src/Rerun.Net/Components/Color.g.cs b/src/Rerun.Net/Components/Color.g.cs index 2a3f8db..a4b74f9 100644 --- a/src/Rerun.Net/Components/Color.g.cs +++ b/src/Rerun.Net/Components/Color.g.cs @@ -14,15 +14,15 @@ namespace Rerun.Net.Components; /// byte is `R` and the least significant byte is `A`. /// /// -public readonly record struct Color(Rgba32 Rgba) : ILoggable +public readonly record struct Color(Datatypes.Rgba32 Rgba) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Color"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Rgba32[data.Length]; + var inner = new Datatypes.Rgba32[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Rgba; - return Rgba32.ToArrow(inner); + return Datatypes.Rgba32.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/GeoLineString.g.cs b/src/Rerun.Net/Components/GeoLineString.g.cs index fcff56f..74f5ad4 100644 --- a/src/Rerun.Net/Components/GeoLineString.g.cs +++ b/src/Rerun.Net/Components/GeoLineString.g.cs @@ -10,14 +10,14 @@ namespace Rerun.Net.Components; /// /// A geospatial line string expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees). /// -public readonly record struct GeoLineString(DVec2D[] LatLon) : ILoggable +public readonly record struct GeoLineString(Datatypes.DVec2D[] LatLon) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.GeoLineString"); public static IArrowArray ToArrow(ReadOnlySpan data) { // Flatten all inner arrays and build offsets for ListArray - var allItems = new System.Collections.Generic.List(); + var allItems = new System.Collections.Generic.List(); var offsets = new Int32Array.Builder(); offsets.Append(0); foreach (var v in data) @@ -26,7 +26,7 @@ public static IArrowArray ToArrow(ReadOnlySpan data) allItems.Add(item); offsets.Append(allItems.Count); } - var valuesArray = DVec2D.ToArrow(allItems.ToArray()); + var valuesArray = Datatypes.DVec2D.ToArrow(allItems.ToArray()); var offsetsArray = offsets.Build(); var listType = new Apache.Arrow.Types.ListType( new Apache.Arrow.Field("item", valuesArray.Data.DataType, false)); diff --git a/src/Rerun.Net/Components/GraphEdge.g.cs b/src/Rerun.Net/Components/GraphEdge.g.cs index b830935..382ce87 100644 --- a/src/Rerun.Net/Components/GraphEdge.g.cs +++ b/src/Rerun.Net/Components/GraphEdge.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// An edge in a graph connecting two nodes. /// -public readonly record struct GraphEdge(Utf8Pair Edge) : ILoggable +public readonly record struct GraphEdge(Datatypes.Utf8Pair Edge) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.GraphEdge"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8Pair[data.Length]; + var inner = new Datatypes.Utf8Pair[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Edge; - return Utf8Pair.ToArrow(inner); + return Datatypes.Utf8Pair.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/GraphNode.g.cs b/src/Rerun.Net/Components/GraphNode.g.cs index 20b433f..bdd90c0 100644 --- a/src/Rerun.Net/Components/GraphNode.g.cs +++ b/src/Rerun.Net/Components/GraphNode.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A string-based ID representing a node in a graph. /// -public readonly record struct GraphNode(Utf8 Id) : ILoggable +public readonly record struct GraphNode(Datatypes.Utf8 Id) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.GraphNode"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Id; - return Utf8.ToArrow(inner); + return Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/HalfSize2D.g.cs b/src/Rerun.Net/Components/HalfSize2D.g.cs index 241acd3..9939ee2 100644 --- a/src/Rerun.Net/Components/HalfSize2D.g.cs +++ b/src/Rerun.Net/Components/HalfSize2D.g.cs @@ -15,15 +15,15 @@ namespace Rerun.Net.Components; /// The box extends both in negative and positive direction along each axis. /// Negative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed. /// -public readonly record struct HalfSize2D(Vec2D Xy) : ILoggable +public readonly record struct HalfSize2D(Datatypes.Vec2D Xy) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.HalfSize2D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec2D[data.Length]; + var inner = new Datatypes.Vec2D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Xy; - return Vec2D.ToArrow(inner); + return Datatypes.Vec2D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/HalfSize3D.g.cs b/src/Rerun.Net/Components/HalfSize3D.g.cs index 302087c..98e83e7 100644 --- a/src/Rerun.Net/Components/HalfSize3D.g.cs +++ b/src/Rerun.Net/Components/HalfSize3D.g.cs @@ -15,15 +15,15 @@ namespace Rerun.Net.Components; /// The box extends both in negative and positive direction along each axis. /// Negative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed. /// -public readonly record struct HalfSize3D(Vec3D Xyz) : ILoggable +public readonly record struct HalfSize3D(Datatypes.Vec3D Xyz) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.HalfSize3D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec3D[data.Length]; + var inner = new Datatypes.Vec3D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Xyz; - return Vec3D.ToArrow(inner); + return Datatypes.Vec3D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/ImageBuffer.g.cs b/src/Rerun.Net/Components/ImageBuffer.g.cs index 0a25127..8fd2f3a 100644 --- a/src/Rerun.Net/Components/ImageBuffer.g.cs +++ b/src/Rerun.Net/Components/ImageBuffer.g.cs @@ -12,15 +12,15 @@ namespace Rerun.Net.Components; /// /// To interpret the contents of this buffer, see, [components.ImageFormat]. /// -public readonly record struct ImageBuffer(Blob Buffer) : ILoggable +public readonly record struct ImageBuffer(Datatypes.Blob Buffer) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.ImageBuffer"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Blob[data.Length]; + var inner = new Datatypes.Blob[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Buffer; - return Blob.ToArrow(inner); + return Datatypes.Blob.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/KeyValuePairs.g.cs b/src/Rerun.Net/Components/KeyValuePairs.g.cs index a16191c..a17d05a 100644 --- a/src/Rerun.Net/Components/KeyValuePairs.g.cs +++ b/src/Rerun.Net/Components/KeyValuePairs.g.cs @@ -13,14 +13,14 @@ namespace Rerun.Net.Components; /// This component can be used to attach arbitrary metadata or annotations to entities. /// Each key-value pair is stored as a UTF-8 string mapping. /// -public readonly record struct KeyValuePairs(Utf8Pair[] Pairs) : ILoggable +public readonly record struct KeyValuePairs(Datatypes.Utf8Pair[] Pairs) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.KeyValuePairs"); public static IArrowArray ToArrow(ReadOnlySpan data) { // Flatten all inner arrays and build offsets for ListArray - var allItems = new System.Collections.Generic.List(); + var allItems = new System.Collections.Generic.List(); var offsets = new Int32Array.Builder(); offsets.Append(0); foreach (var v in data) @@ -29,7 +29,7 @@ public static IArrowArray ToArrow(ReadOnlySpan data) allItems.Add(item); offsets.Append(allItems.Count); } - var valuesArray = Utf8Pair.ToArrow(allItems.ToArray()); + var valuesArray = Datatypes.Utf8Pair.ToArrow(allItems.ToArray()); var offsetsArray = offsets.Build(); var listType = new Apache.Arrow.Types.ListType( new Apache.Arrow.Field("item", valuesArray.Data.DataType, false)); diff --git a/src/Rerun.Net/Components/LatLon.g.cs b/src/Rerun.Net/Components/LatLon.g.cs index c2fe208..38e1316 100644 --- a/src/Rerun.Net/Components/LatLon.g.cs +++ b/src/Rerun.Net/Components/LatLon.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A geospatial position expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees). /// -public readonly record struct LatLon(DVec2D LatLonValue) : ILoggable +public readonly record struct LatLon(Datatypes.DVec2D LatLonValue) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.LatLon"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new DVec2D[data.Length]; + var inner = new Datatypes.DVec2D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].LatLonValue; - return DVec2D.ToArrow(inner); + return Datatypes.DVec2D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/LineStrip2D.g.cs b/src/Rerun.Net/Components/LineStrip2D.g.cs index 298ffb4..29c4a3b 100644 --- a/src/Rerun.Net/Components/LineStrip2D.g.cs +++ b/src/Rerun.Net/Components/LineStrip2D.g.cs @@ -21,14 +21,14 @@ namespace Rerun.Net.Components; /// 4 /// ``` /// -public readonly record struct LineStrip2D(Vec2D[] Points) : ILoggable +public readonly record struct LineStrip2D(Datatypes.Vec2D[] Points) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.LineStrip2D"); public static IArrowArray ToArrow(ReadOnlySpan data) { // Flatten all inner arrays and build offsets for ListArray - var allItems = new System.Collections.Generic.List(); + var allItems = new System.Collections.Generic.List(); var offsets = new Int32Array.Builder(); offsets.Append(0); foreach (var v in data) @@ -37,7 +37,7 @@ public static IArrowArray ToArrow(ReadOnlySpan data) allItems.Add(item); offsets.Append(allItems.Count); } - var valuesArray = Vec2D.ToArrow(allItems.ToArray()); + var valuesArray = Datatypes.Vec2D.ToArrow(allItems.ToArray()); var offsetsArray = offsets.Build(); var listType = new Apache.Arrow.Types.ListType( new Apache.Arrow.Field("item", valuesArray.Data.DataType, false)); diff --git a/src/Rerun.Net/Components/LineStrip3D.g.cs b/src/Rerun.Net/Components/LineStrip3D.g.cs index 1b328cf..0737017 100644 --- a/src/Rerun.Net/Components/LineStrip3D.g.cs +++ b/src/Rerun.Net/Components/LineStrip3D.g.cs @@ -21,14 +21,14 @@ namespace Rerun.Net.Components; /// 4 /// ``` /// -public readonly record struct LineStrip3D(Vec3D[] Points) : ILoggable +public readonly record struct LineStrip3D(Datatypes.Vec3D[] Points) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.LineStrip3D"); public static IArrowArray ToArrow(ReadOnlySpan data) { // Flatten all inner arrays and build offsets for ListArray - var allItems = new System.Collections.Generic.List(); + var allItems = new System.Collections.Generic.List(); var offsets = new Int32Array.Builder(); offsets.Append(0); foreach (var v in data) @@ -37,7 +37,7 @@ public static IArrowArray ToArrow(ReadOnlySpan data) allItems.Add(item); offsets.Append(allItems.Count); } - var valuesArray = Vec3D.ToArrow(allItems.ToArray()); + var valuesArray = Datatypes.Vec3D.ToArrow(allItems.ToArray()); var offsetsArray = offsets.Build(); var listType = new Apache.Arrow.Types.ListType( new Apache.Arrow.Field("item", valuesArray.Data.DataType, false)); diff --git a/src/Rerun.Net/Components/MediaType.g.cs b/src/Rerun.Net/Components/MediaType.g.cs index 1b59b8d..0ffdf1a 100644 --- a/src/Rerun.Net/Components/MediaType.g.cs +++ b/src/Rerun.Net/Components/MediaType.g.cs @@ -13,15 +13,15 @@ namespace Rerun.Net.Components; /// The complete reference of officially registered media types is maintained by the IANA and can be /// consulted at . /// -public readonly record struct MediaType(Utf8 Value) : ILoggable +public readonly record struct MediaType(Datatypes.Utf8 Value) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.MediaType"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Value; - return Utf8.ToArrow(inner); + return Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Name.g.cs b/src/Rerun.Net/Components/Name.g.cs index c7fba3e..6109fc2 100644 --- a/src/Rerun.Net/Components/Name.g.cs +++ b/src/Rerun.Net/Components/Name.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A display name, typically for an entity or a item like a plot series. /// -public readonly record struct Name(Utf8 Value) : ILoggable +public readonly record struct Name(Datatypes.Utf8 Value) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Name"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Value; - return Utf8.ToArrow(inner); + return Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/PinholeProjection.g.cs b/src/Rerun.Net/Components/PinholeProjection.g.cs index e52ca30..fd8c768 100644 --- a/src/Rerun.Net/Components/PinholeProjection.g.cs +++ b/src/Rerun.Net/Components/PinholeProjection.g.cs @@ -20,15 +20,15 @@ namespace Rerun.Net.Components; /// 0.0 0.0 1.0 /// ``` /// -public readonly record struct PinholeProjection(Mat3x3 ImageFromCamera) : ILoggable +public readonly record struct PinholeProjection(Datatypes.Mat3x3 ImageFromCamera) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.PinholeProjection"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Mat3x3[data.Length]; + var inner = new Datatypes.Mat3x3[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].ImageFromCamera; - return Mat3x3.ToArrow(inner); + return Datatypes.Mat3x3.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Position2D.g.cs b/src/Rerun.Net/Components/Position2D.g.cs index 85d0e99..d3ef3d1 100644 --- a/src/Rerun.Net/Components/Position2D.g.cs +++ b/src/Rerun.Net/Components/Position2D.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A position in 2D space. /// -public readonly record struct Position2D(Vec2D Xy) : ILoggable +public readonly record struct Position2D(Datatypes.Vec2D Xy) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Position2D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec2D[data.Length]; + var inner = new Datatypes.Vec2D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Xy; - return Vec2D.ToArrow(inner); + return Datatypes.Vec2D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Position3D.g.cs b/src/Rerun.Net/Components/Position3D.g.cs index a70895c..82fb3e9 100644 --- a/src/Rerun.Net/Components/Position3D.g.cs +++ b/src/Rerun.Net/Components/Position3D.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A position in 3D space. /// -public readonly record struct Position3D(Vec3D Xyz) : ILoggable +public readonly record struct Position3D(Datatypes.Vec3D Xyz) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Position3D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec3D[data.Length]; + var inner = new Datatypes.Vec3D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Xyz; - return Vec3D.ToArrow(inner); + return Datatypes.Vec3D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Resolution.g.cs b/src/Rerun.Net/Components/Resolution.g.cs index ed04699..4e83484 100644 --- a/src/Rerun.Net/Components/Resolution.g.cs +++ b/src/Rerun.Net/Components/Resolution.g.cs @@ -12,15 +12,15 @@ namespace Rerun.Net.Components; /// /// Typically in integer units, but for some use cases floating point may be used. /// -public readonly record struct Resolution(Vec2D ResolutionValue) : ILoggable +public readonly record struct Resolution(Datatypes.Vec2D ResolutionValue) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Resolution"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec2D[data.Length]; + var inner = new Datatypes.Vec2D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].ResolutionValue; - return Vec2D.ToArrow(inner); + return Datatypes.Vec2D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/RotationQuat.g.cs b/src/Rerun.Net/Components/RotationQuat.g.cs index a815db3..df5e98a 100644 --- a/src/Rerun.Net/Components/RotationQuat.g.cs +++ b/src/Rerun.Net/Components/RotationQuat.g.cs @@ -14,15 +14,15 @@ namespace Rerun.Net.Components; /// datastore as provided, when used in the Viewer, quaternions will always be normalized. /// If normalization fails the rotation is treated as an invalid transform. /// -public readonly record struct RotationQuat(Quaternion Quaternion) : ILoggable +public readonly record struct RotationQuat(Datatypes.Quaternion Quaternion) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.RotationQuat"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Quaternion[data.Length]; + var inner = new Datatypes.Quaternion[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Quaternion; - return Quaternion.ToArrow(inner); + return Datatypes.Quaternion.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Scale3D.g.cs b/src/Rerun.Net/Components/Scale3D.g.cs index f3d7c32..cb9843c 100644 --- a/src/Rerun.Net/Components/Scale3D.g.cs +++ b/src/Rerun.Net/Components/Scale3D.g.cs @@ -14,15 +14,15 @@ namespace Rerun.Net.Components; /// A scale of 2.0 means doubling the size. /// Each component scales along the corresponding axis. /// -public readonly record struct Scale3D(Vec3D Scale) : ILoggable +public readonly record struct Scale3D(Datatypes.Vec3D Scale) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Scale3D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec3D[data.Length]; + var inner = new Datatypes.Vec3D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Scale; - return Vec3D.ToArrow(inner); + return Datatypes.Vec3D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/TensorHeightDimension.g.cs b/src/Rerun.Net/Components/TensorHeightDimension.g.cs index 0f51aaf..b0e8a12 100644 --- a/src/Rerun.Net/Components/TensorHeightDimension.g.cs +++ b/src/Rerun.Net/Components/TensorHeightDimension.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// Specifies which dimension to use for height. /// -public readonly record struct TensorHeightDimension(TensorDimensionSelection Dimension) : ILoggable +public readonly record struct TensorHeightDimension(Datatypes.TensorDimensionSelection Dimension) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.TensorHeightDimension"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new TensorDimensionSelection[data.Length]; + var inner = new Datatypes.TensorDimensionSelection[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Dimension; - return TensorDimensionSelection.ToArrow(inner); + return Datatypes.TensorDimensionSelection.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/TensorWidthDimension.g.cs b/src/Rerun.Net/Components/TensorWidthDimension.g.cs index f8ac3f6..4a7fa25 100644 --- a/src/Rerun.Net/Components/TensorWidthDimension.g.cs +++ b/src/Rerun.Net/Components/TensorWidthDimension.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// Specifies which dimension to use for width. /// -public readonly record struct TensorWidthDimension(TensorDimensionSelection Dimension) : ILoggable +public readonly record struct TensorWidthDimension(Datatypes.TensorDimensionSelection Dimension) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.TensorWidthDimension"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new TensorDimensionSelection[data.Length]; + var inner = new Datatypes.TensorDimensionSelection[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Dimension; - return TensorDimensionSelection.ToArrow(inner); + return Datatypes.TensorDimensionSelection.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Texcoord2D.g.cs b/src/Rerun.Net/Components/Texcoord2D.g.cs index a86df39..78286a1 100644 --- a/src/Rerun.Net/Components/Texcoord2D.g.cs +++ b/src/Rerun.Net/Components/Texcoord2D.g.cs @@ -26,15 +26,15 @@ namespace Rerun.Net.Components; /// This is the same convention as in Vulkan/Metal/DX12/WebGPU, but (!) unlike OpenGL, /// which places the origin at the bottom-left. /// -public readonly record struct Texcoord2D(Vec2D Uv) : ILoggable +public readonly record struct Texcoord2D(Datatypes.Vec2D Uv) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Texcoord2D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec2D[data.Length]; + var inner = new Datatypes.Vec2D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Uv; - return Vec2D.ToArrow(inner); + return Datatypes.Vec2D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Text.g.cs b/src/Rerun.Net/Components/Text.g.cs index 65b44e6..b1dc484 100644 --- a/src/Rerun.Net/Components/Text.g.cs +++ b/src/Rerun.Net/Components/Text.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A string of text, e.g. for labels and text documents. /// -public readonly record struct Text(Utf8 Value) : ILoggable +public readonly record struct Text(Datatypes.Utf8 Value) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Text"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Value; - return Utf8.ToArrow(inner); + return Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/TextLogLevel.g.cs b/src/Rerun.Net/Components/TextLogLevel.g.cs index ffd74a5..1ef2595 100644 --- a/src/Rerun.Net/Components/TextLogLevel.g.cs +++ b/src/Rerun.Net/Components/TextLogLevel.g.cs @@ -18,15 +18,15 @@ namespace Rerun.Net.Components; /// * `"DEBUG"` /// * `"TRACE"` /// -public readonly record struct TextLogLevel(Utf8 Value) : ILoggable +public readonly record struct TextLogLevel(Datatypes.Utf8 Value) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.TextLogLevel"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Value; - return Utf8.ToArrow(inner); + return Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Timestamp.g.cs b/src/Rerun.Net/Components/Timestamp.g.cs index f268060..97240e0 100644 --- a/src/Rerun.Net/Components/Timestamp.g.cs +++ b/src/Rerun.Net/Components/Timestamp.g.cs @@ -12,15 +12,15 @@ namespace Rerun.Net.Components; /// /// Should be an absolute time, i.e. relative to Unix Epoch. /// -public readonly record struct Timestamp(TimeInt TimestampValue) : ILoggable +public readonly record struct Timestamp(Datatypes.TimeInt TimestampValue) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Timestamp"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new TimeInt[data.Length]; + var inner = new Datatypes.TimeInt[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].TimestampValue; - return TimeInt.ToArrow(inner); + return Datatypes.TimeInt.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/TransformFrameId.g.cs b/src/Rerun.Net/Components/TransformFrameId.g.cs index 3ca4cce..10701d9 100644 --- a/src/Rerun.Net/Components/TransformFrameId.g.cs +++ b/src/Rerun.Net/Components/TransformFrameId.g.cs @@ -18,15 +18,15 @@ namespace Rerun.Net.Components; /// describes a relationship between these parent and child transform frames, **not** the transform frame /// that the entity path may be using (defined by an [archetypes.CoordinateFrame]). /// -public readonly record struct TransformFrameId(Utf8 Value) : ILoggable +public readonly record struct TransformFrameId(Datatypes.Utf8 Value) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.TransformFrameId"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Utf8[data.Length]; + var inner = new Datatypes.Utf8[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Value; - return Utf8.ToArrow(inner); + return Datatypes.Utf8.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/TransformMat3x3.g.cs b/src/Rerun.Net/Components/TransformMat3x3.g.cs index 97a1695..2798595 100644 --- a/src/Rerun.Net/Components/TransformMat3x3.g.cs +++ b/src/Rerun.Net/Components/TransformMat3x3.g.cs @@ -23,15 +23,15 @@ namespace Rerun.Net.Components; /// ``` /// /// -public readonly record struct TransformMat3x3(Mat3x3 Matrix) : ILoggable +public readonly record struct TransformMat3x3(Datatypes.Mat3x3 Matrix) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.TransformMat3x3"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Mat3x3[data.Length]; + var inner = new Datatypes.Mat3x3[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Matrix; - return Mat3x3.ToArrow(inner); + return Datatypes.Mat3x3.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Translation3D.g.cs b/src/Rerun.Net/Components/Translation3D.g.cs index cf51d72..9c92b45 100644 --- a/src/Rerun.Net/Components/Translation3D.g.cs +++ b/src/Rerun.Net/Components/Translation3D.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A translation vector in 3D space. /// -public readonly record struct Translation3D(Vec3D Vector) : ILoggable +public readonly record struct Translation3D(Datatypes.Vec3D Vector) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Translation3D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec3D[data.Length]; + var inner = new Datatypes.Vec3D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Vector; - return Vec3D.ToArrow(inner); + return Datatypes.Vec3D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/TriangleIndices.g.cs b/src/Rerun.Net/Components/TriangleIndices.g.cs index 78bcec5..069cde1 100644 --- a/src/Rerun.Net/Components/TriangleIndices.g.cs +++ b/src/Rerun.Net/Components/TriangleIndices.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// The three indices of a triangle in a triangle mesh. /// -public readonly record struct TriangleIndices(UVec3D Indices) : ILoggable +public readonly record struct TriangleIndices(Datatypes.UVec3D Indices) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.TriangleIndices"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new UVec3D[data.Length]; + var inner = new Datatypes.UVec3D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Indices; - return UVec3D.ToArrow(inner); + return Datatypes.UVec3D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/ValueRange.g.cs b/src/Rerun.Net/Components/ValueRange.g.cs index ba15adf..44ee8bc 100644 --- a/src/Rerun.Net/Components/ValueRange.g.cs +++ b/src/Rerun.Net/Components/ValueRange.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// Range of expected or valid values, specifying a lower and upper bound. /// -public readonly record struct ValueRange(Range1D Range) : ILoggable +public readonly record struct ValueRange(Datatypes.Range1D Range) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.ValueRange"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Range1D[data.Length]; + var inner = new Datatypes.Range1D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Range; - return Range1D.ToArrow(inner); + return Datatypes.Range1D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Vector2D.g.cs b/src/Rerun.Net/Components/Vector2D.g.cs index d2e7b15..1d4644d 100644 --- a/src/Rerun.Net/Components/Vector2D.g.cs +++ b/src/Rerun.Net/Components/Vector2D.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A vector in 2D space. /// -public readonly record struct Vector2D(Vec2D Vector) : ILoggable +public readonly record struct Vector2D(Datatypes.Vec2D Vector) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Vector2D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec2D[data.Length]; + var inner = new Datatypes.Vec2D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Vector; - return Vec2D.ToArrow(inner); + return Datatypes.Vec2D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/Vector3D.g.cs b/src/Rerun.Net/Components/Vector3D.g.cs index e4cf4b4..5be80b6 100644 --- a/src/Rerun.Net/Components/Vector3D.g.cs +++ b/src/Rerun.Net/Components/Vector3D.g.cs @@ -10,15 +10,15 @@ namespace Rerun.Net.Components; /// /// A vector in 3D space. /// -public readonly record struct Vector3D(Vec3D Vector) : ILoggable +public readonly record struct Vector3D(Datatypes.Vec3D Vector) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.Vector3D"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Vec3D[data.Length]; + var inner = new Datatypes.Vec3D[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Vector; - return Vec3D.ToArrow(inner); + return Datatypes.Vec3D.ToArrow(inner); } } diff --git a/src/Rerun.Net/Components/VideoSample.g.cs b/src/Rerun.Net/Components/VideoSample.g.cs index 628ade2..3b667bd 100644 --- a/src/Rerun.Net/Components/VideoSample.g.cs +++ b/src/Rerun.Net/Components/VideoSample.g.cs @@ -15,15 +15,15 @@ namespace Rerun.Net.Components; /// /// Keyframes may require additional data, for details see [components.VideoCodec]. /// -public readonly record struct VideoSample(Blob Buffer) : ILoggable +public readonly record struct VideoSample(Datatypes.Blob Buffer) : ILoggable { public static ComponentDescriptor Descriptor => new(null, null, "rerun.components.VideoSample"); public static IArrowArray ToArrow(ReadOnlySpan data) { - var inner = new Blob[data.Length]; + var inner = new Datatypes.Blob[data.Length]; for (var i = 0; i < data.Length; i++) inner[i] = data[i].Buffer; - return Blob.ToArrow(inner); + return Datatypes.Blob.ToArrow(inner); } } diff --git a/src/Rerun.Net/Core/RecordingStream.cs b/src/Rerun.Net/Core/RecordingStream.cs index 8172feb..13db771 100644 --- a/src/Rerun.Net/Core/RecordingStream.cs +++ b/src/Rerun.Net/Core/RecordingStream.cs @@ -160,7 +160,7 @@ public void ServeGrpc(string? bindIp = null, ushort port = 0, string? serverMemo : default; var error = new RrError(); NativeMethods.RrRecordingStreamServeGrpc( - _handle, rrBindIp, port, rrMemLimit, newestFirst, null, 0, ref error); + _handle, rrBindIp, port, rrMemLimit, newestFirst, ref error); RerunException.ThrowIfError(error); } } diff --git a/src/Rerun.Net/Native/NativeMethods.cs b/src/Rerun.Net/Native/NativeMethods.cs index 227d694..28c1b03 100644 --- a/src/Rerun.Net/Native/NativeMethods.cs +++ b/src/Rerun.Net/Native/NativeMethods.cs @@ -68,10 +68,9 @@ internal static partial void RrRecordingStreamFlushBlocking( uint stream, float timeoutSec, ref RrError error); [LibraryImport(LibraryName, EntryPoint = "rr_recording_stream_serve_grpc")] - internal static unsafe partial void RrRecordingStreamServeGrpc( + internal static partial void RrRecordingStreamServeGrpc( uint stream, RrString bindIp, ushort port, RrString serverMemoryLimit, [MarshalAs(UnmanagedType.U1)] bool newestFirst, - RrString* corsAllowOrigins, uint numCorsAllowOrigins, ref RrError error); [LibraryImport(LibraryName, EntryPoint = "rr_recording_stream_set_sinks")] diff --git a/src/Rerun.Net/Rerun.Net.csproj b/src/Rerun.Net/Rerun.Net.csproj index b19f092..46be995 100644 --- a/src/Rerun.Net/Rerun.Net.csproj +++ b/src/Rerun.Net/Rerun.Net.csproj @@ -4,7 +4,7 @@ Rerun.Net Rerun.Net Rerun.Net - 0.32.0-alpha.1 + 0.31.3 C# SDK for Rerun - visualization infrastructure for multimodal data Kevin Gliewe MIT