file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
An-u-rag/synthetic-visual-dataset-generation/fiftyone.py | import fiftyone as fo
name = "my-dataset"
dataset_dir = "C:/Users/xyche/Downloads/dataset"
# Create the dataset
dataset = fo.Dataset.from_dir(
dataset_dir=dataset_dir,
dataset_type=fo.types.YOLOv5Dataset,
name=name,
)
# View summary info about the dataset
print(dataset)
# Print the first few samples in the dataset
print(dataset.head())
session = fo.launch_app(dataset) | 387 | Python | 19.421052 | 48 | 0.73385 |
An-u-rag/synthetic-visual-dataset-generation/README.md | # synthetic-visual-dataset-generation
Generation of synthetic visual datasets using NVIDIA Omniverse for training Deep Learning Models.
| 136 | Markdown | 44.666652 | 97 | 0.852941 |
An-u-rag/synthetic-visual-dataset-generation/Yolov5TrainingOutputs/yolov5m_35ep_syntheticAndReal/opt.yaml | weights: yolov5m.pt
cfg: models/yolov5m.yaml
data: data/cocow_less.yaml
hyp:
lr0: 0.01
lrf: 0.01
momentum: 0.937
weight_decay: 0.0005
warmup_epochs: 3.0
warmup_momentum: 0.8
warmup_bias_lr: 0.1
box: 0.05
cls: 0.5
cls_pw: 1.0
obj: 1.0
obj_pw: 1.0
iou_t: 0.2
anchor_t: 4.0
fl_gamma: 0.0
hsv_h: 0.015
hsv_s: 0.7
hsv_v: 0.4
degrees: 0.0
translate: 0.1
scale: 0.5
shear: 0.0
perspective: 0.0
flipud: 0.0
fliplr: 0.5
mosaic: 1.0
mixup: 0.0
copy_paste: 0.0
epochs: 100
batch_size: 16
imgsz: 640
rect: false
resume: false
nosave: false
noval: false
noautoanchor: false
noplots: false
evolve: null
bucket: ''
cache: disk
image_weights: false
device: ''
multi_scale: false
single_cls: false
optimizer: SGD
sync_bn: false
workers: 8
project: runs\train
name: realaugmented
exist_ok: false
quad: false
cos_lr: false
label_smoothing: 0.0
patience: 100
freeze:
- 0
save_period: 5
seed: 0
local_rank: -1
entity: null
upload_dataset: false
bbox_interval: -1
artifact_alias: latest
save_dir: runs\train\realaugmented
| 1,056 | YAML | 14.31884 | 34 | 0.6875 |
An-u-rag/synthetic-visual-dataset-generation/Yolov5TrainingOutputs/yolov5m_35ep_syntheticAndReal/hyp.yaml | lr0: 0.01
lrf: 0.01
momentum: 0.937
weight_decay: 0.0005
warmup_epochs: 3.0
warmup_momentum: 0.8
warmup_bias_lr: 0.1
box: 0.05
cls: 0.5
cls_pw: 1.0
obj: 1.0
obj_pw: 1.0
iou_t: 0.2
anchor_t: 4.0
fl_gamma: 0.0
hsv_h: 0.015
hsv_s: 0.7
hsv_v: 0.4
degrees: 0.0
translate: 0.1
scale: 0.5
shear: 0.0
perspective: 0.0
flipud: 0.0
fliplr: 0.5
mosaic: 1.0
mixup: 0.0
copy_paste: 0.0
| 373 | YAML | 11.896551 | 20 | 0.662198 |
An-u-rag/synthetic-visual-dataset-generation/Yolov5TrainingOutputs/yolov5m_calibrateddataset_60ep_syntheticOnly/opt.yaml | weights: yolov5m.pt
cfg: models/yolov5m.yaml
data: C:\Users\anura\Desktop\project_training\yolov5-master\data\cocow_less.yaml
hyp:
lr0: 0.01
lrf: 0.01
momentum: 0.937
weight_decay: 0.0005
warmup_epochs: 3.0
warmup_momentum: 0.8
warmup_bias_lr: 0.1
box: 0.05
cls: 0.5
cls_pw: 1.0
obj: 1.0
obj_pw: 1.0
iou_t: 0.2
anchor_t: 4.0
fl_gamma: 0.0
hsv_h: 0.015
hsv_s: 0.7
hsv_v: 0.4
degrees: 0.0
translate: 0.1
scale: 0.5
shear: 0.0
perspective: 0.0
flipud: 0.0
fliplr: 0.5
mosaic: 1.0
mixup: 0.0
copy_paste: 0.0
epochs: 100
batch_size: 16
imgsz: 640
rect: false
resume: false
nosave: false
noval: false
noautoanchor: false
noplots: false
evolve: null
bucket: ''
cache: disk
image_weights: false
device: ''
multi_scale: false
single_cls: false
optimizer: SGD
sync_bn: false
workers: 8
project: runs\train
name: main_less_100e
exist_ok: false
quad: false
cos_lr: false
label_smoothing: 0.0
patience: 100
freeze:
- 0
save_period: 5
seed: 0
local_rank: -1
entity: null
upload_dataset: false
bbox_interval: -1
artifact_alias: latest
save_dir: runs\train\main_less_100e
| 1,112 | YAML | 15.130435 | 80 | 0.691547 |
An-u-rag/synthetic-visual-dataset-generation/Yolov5TrainingOutputs/yolov5m_calibrateddataset_60ep_syntheticOnly/hyp.yaml | lr0: 0.01
lrf: 0.01
momentum: 0.937
weight_decay: 0.0005
warmup_epochs: 3.0
warmup_momentum: 0.8
warmup_bias_lr: 0.1
box: 0.05
cls: 0.5
cls_pw: 1.0
obj: 1.0
obj_pw: 1.0
iou_t: 0.2
anchor_t: 4.0
fl_gamma: 0.0
hsv_h: 0.015
hsv_s: 0.7
hsv_v: 0.4
degrees: 0.0
translate: 0.1
scale: 0.5
shear: 0.0
perspective: 0.0
flipud: 0.0
fliplr: 0.5
mosaic: 1.0
mixup: 0.0
copy_paste: 0.0
| 373 | YAML | 11.896551 | 20 | 0.662198 |
An-u-rag/synthetic-visual-dataset-generation/Yolov5TrainingOutputs/yolov5m_100ep_syntheticOnly/opt.yaml | weights: yolov5m.pt
cfg: ''
data: C:\Users\anura\Desktop\project_training\yolov5-master\data\cocow.yaml
hyp:
lr0: 0.01
lrf: 0.01
momentum: 0.937
weight_decay: 0.0005
warmup_epochs: 3.0
warmup_momentum: 0.8
warmup_bias_lr: 0.1
box: 0.05
cls: 0.5
cls_pw: 1.0
obj: 1.0
obj_pw: 1.0
iou_t: 0.2
anchor_t: 4.0
fl_gamma: 0.0
hsv_h: 0.015
hsv_s: 0.7
hsv_v: 0.4
degrees: 0.0
translate: 0.1
scale: 0.5
shear: 0.0
perspective: 0.0
flipud: 0.0
fliplr: 0.5
mosaic: 1.0
mixup: 0.0
copy_paste: 0.0
epochs: 100
batch_size: 16
imgsz: 640
rect: false
resume: false
nosave: false
noval: false
noautoanchor: false
noplots: false
evolve: null
bucket: ''
cache: disk
image_weights: false
device: ''
multi_scale: false
single_cls: false
optimizer: SGD
sync_bn: false
workers: 8
project: runs\train
name: exp
exist_ok: false
quad: false
cos_lr: false
label_smoothing: 0.0
patience: 100
freeze:
- 0
save_period: -1
seed: 0
local_rank: -1
entity: null
upload_dataset: false
bbox_interval: -1
artifact_alias: latest
save_dir: runs\train\exp4
| 1,070 | YAML | 14.521739 | 75 | 0.683178 |
An-u-rag/synthetic-visual-dataset-generation/Yolov5TrainingOutputs/yolov5m_100ep_syntheticOnly/hyp.yaml | lr0: 0.01
lrf: 0.01
momentum: 0.937
weight_decay: 0.0005
warmup_epochs: 3.0
warmup_momentum: 0.8
warmup_bias_lr: 0.1
box: 0.05
cls: 0.5
cls_pw: 1.0
obj: 1.0
obj_pw: 1.0
iou_t: 0.2
anchor_t: 4.0
fl_gamma: 0.0
hsv_h: 0.015
hsv_s: 0.7
hsv_v: 0.4
degrees: 0.0
translate: 0.1
scale: 0.5
shear: 0.0
perspective: 0.0
flipud: 0.0
fliplr: 0.5
mosaic: 1.0
mixup: 0.0
copy_paste: 0.0
| 373 | YAML | 11.896551 | 20 | 0.662198 |
An-u-rag/synthetic-visual-dataset-generation/ReplicatorScripts/Replicator_RandomizeCows_Basic.py | import io
import json
import time
import asyncio
from typing import List
import omni.kit
import omni.usd
import omni.replicator.core as rep
import numpy as np
from omni.replicator.core import AnnotatorRegistry, BackendDispatch, Writer, WriterRegistry, orchestrator
from omni.syntheticdata.scripts.SyntheticData import SyntheticData
camera_positions = [(1720, -1220, 200), (3300, -1220, 200),
(3300, -3500, 200), (1720, -3500, 200)]
# Attach Render Product
with rep.new_layer():
camera = rep.create.camera()
render_product = rep.create.render_product(camera, (1280, 1280))
# Randomizer Function
def randomize_cows():
cows = rep.get.prims(semantics=[('class', 'cow')])
with cows:
rep.modify.visibility(rep.distribution.choice([True, False]))
return cows.node
rep.randomizer.register(randomize_cows)
# Trigger to call randomizer
with rep.trigger.on_frame(num_frames=10):
with camera:
rep.modify.pose(position=rep.distribution.choice(
camera_positions), look_at=(2500, -2300, 0))
rep.randomizer.randomize_cows()
# Initialize and attach Writer to store result
writer = rep.WriterRegistry.get('CowWriter')
writer.initialize(output_dir='C:/Users/anura/Desktop/IndoorRanch_ReplicatorOutputs/Run4',
rgb=True, bounding_box_2d_tight=True)
writer.attach([render_product])
| 1,376 | Python | 22.741379 | 105 | 0.713663 |
An-u-rag/synthetic-visual-dataset-generation/ReplicatorScripts/Replicator_RandomizeSimple.py | import io
import json
import time
import asyncio
from typing import List
import omni.kit
import omni.usd
import omni.replicator.core as rep
import csv
import numpy as np
from omni.replicator.core import AnnotatorRegistry, BackendDispatch, Writer, WriterRegistry, orchestrator
from omni.syntheticdata.scripts.SyntheticData import SyntheticData
class CowWriter(Writer):
def __init__(
self,
output_dir: str,
semantic_types: List[str] = None,
rgb: bool = True,
bounding_box_2d_loose: bool = False,
image_output_format: str = "png",
):
self._output_dir = output_dir
self._backend = BackendDispatch({"paths": {"out_dir": output_dir}})
self._frame_id = 0
self._sequence_id = 0
self._image_output_format = image_output_format
self._output_data_format = {}
self.annotators = []
if semantic_types is None:
semantic_types = ["class"]
# RGB
if rgb:
self.annotators.append(AnnotatorRegistry.get_annotator("rgb"))
if bounding_box_2d_loose:
self.annotators.append(
AnnotatorRegistry.get_annotator("bounding_box_2d_loose", init_params={
"semanticTypes": semantic_types})
)
def write(self, data: dict):
sequence_id = ""
for trigger_name, call_count in data["trigger_outputs"].items():
if "on_time" in trigger_name:
sequence_id = f"{call_count}_{sequence_id}"
if sequence_id != self._sequence_id:
self._frame_id = 0
self._sequence_id = sequence_id
for annotator in data.keys():
annotator_split = annotator.split("-")
render_product_path = ""
multi_render_prod = 0
if len(annotator_split) > 1:
multi_render_prod = 1
render_product_name = annotator_split[-1]
render_product_path = f"{render_product_name}/"
if annotator.startswith("rgb"):
if multi_render_prod:
render_product_path += "rgb/"
self._write_rgb(data, render_product_path, annotator)
if annotator.startswith("bounding_box_2d_loose"):
if multi_render_prod:
render_product_path += "bounding_box_2d_loose/"
self._write_bounding_box_data(
data, "2d_loose", render_product_path, annotator)
self._frame_id += 1
def _write_rgb(self, data: dict, render_product_path: str, annotator: str):
file_path = f"{render_product_path}rgb_{self._sequence_id}{self._frame_id:0}.{self._image_output_format}"
self._backend.write_image(file_path, data[annotator])
def _write_bounding_box_data(self, data: dict, bbox_type: str, render_product_path: str, annotator: str):
bbox_data_all = data[annotator]["data"]
id_to_labels = data[annotator]["info"]["idToLabels"]
prim_paths = data[annotator]["info"]["primPaths"]
target_coco_bbox_data = []
count = 0
print(bbox_data_all)
labels_file_path = f"{render_product_path}rgb_{self._sequence_id}{self._frame_id:0}.txt"
for bbox_data in bbox_data_all:
target_bbox_data = {'x_min': bbox_data['x_min'], 'y_min': bbox_data['y_min'],
'x_max': bbox_data['x_max'], 'y_max': bbox_data['y_max']}
width = int(
abs(target_bbox_data["x_max"] - target_bbox_data["x_min"]))
height = int(
abs(target_bbox_data["y_max"] - target_bbox_data["y_min"]))
semantic_label = data[annotator]["info"]["idToLabels"].get(bbox_data["semanticId"])
coco_bbox_data = []
coco_bbox_data.append(semantic_label)
coco_bbox_data.append(str((float(target_bbox_data["x_min"]) + float(target_bbox_data["x_max"]))/2))
coco_bbox_data.append(str((float(target_bbox_data["y_min"]) + float(target_bbox_data["y_max"]))/2))
coco_bbox_data.append(str(width))
coco_bbox_data.append(str(height))
target_coco_bbox_data.append(coco_bbox_data)
count += 1
buf = io.StringIO()
writer = csv.writer(buf, delimiter = " ")
writer.writerows(target_coco_bbox_data)
self._backend.write_blob(labels_file_path, bytes(buf.getvalue(), "utf-8"))
rep.WriterRegistry.register(CowWriter)
camera_positions = [(-1100, 1480, -900), (-1100, 3355, -900),
(2815, 3410, -800), (2815, 1380, -800)]
# Attach Render Product
with rep.new_layer():
camera = rep.create.camera()
render_product = rep.create.render_product(camera, (1280, 1280))
# Randomizer Function
def randomize_pigsdirty():
pigs = rep.get.prims(semantics=[('class', 'pig_dirty')])
with pigs:
rep.modify.visibility(rep.distribution.choice([True, False]))
return pigs.node
rep.randomizer.register(randomize_pigsdirty)
def randomize_pigsclean():
pigs = rep.get.prims(semantics=[('class', 'pig_clean')])
with pigs:
rep.modify.visibility(rep.distribution.choice([True, False]))
return pigs.node
rep.randomizer.register(randomize_pigsclean)
def randomize_cows2():
cows = rep.get.prims(semantics=[('class', 'cow_2')])
with cows:
rep.modify.visibility(rep.distribution.choice([True, False]))
return cows.node
rep.randomizer.register(randomize_cows2)
def randomize_cows3():
cows = rep.get.prims(semantics=[('class', 'cow_3')])
with cows:
rep.modify.visibility(rep.distribution.choice([True, False]))
return cows.node
rep.randomizer.register(randomize_cows3)
def randomize_cows4():
cows = rep.get.prims(semantics=[('class', 'cow_4')])
with cows:
rep.modify.visibility(rep.distribution.choice([True, False]))
return cows.node
rep.randomizer.register(randomize_cows4)
def randomize_environment():
envs = ["omniverse://localhost/NVIDIA/Assets/Skies/Clear/noon_grass_4k.hdr",
"omniverse://localhost/NVIDIA/Assets/Skies/Night/moonlit_golf_4k.hdr",
"omniverse://localhost/NVIDIA/Assets/Skies/Storm/approaching_storm_4k.hdr"]
lights = rep.create.light(
light_type = "Dome",
position = (2500, -2300, 0),
intensity = rep.distribution.choice([1., 10., 100., 1000.]),
texture = rep.distribution.choice(envs)
)
return lights.node
rep.randomizer.register(randomize_environment)
# Trigger to call randomizer
with rep.trigger.on_frame(num_frames=3000):
with camera:
rep.modify.pose(position=rep.distribution.choice(
camera_positions), look_at=(790, 2475, -1178))
rep.randomizer.randomize_environment()
rep.randomizer.randomize_pigsdirty()
rep.randomizer.randomize_pigsclean()
rep.randomizer.randomize_cows2()
rep.randomizer.randomize_cows3()
rep.randomizer.randomize_cows4()
writer = rep.WriterRegistry.get('BasicWriter')
writer.initialize(output_dir='C:/Users/anura/Desktop/IndoorRanch_ReplicatorOutputs/SanjRun1',
rgb=True, bounding_box_2d_tight=True, bounding_box_2d_loose=True, semantic_segmentation=True, bounding_box_3d=True)
writer.attach([render_product])
| 7,338 | Python | 34.8 | 134 | 0.615018 |
An-u-rag/synthetic-visual-dataset-generation/ReplicatorScripts/Replicator_RandomizeCows.py | import io
import json
import time
import asyncio
from typing import List
import omni.kit
import omni.usd
import omni.replicator.core as rep
import numpy as np
from omni.replicator.core import AnnotatorRegistry, BackendDispatch, Writer, WriterRegistry, orchestrator
from omni.syntheticdata.scripts.SyntheticData import SyntheticData
class CowWriter(Writer):
def __init__(
self,
output_dir: str,
semantic_types: List[str] = None,
rgb: bool = True,
bounding_box_2d_tight: bool = False,
bounding_box_2d_loose: bool = False,
semantic_segmentation: bool = False,
instance_id_segmentation: bool = False,
instance_segmentation: bool = False,
distance_to_camera: bool = False,
bounding_box_3d: bool = False,
image_output_format: str = "png",
):
self._output_dir = output_dir
self._backend = BackendDispatch({"paths": {"out_dir": output_dir}})
self._frame_id = 0
self._sequence_id = 0
self._image_output_format = image_output_format
self._output_data_format = {}
self.annotators = []
if semantic_types is None:
semantic_types = ["class"]
# RGB
if rgb:
self.annotators.append(AnnotatorRegistry.get_annotator("rgb"))
# Bounding Box 2D
if bounding_box_2d_tight:
self.annotators.append(
AnnotatorRegistry.get_annotator("bounding_box_2d_tight", init_params={
"semanticTypes": semantic_types})
)
if bounding_box_2d_loose:
self.annotators.append(
AnnotatorRegistry.get_annotator("bounding_box_2d_loose", init_params={
"semanticTypes": semantic_types})
)
# Semantic Segmentation
if semantic_segmentation:
self.annotators.append(
AnnotatorRegistry.get_annotator(
"semantic_segmentation",
init_params={"semanticTypes": semantic_types},
)
)
# Instance Segmentation
if instance_id_segmentation:
self.annotators.append(
AnnotatorRegistry.get_annotator(
"instance_id_segmentation", init_params={}
)
)
# Instance Segmentation
if instance_segmentation:
self.annotators.append(
AnnotatorRegistry.get_annotator(
"instance_segmentation",
init_params={"semanticTypes": semantic_types},
)
)
# Depth
if distance_to_camera:
self.annotators.append(
AnnotatorRegistry.get_annotator("distance_to_camera"))
# Bounding Box 3D
if bounding_box_3d:
self.annotators.append(
AnnotatorRegistry.get_annotator("bounding_box_3d", init_params={
"semanticTypes": semantic_types})
)
def write(self, data: dict):
sequence_id = ""
for trigger_name, call_count in data["trigger_outputs"].items():
if "on_time" in trigger_name:
sequence_id = f"{call_count}_{sequence_id}"
if sequence_id != self._sequence_id:
self._frame_id = 0
self._sequence_id = sequence_id
for annotator in data.keys():
annotator_split = annotator.split("-")
render_product_path = ""
multi_render_prod = 0
if len(annotator_split) > 1:
multi_render_prod = 1
render_product_name = annotator_split[-1]
render_product_path = f"{render_product_name}/"
if annotator.startswith("rgb"):
if multi_render_prod:
render_product_path += "rgb/"
self._write_rgb(data, render_product_path, annotator)
if annotator.startswith("distance_to_camera"):
if multi_render_prod:
render_product_path += "distance_to_camera/"
self._write_distance_to_camera(
data, render_product_path, annotator)
if annotator.startswith("semantic_segmentation"):
if multi_render_prod:
render_product_path += "semantic_segmentation/"
self._write_semantic_segmentation(
data, render_product_path, annotator)
if annotator.startswith("instance_id_segmentation"):
if multi_render_prod:
render_product_path += "instance_id_segmentation/"
self._write_instance_id_segmentation(
data, render_product_path, annotator)
if annotator.startswith("instance_segmentation"):
if multi_render_prod:
render_product_path += "instance_segmentation/"
self._write_instance_segmentation(
data, render_product_path, annotator)
if annotator.startswith("bounding_box_3d"):
if multi_render_prod:
render_product_path += "bounding_box_3d/"
self._write_bounding_box_data(
data, "3d", render_product_path, annotator)
if annotator.startswith("bounding_box_2d_loose"):
if multi_render_prod:
render_product_path += "bounding_box_2d_loose/"
self._write_bounding_box_data(
data, "2d_loose", render_product_path, annotator)
if annotator.startswith("bounding_box_2d_tight"):
if multi_render_prod:
render_product_path += "bounding_box_2d_tight/"
self._write_bounding_box_data(
data, "2d_tight", render_product_path, annotator)
self._frame_id += 1
def _write_rgb(self, data: dict, render_product_path: str, annotator: str):
file_path = f"{render_product_path}rgb_{self._sequence_id}{self._frame_id:0}.{self._image_output_format}"
self._backend.write_image(file_path, data[annotator])
def _write_distance_to_camera(self, data: dict, render_product_path: str, annotator: str):
dist_to_cam_data = data[annotator]
file_path = (
f"{render_product_path}distance_to_camera_{self._sequence_id}{self._frame_id:0}.npy"
)
buf = io.BytesIO()
np.save(buf, dist_to_cam_data)
self._backend.write_blob(file_path, buf.getvalue())
def _write_semantic_segmentation(self, data: dict, render_product_path: str, annotator: str):
semantic_seg_data = data[annotator]["data"]
height, width = semantic_seg_data.shape[:2]
file_path = (
f"{render_product_path}semantic_segmentation_{self._sequence_id}{self._frame_id:0}.png"
)
if self.colorize_semantic_segmentation:
semantic_seg_data = semantic_seg_data.view(
np.uint8).reshape(height, width, -1)
self._backend.write_image(file_path, semantic_seg_data)
else:
semantic_seg_data = semantic_seg_data.view(
np.uint32).reshape(height, width)
self._backend.write_image(file_path, semantic_seg_data)
id_to_labels = data[annotator]["info"]["idToLabels"]
file_path = f"{render_product_path}semantic_segmentation_labels_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(
{str(k): v for k, v in id_to_labels.items()}).encode())
self._backend.write_blob(file_path, buf.getvalue())
def _write_instance_id_segmentation(self, data: dict, render_product_path: str, annotator: str):
instance_seg_data = data[annotator]["data"]
height, width = instance_seg_data.shape[:2]
file_path = f"{render_product_path}instance_id_segmentation_{self._sequence_id}{self._frame_id:0}.png"
if self.colorize_instance_id_segmentation:
instance_seg_data = instance_seg_data.view(
np.uint8).reshape(height, width, -1)
self._backend.write_image(file_path, instance_seg_data)
else:
instance_seg_data = instance_seg_data.view(
np.uint32).reshape(height, width)
self._backend.write_image(file_path, instance_seg_data)
id_to_labels = data[annotator]["info"]["idToLabels"]
file_path = f"{render_product_path}instance_id_segmentation_mapping_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(
{str(k): v for k, v in id_to_labels.items()}).encode())
self._backend.write_blob(file_path, buf.getvalue())
def _write_instance_segmentation(self, data: dict, render_product_path: str, annotator: str):
instance_seg_data = data[annotator]["data"]
height, width = instance_seg_data.shape[:2]
file_path = (
f"{render_product_path}instance_segmentation_{self._sequence_id}{self._frame_id:0}.png"
)
if self.colorize_instance_segmentation:
instance_seg_data = instance_seg_data.view(
np.uint8).reshape(height, width, -1)
self._backend.write_image(file_path, instance_seg_data)
else:
instance_seg_data = instance_seg_data.view(
np.uint32).reshape(height, width)
self._backend.write_image(file_path, instance_seg_data)
id_to_labels = data[annotator]["info"]["idToLabels"]
file_path = f"{render_product_path}instance_segmentation_mapping_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(
{str(k): v for k, v in id_to_labels.items()}).encode())
self._backend.write_blob(file_path, buf.getvalue())
id_to_semantics = data[annotator]["info"]["idToSemantics"]
file_path = f"{render_product_path}instance_segmentation_semantics_mapping_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(
{str(k): v for k, v in id_to_semantics.items()}).encode())
self._backend.write_blob(file_path, buf.getvalue())
def _write_bounding_box_data(self, data: dict, bbox_type: str, render_product_path: str, annotator: str):
bbox_data_all = data[annotator]["data"]
print(bbox_data_all)
id_to_labels = data[annotator]["info"]["idToLabels"]
prim_paths = data[annotator]["info"]["primPaths"]
file_path = f"{render_product_path}bounding_box_{bbox_type}_{self._sequence_id}{self._frame_id:0}.npy"
buf = io.BytesIO()
np.save(buf, bbox_data_all)
self._backend.write_blob(file_path, buf.getvalue())
labels_file_path = f"{render_product_path}bounding_box_{bbox_type}_labels_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(id_to_labels).encode())
self._backend.write_blob(labels_file_path, buf.getvalue())
labels_file_path = f"{render_product_path}bounding_box_{bbox_type}_prim_paths_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(prim_paths).encode())
self._backend.write_blob(labels_file_path, buf.getvalue())
target_coco_bbox_data = []
count = 0
for bbox_data in bbox_data_all:
target_bbox_data = {'x_min': bbox_data['x_min'], 'y_min': bbox_data['y_min'],
'x_max': bbox_data['x_max'], 'y_max': bbox_data['y_max']}
width = int(
abs(target_bbox_data["x_max"] - target_bbox_data["x_min"]))
height = int(
abs(target_bbox_data["y_max"] - target_bbox_data["y_min"]))
if width != 2147483647 and height != 2147483647:
# filepath = f"rgb_{self._frame_id}.{self._image_output_format}"
# self._backend.write_image(filepath, data["rgb"])
bbox_filepath = f"bbox_{self._frame_id}.txt"
coco_bbox_data = {
"name": prim_paths[count],
"x_min": int(target_bbox_data["x_min"]),
"y_min": int(target_bbox_data["y_min"]),
"x_max": int(target_bbox_data["x_max"]),
"y_max": int(target_bbox_data["y_max"]),
"width": width,
"height": height}
target_coco_bbox_data.append(coco_bbox_data)
count += 1
buf = io.BytesIO()
buf.write(json.dumps(target_coco_bbox_data).encode())
self._backend.write_blob(bbox_filepath, buf.getvalue())
rep.WriterRegistry.register(CowWriter)
camera_positions = [(1720, -1220, 200), (3300, -1220, 200),
(3300, -3500, 200), (1720, -3500, 200)]
# Attach Render Product
with rep.new_layer():
camera = rep.create.camera()
render_product = rep.create.render_product(camera, (1280, 1280))
# Randomizer Function
def randomize_cows1():
cows = rep.get.prims(semantics=[('class', 'cow_1')])
with cows:
rep.modify.visibility(rep.distribution.choice([True, False]))
return cows.node
rep.randomizer.register(randomize_cows1)
def randomize_cows2():
cows = rep.get.prims(semantics=[('class', 'cow_2')])
with cows:
rep.modify.visibility(rep.distribution.choice([True, False]))
return cows.node
rep.randomizer.register(randomize_cows2)
def randomize_cows3():
cows = rep.get.prims(semantics=[('class', 'cow_3')])
with cows:
rep.modify.visibility(rep.distribution.choice([True, False]))
return cows.node
rep.randomizer.register(randomize_cows3)
def randomize_cows4():
cows = rep.get.prims(semantics=[('class', 'cow_4')])
with cows:
rep.modify.visibility(rep.distribution.choice([True, False]))
return cows.node
rep.randomizer.register(randomize_cows4)
def randomize_environment():
envs = ["omniverse://localhost/NVIDIA/Assets/Skies/Clear/noon_grass_4k.hdr",
"omniverse://localhost/NVIDIA/Assets/Skies/Night/moonlit_golf_4k.hdr",
"omniverse://localhost/NVIDIA/Assets/Skies/Storm/approaching_storm_4k.hdr"]
lights = rep.create.light(
light_type = "Dome",
position = (2500, -2300, 0),
intensity = rep.distribution.choice([1., 10., 100., 1000.]),
texture = rep.distribution.choice(envs)
)
return lights.node
rep.randomizer.register(randomize_environment)
# Trigger to call randomizer
with rep.trigger.on_frame(num_frames=10):
with camera:
rep.modify.pose(position=rep.distribution.choice(
camera_positions), look_at=(2500, -2300, 0))
rep.randomizer.randomize_environment()
rep.randomizer.randomize_cows1()
rep.randomizer.randomize_cows2()
rep.randomizer.randomize_cows3()
rep.randomizer.randomize_cows4()
writer = rep.WriterRegistry.get('BasicWriter')
writer.initialize(output_dir='C:/Users/anura/Desktop/IndoorRanch_ReplicatorOutputs/NewRun1',
rgb=True, bounding_box_2d_tight=True)
writer.attach([render_product])
| 15,455 | Python | 35.8 | 129 | 0.581171 |
An-u-rag/synthetic-visual-dataset-generation/ReplicatorScripts/CowWriter_COCO.py | import io
import json
import time
import asyncio
from typing import List
import omni.kit
import omni.usd
import omni.replicator.core as rep
import numpy as np
from omni.replicator.core import AnnotatorRegistry, BackendDispatch, Writer, WriterRegistry, orchestrator
from omni.syntheticdata.scripts.SyntheticData import SyntheticData
class CowWriter(Writer):
def __init__(
self,
output_dir: str,
semantic_types: List[str] = None,
rgb: bool = True,
bounding_box_2d_tight: bool = False,
bounding_box_2d_loose: bool = False,
semantic_segmentation: bool = False,
instance_id_segmentation: bool = False,
instance_segmentation: bool = False,
distance_to_camera: bool = False,
bounding_box_3d: bool = False,
image_output_format: str = "png",
):
self._output_dir = output_dir
self._backend = BackendDispatch({"paths": {"out_dir": output_dir}})
self._frame_id = 0
self._sequence_id = 0
self._image_output_format = image_output_format
self._output_data_format = {}
self.annotators = []
if semantic_types is None:
semantic_types = ["class"]
# RGB
if rgb:
self.annotators.append(AnnotatorRegistry.get_annotator("rgb"))
# Bounding Box 2D
if bounding_box_2d_tight:
self.annotators.append(
AnnotatorRegistry.get_annotator("bounding_box_2d_tight", init_params={
"semanticTypes": semantic_types})
)
if bounding_box_2d_loose:
self.annotators.append(
AnnotatorRegistry.get_annotator("bounding_box_2d_loose", init_params={
"semanticTypes": semantic_types})
)
# Semantic Segmentation
if semantic_segmentation:
self.annotators.append(
AnnotatorRegistry.get_annotator(
"semantic_segmentation",
init_params={"semanticTypes": semantic_types},
)
)
# Instance Segmentation
if instance_id_segmentation:
self.annotators.append(
AnnotatorRegistry.get_annotator(
"instance_id_segmentation", init_params={}
)
)
# Instance Segmentation
if instance_segmentation:
self.annotators.append(
AnnotatorRegistry.get_annotator(
"instance_segmentation",
init_params={"semanticTypes": semantic_types},
)
)
# Depth
if distance_to_camera:
self.annotators.append(
AnnotatorRegistry.get_annotator("distance_to_camera"))
# Bounding Box 3D
if bounding_box_3d:
self.annotators.append(
AnnotatorRegistry.get_annotator("bounding_box_3d", init_params={
"semanticTypes": semantic_types})
)
def write(self, data: dict):
sequence_id = ""
for trigger_name, call_count in data["trigger_outputs"].items():
if "on_time" in trigger_name:
sequence_id = f"{call_count}_{sequence_id}"
if sequence_id != self._sequence_id:
self._frame_id = 0
self._sequence_id = sequence_id
for annotator in data.keys():
annotator_split = annotator.split("-")
render_product_path = ""
multi_render_prod = 0
if len(annotator_split) > 1:
multi_render_prod = 1
render_product_name = annotator_split[-1]
render_product_path = f"{render_product_name}/"
if annotator.startswith("rgb"):
if multi_render_prod:
render_product_path += "rgb/"
self._write_rgb(data, render_product_path, annotator)
if annotator.startswith("distance_to_camera"):
if multi_render_prod:
render_product_path += "distance_to_camera/"
self._write_distance_to_camera(
data, render_product_path, annotator)
if annotator.startswith("semantic_segmentation"):
if multi_render_prod:
render_product_path += "semantic_segmentation/"
self._write_semantic_segmentation(
data, render_product_path, annotator)
if annotator.startswith("instance_id_segmentation"):
if multi_render_prod:
render_product_path += "instance_id_segmentation/"
self._write_instance_id_segmentation(
data, render_product_path, annotator)
if annotator.startswith("instance_segmentation"):
if multi_render_prod:
render_product_path += "instance_segmentation/"
self._write_instance_segmentation(
data, render_product_path, annotator)
if annotator.startswith("bounding_box_3d"):
if multi_render_prod:
render_product_path += "bounding_box_3d/"
self._write_bounding_box_data(
data, "3d", render_product_path, annotator)
if annotator.startswith("bounding_box_2d_loose"):
if multi_render_prod:
render_product_path += "bounding_box_2d_loose/"
self._write_bounding_box_data(
data, "2d_loose", render_product_path, annotator)
if annotator.startswith("bounding_box_2d_tight"):
if multi_render_prod:
render_product_path += "bounding_box_2d_tight/"
self._write_bounding_box_data(
data, "2d_tight", render_product_path, annotator)
self._frame_id += 1
def _write_rgb(self, data: dict, render_product_path: str, annotator: str):
file_path = f"{render_product_path}rgb_{self._sequence_id}{self._frame_id:0}.{self._image_output_format}"
self._backend.write_image(file_path, data[annotator])
def _write_distance_to_camera(self, data: dict, render_product_path: str, annotator: str):
dist_to_cam_data = data[annotator]
file_path = (
f"{render_product_path}distance_to_camera_{self._sequence_id}{self._frame_id:0}.npy"
)
buf = io.BytesIO()
np.save(buf, dist_to_cam_data)
self._backend.write_blob(file_path, buf.getvalue())
def _write_semantic_segmentation(self, data: dict, render_product_path: str, annotator: str):
semantic_seg_data = data[annotator]["data"]
height, width = semantic_seg_data.shape[:2]
file_path = (
f"{render_product_path}semantic_segmentation_{self._sequence_id}{self._frame_id:0}.png"
)
if self.colorize_semantic_segmentation:
semantic_seg_data = semantic_seg_data.view(
np.uint8).reshape(height, width, -1)
self._backend.write_image(file_path, semantic_seg_data)
else:
semantic_seg_data = semantic_seg_data.view(
np.uint32).reshape(height, width)
self._backend.write_image(file_path, semantic_seg_data)
id_to_labels = data[annotator]["info"]["idToLabels"]
file_path = f"{render_product_path}semantic_segmentation_labels_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(
{str(k): v for k, v in id_to_labels.items()}).encode())
self._backend.write_blob(file_path, buf.getvalue())
def _write_instance_id_segmentation(self, data: dict, render_product_path: str, annotator: str):
instance_seg_data = data[annotator]["data"]
height, width = instance_seg_data.shape[:2]
file_path = f"{render_product_path}instance_id_segmentation_{self._sequence_id}{self._frame_id:0}.png"
if self.colorize_instance_id_segmentation:
instance_seg_data = instance_seg_data.view(
np.uint8).reshape(height, width, -1)
self._backend.write_image(file_path, instance_seg_data)
else:
instance_seg_data = instance_seg_data.view(
np.uint32).reshape(height, width)
self._backend.write_image(file_path, instance_seg_data)
id_to_labels = data[annotator]["info"]["idToLabels"]
file_path = f"{render_product_path}instance_id_segmentation_mapping_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(
{str(k): v for k, v in id_to_labels.items()}).encode())
self._backend.write_blob(file_path, buf.getvalue())
def _write_instance_segmentation(self, data: dict, render_product_path: str, annotator: str):
instance_seg_data = data[annotator]["data"]
height, width = instance_seg_data.shape[:2]
file_path = (
f"{render_product_path}instance_segmentation_{self._sequence_id}{self._frame_id:0}.png"
)
if self.colorize_instance_segmentation:
instance_seg_data = instance_seg_data.view(
np.uint8).reshape(height, width, -1)
self._backend.write_image(file_path, instance_seg_data)
else:
instance_seg_data = instance_seg_data.view(
np.uint32).reshape(height, width)
self._backend.write_image(file_path, instance_seg_data)
id_to_labels = data[annotator]["info"]["idToLabels"]
file_path = f"{render_product_path}instance_segmentation_mapping_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(
{str(k): v for k, v in id_to_labels.items()}).encode())
self._backend.write_blob(file_path, buf.getvalue())
id_to_semantics = data[annotator]["info"]["idToSemantics"]
file_path = f"{render_product_path}instance_segmentation_semantics_mapping_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(
{str(k): v for k, v in id_to_semantics.items()}).encode())
self._backend.write_blob(file_path, buf.getvalue())
def _write_bounding_box_data(self, data: dict, bbox_type: str, render_product_path: str, annotator: str):
bbox_data_all = data[annotator]["data"]
print(bbox_data_all)
id_to_labels = data[annotator]["info"]["idToLabels"]
prim_paths = data[annotator]["info"]["primPaths"]
file_path = f"{render_product_path}bounding_box_{bbox_type}_{self._sequence_id}{self._frame_id:0}.npy"
buf = io.BytesIO()
np.save(buf, bbox_data_all)
self._backend.write_blob(file_path, buf.getvalue())
labels_file_path = f"{render_product_path}bounding_box_{bbox_type}_labels_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(id_to_labels).encode())
self._backend.write_blob(labels_file_path, buf.getvalue())
labels_file_path = f"{render_product_path}bounding_box_{bbox_type}_prim_paths_{self._sequence_id}{self._frame_id:0}.json"
buf = io.BytesIO()
buf.write(json.dumps(prim_paths).encode())
self._backend.write_blob(labels_file_path, buf.getvalue())
target_coco_bbox_data = []
count = 0
for bbox_data in bbox_data_all:
target_bbox_data = {'x_min': bbox_data['x_min'], 'y_min': bbox_data['y_min'],
'x_max': bbox_data['x_max'], 'y_max': bbox_data['y_max']}
width = int(
abs(target_bbox_data["x_max"] - target_bbox_data["x_min"]))
height = int(
abs(target_bbox_data["y_max"] - target_bbox_data["y_min"]))
if width != 2147483647 and height != 2147483647:
bbox_filepath = f"bbox_{self._frame_id}.json"
coco_bbox_data = {
"name": prim_paths[count],
"x_min": int(target_bbox_data["x_min"]),
"y_min": int(target_bbox_data["y_min"]),
"x_max": int(target_bbox_data["x_max"]),
"y_max": int(target_bbox_data["y_max"]),
"width": width,
"height": height}
target_coco_bbox_data.append(coco_bbox_data)
count += 1
buf = io.BytesIO()
buf.write(json.dumps(target_coco_bbox_data).encode())
self._backend.write_blob(bbox_filepath, buf.getvalue())
rep.WriterRegistry.register(CowWriter)
| 12,859 | Python | 41.442244 | 129 | 0.565674 |
CesiumGS/cesium-omniverse/copy-python-path-for-vs.py | from os import getcwd
from os.path import exists
import json
from textwrap import indent
from jsmin import jsmin
#
# Note: This requires JSMin to be installed since the vscode workspace files have Comments in them.
# You can install JSMin by just installing it globally via pip.
#
# Also Note: You may need to run Visual Studio and open a Python file before running this script.
#
cwd_path = getcwd()
root_path = f"{cwd_path}/extern/nvidia/app"
vs_code_workspace_file_path = f"{cwd_path}/.vscode/cesium-omniverse-windows.code-workspace"
vs_python_settings_file_path = f"{cwd_path}/.vs/PythonSettings.json"
if not exists(root_path):
print(f"Could not find {root_path}")
exit(1)
if not exists(vs_code_workspace_file_path):
print(f"Could not find {vs_code_workspace_file_path}")
exit(1)
if not exists(vs_python_settings_file_path):
print(f"Could not find {vs_python_settings_file_path}")
exit(1)
print(f"Using root path: {root_path}")
print(f"Using vs code workspace file: {vs_code_workspace_file_path}")
print(f"Using vs PythonSettings file: {vs_python_settings_file_path}")
with open(vs_code_workspace_file_path) as fh:
m = jsmin(fh.read())
vs_code_workspace_file = json.loads(m)
def process_paths(path):
return path.replace("${workspaceFolder}", cwd_path).replace("/", "\\")
extra_paths = list(map(process_paths, vs_code_workspace_file["settings"]["python.analysis.extraPaths"]))
with open(vs_python_settings_file_path, 'r') as fh:
vs_python_settings = json.load(fh)
vs_python_settings["SearchPaths"] = extra_paths
# The read and write handles are split because we want to truncate the old file.
with open(vs_python_settings_file_path, 'w') as fh:
json.dump(vs_python_settings, fh, indent=2)
print(f"Wrote to {vs_python_settings_file_path}")
| 1,800 | Python | 32.981131 | 104 | 0.725556 |
CesiumGS/cesium-omniverse/CHANGES.md | # Change Log
### v0.19.0 - 2024-04-01
* Added scrollbar to main window UI.
* Fixed issue when loading tilesets with Cesium ion Self-Hosted in developer mode.
### v0.18.0 - 2024-03-01
* **Breaking change:** removed deprecated properties `projectDefaultIonAccessToken` and `projectDefaultIonAccessToken` from `CesiumDataPrim`. `CesiumIonServerPrim` should be used instead.
* Improved tile streaming performance by 35% by switching to UrlAssetAccessor from vsgCs.
* Added support for disk tile caching which improves streaming performance by 50% when reloading the same scene.
* Added support for Web Map Service (WMS) raster overlays.
* Added support for Tile Map Service (TMS) raster overlays.
* Added support for Web Map Tile Service (WMTS) raster overlays.
* Added raster overlay options: `maximumScreenSpaceError`, `maximumTextureSize`, `maximumSimultaneousTileLoads`, `subTileCacheBytes`.
* Added ability to bypass downloading of tiles clipped by a cartographic polygon raster overlay.
* Added support for globe anchors on non-georeferenced tilesets.
* Fixed crash when disabling and re-enabling the extension.
* Fixed crash when setting certain `/Cesium` debug options at runtime.
* Fixed crash when updating tilesets shader inputs.
* Fixed crash when removing USD prims in certain order.
* Fixed issue where Cesium ion session would not resume on reload.
* Fixed issue where save stage dialog would appear when reloading Fabric stage at startup.
* Fixed issue where zooming to tileset extents would not work correctly with non-identity transformation.
* Fixed issue where globe anchors didn't work with `xformOp:orient`.
* The movie capture tool now waits for tilesets to complete loading before it captures a frame.
### v0.17.0 - 2024-02-01
* **Breaking changes for globe anchors:**
* Removed `anchor_xform_at_path`. Globe anchors can now be created directly in USD.
* Split `cesium:anchor:geographicCoordinates` into separate properties: `cesium:anchor:latitude`, `cesium:anchor:longitude`, `cesium:anchor:height`.
* Globe anchors no longer add a `transform:cesium` op to the attached prim. Instead the `translate`, `rotateXYZ`, and `scale` ops are modified directly.
* Removed `cesium:anchor:rotation` and `cesium:anchor:scale`. Instead, use `UsdGeom.XformCommonAPI` to modify the globe anchor's local rotation and scale.
* Globe anchors now use the scene's default georeference if `cesium:georeferenceBinding` is empty.
* For migrating existing USD files, see https://github.com/CesiumGS/cesium-omniverse-samples/pull/13
* **Breaking changes for imagery layers:**
* `CesiumImagery` was renamed to `CesiumRasterOverlay` and is now an abstract class. To create ion raster overlays, use `CesiumIonRasterOverlay`.
* MDL changes: `cesium_imagery_layer_float4` was renamed to `cesium_raster_overlay_float4` and `imagery_layer_index` was renamed to `raster_overlay_index`.
* ion raster overlays now use the scene's default ion server if `cesium:ionServerBinding` is empty.
* **Breaking change for tilesets:**
* Tilesets must now reference raster overlays with `cesium:rasterOverlayBinding`.
* Tilesets now use the scene's default georeference if `cesium:georeferenceBinding` is empty.
* Tilesets now uses the scene's default ion server if `cesium:ionServerBinding` is empty.
* Added support for polygon-based clipping with `CesiumPolygonRasterOverlay`.
* Added ability for multiple tilesets referencing the same raster overlay.
* Added ability to reorder raster overlays in UI.
* Added context menu options for adding raster overlays to tilesets.
* Fixed multiple globe anchor related issues.
* Fixed excessive property warnings when using custom materials.
* Fixed adding raster overlays to selected tileset in the Add Assets UI.
* Fixed loading 3D Tiles 1.1 implicit tilesets.
### v0.16.0 - 2024-01-02
* Fixed issue where the current ion session would be signed out on reload.
* Fixed crash in Cesium Debugging window.
### v0.15.0 - 2023-12-14
* Added support for multiple Cesium ion servers by creating `CesiumIonServerPrim` prims.
### v0.14.0 - 2023-12-01
* Added support for `EXT_structural_metadata`. Property values can be accessed in material graph with the `cesium_property` nodes.
* Added support for `EXT_mesh_features`. Feature ID values can be accessed in material graph with the `cesium_feature_id_int` node.
* Added support for custom glTF vertex attributes. Attribute values can be accessed in material graph with the `data_lookup` nodes.
* Added support for changing a tileset's imagery layer dynamically in material graph.
### v0.13.0 - 2023-11-01
* Changing certain tileset properties no longer triggers a tileset reload.
* Added support for `displayColor` and `displayOpacity` for tileset prims.
* Fixed rendering point clouds with alpha values.
### v0.12.1 - 2023-10-26
* Fixed version numbers.
### v0.12.0 - 2023-10-25
* Added a quick add button for Google Photorealistic 3D Tiles through ion.
* Added support for globe anchors.
* Added support for multiple imagery layers.
* Added alpha property to imagery layers.
* Added support for reading textures and imagery layers in MDL.
* Added Cesium for Omniverse Python API, see the `cesium.omniverse.api` module.
* Fixed debug colors not working for tiles with vertex colors.
* Fixed hangs when loading tilesets by setting `omnihydra.parallelHydraSprimSync` to `false`.
* Basis Universal textures are now decoded to the native BCn texture format instead of RGBA8 in Kit 105.1 and above.
### v0.11.0 - 2023-10-02
* **Breaking change:** Cesium for Omniverse now requires Kit 105.1 or above (USD Composer 2023.2.0 or above).
* Reduced the number of materials created when loading un-textured tilesets.
* Added debug option `cesium:debug:disableGeoreferencing` to `CesiumDataPrim` to disable georeferencing and view tilesets in ECEF coordinates.
* Improvements to C++ testing infrastructure.
### v0.10.0 - 2023-09-01
* Improved error message if fetching tileset fails.
* Added basic point cloud support.
* Fixed loading extension in Omniverse Code 2023.1.1.
* Fixed crashes when reloading tileset.
* Fixed memory leak when removing tileset mid-load.
* Fixed several other bugs related to removing tilesets mid-load.
* Upgraded to cesium-native v0.26.0.
### v0.9.0 - 2023-08-01
* **Breaking change:** `CesiumTilesetPrim` now inherits from `UsdGeomGprim` instead of `UsdGeomBoundable`.
* Improved texture loading performance by moving texture loading to a worker thread.
* Improved performance when refining with parent tile's imagery by sharing the same texture instead of duplicating it.
* Added support for assigning materials to a tileset.
* Improved styling of credits.
* Visually enable/disable top bar buttons based on sign-in status.
* Fixed bug where not all Cesium windows would not appear in Windows menu.
### v0.8.0 - 2023-07-03
* **Breaking change:** Cesium for Omniverse now requires Kit 105 or above (USD Composer 2023.1.0 or above).
* **Breaking change:** broke out georeference attributes from `CesiumDataPrim` into dedicated `CesiumGeoreferencePrim` class.
* **Breaking change:** `CesiumTilesetPrim` is now a concrete type that inherits from `UsdGeomBoundable`.
* **Breaking change:** `CesiumTilesetPrim` now has an explicit binding to a `CesiumGeoreferencePrim`.
* **Breaking change:** default values for attributes are no longer written out when saved as `.usd` files.
* Added ability to zoom to extents on tilesets.
* Added vertex color support.
* Added `cesium.omniverse.TILESET_LOADED` Carbonite event.
* Added more statistics to the Cesium Debugging window.
* Fixed holes when camera is moving.
* Fixed orphaned tiles.
* Fixed credit parsing issue.
* Improved performance when refining with parent tile's imagery.
* Improved performance when creating Fabric geometry.
* Switched base material to `gltf/pbr.mdl`.
### v0.7.0 - 2023-06-01
* Set better default values when loading glTFs with the `KHR_materials_unlit` extension. This improves the visual quality of Google 3D Tiles.
* Improved installation process by forcing application reload when Cesium for Omniverse is first enabled.
* Changed material loading color from red to black.
* Added `/CesiumSession` prim for storing ephemeral state in the Session Layer, including `ecefToUsdTransform`.
* Fixed credits not appearing on all viewports.
* Improved readability of debug statistics.
* Integrated Cesium Native's performance tracing utility.
* Updated to Cesium Native 0.24.0 which adds support for 3D Tiles 1.1 implicit tiling.
### v0.6.2 - 2023-05-19
* Added more rendering statistics to the Cesium Debugging window.
* Added debug options to the top-level `Cesium` prim.
* Fixed issue where `cesium:enableFrustumCulling` wasn't appearing in the USD schema UI.
* Fixed issue where some Fabric shader node prims were not being deleted.
### v0.6.1 - 2023-05-11
* Added `premake5.lua` to `cesium.omniverse` and `cesium.usd.plugins` to better support Kit templates.
* Fixed crash in the Cesium Debugging window when reloading a stage.
### v0.6.0 - 2023-05-04
* Added option to show credits on screen.
* Fixed issue where tileset traversal was happening on hidden tilesets.
* Fixed issue where tile render resources were not being released back into the Fabric mesh pool in certain cases.
* Fixed regression where the texture wrap mode was no longer clamping to edge.
### v0.5.0 - 2023-05-01
* Added material pool for better performance and to reduce texture/material loading artifacts.
* Added support for multiple viewports.
* Fixed red flashes when materials are loading.
* Fixed cyan flashes when textures are loading.
* Fixed adding imagery as base layer for existing tileset.
* Fixed Fabric types for `tilesetId` and `tileId`.
* Upgraded to cesium-native v0.23.0.
### v0.4.0 - 2023-04-03
* Fixed a crash when removing the last available access token for a tileset.
* Added search field to the asset window.
* Added placeholder token name in the create field of the token window.
* No longer printing "Error adding tileset and imagery to stage" when adding a tileset.
* Better handling of long names in the asset details panel.
* Upgraded to cesium-native v0.22.1.
### v0.3.0 - 2023-03-20
* Split the Cesium USD plugins into their own Kit extension.
* Added on-screen credits.
* Added modal dialog prompting the user to enable Fabric Scene Delegate.
* General cleanup before public release.
### v0.2.0 - 2023-03-16
* Fixed raster overlay refinement.
* Fixed a crash when removing tileset and imagery using the stage window.
* Fixed issues around loading pre-existing USD files.
* Now generating flat normals by default.
* Added property window widgets for the Cesium USD Schema attributes.
* Updated documentation.
* General cleanup.
### v0.1.0 - 2023-03-01
* The initial preview build of Cesium for Omniverse!
| 10,825 | Markdown | 51.299517 | 187 | 0.774503 |
CesiumGS/cesium-omniverse/pyproject.toml | [tool.black]
line-length = 118
target-version = ['py310']
include = '^/exts/cesium\.omniverse/cesium/.*\.pyi?$'
| 112 | TOML | 21.599996 | 53 | 0.669643 |
CesiumGS/cesium-omniverse/README.md | [](https://cesium.com/)
Cesium for Omniverse enables building 3D geospatial applications and experiences with 3D Tiles and open standards in NVIDIA Omniverse, a real-time 3D graphics collaboration development platform. Cesium for Omniverse is an extension for Omniverse's Kit-based applications such as USD Composer, a reference application for large-scale world building and advanced 3D scene composition of Universal Scene Description (USD)-based workflows, and Omniverse Code, an integrated development environment (IDE) for developers. Cesium for Omniverse enables developers to create geospatial and enterprise metaverse, simulations, digital twins, and other real-world applications in precise geospatial context and stream massive real-word 3D content.
By combining a high-accuracy full-scale WGS84 globe, open APIs and open standards for spatial indexing such as 3D Tiles, and cloud-based real-world content from [Cesium ion](https://cesium.com/cesium-ion) with Omniverse, this extension enables rich 3D geospatial workflows and applications in Omniverse, which adds real-time ray tracing and AI-powered analytics.
[Cesium for Omniverse Homepage](https://cesium.com/platform/cesium-for-omniverse?utm_source=github&utm_medium=github&utm_campaign=omniverse)
### :rocket: Get Started
**[Download Cesium for Omniverse](https://github.com/CesiumGS/cesium-omniverse/releases/latest)**
**[Follow the Quickstart](https://cesium.com/learn/omniverse/omniverse-quickstart/)**
Have questions? Ask them on the [community forum](https://community.cesium.com/c/cesium-for-omniverse).
### :clap: Featured Demos
### :house_with_garden: Cesium for Omniverse and the 3D Geospatial Ecosystem
Cesium for Omniverse streams real-world 3D content such as high-resolution photogrammetry, terrain, imagery, and 3D buildings from [Cesium ion](https://cesium.com/cesium-ion) and other sources, available as optional commercial subscriptions. The extension includes Cesium ion integration for instant access to global high-resolution 3D content ready for runtime streaming. Cesium ion users can also leverage cloud-based 3D tiling pipelines to create end-to-end workflows to transform massive heterogenous content into semantically-rich 3D Tiles, ready for streaming to Omniverse.
Cesium for Omniverse supports cloud and private network content and services based on open standards and APIs. You are free to use any combination of supported content sources, standards, APIs with Cesium for Omniverse.
Using Cesium ion helps support Cesium for Omniverse development. :heart:
### :green_book: License
[Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0.html). Cesium for Omniverse is free for both commercial and non-commercial use.
### :computer: Developing Cesium for Omniverse
See the [Developer Setup Guide](docs/developer-setup/README.md) to learn how to set up a development environment for Cesium for Omniverse, allowing you to compile it, customize it, and contribute to its development.
| 3,262 | Markdown | 84.868419 | 735 | 0.806867 |
CesiumGS/cesium-omniverse/src/core/src/UrlAssetAccessor.cpp | /* <editor-fold desc="MIT License">
Copyright(c) 2023 Timothy Moore
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
</editor-fold> */
// Copyright 2024 CesiumGS, Inc. and Contributors
#include "cesium/omniverse/UrlAssetAccessor.h"
#include <CesiumAsync/IAssetResponse.h>
#include <CesiumUtility/Tracing.h>
#include <omni/kit/IApp.h>
#include <algorithm>
#include <cstring>
namespace cesium::omniverse {
const auto CURL_BUFFERSIZE = 3145728L; // 3 MiB
class UrlAssetResponse final : public CesiumAsync::IAssetResponse {
public:
uint16_t statusCode() const override {
return _statusCode;
}
std::string contentType() const override {
return _contentType;
}
const CesiumAsync::HttpHeaders& headers() const override {
return _headers;
}
gsl::span<const std::byte> data() const override {
return {const_cast<const std::byte*>(_result.data()), _result.size()};
}
static size_t headerCallback(char* buffer, size_t size, size_t nitems, void* userData);
static size_t dataCallback(char* buffer, size_t size, size_t nitems, void* userData);
void setCallbacks(CURL* curl);
uint16_t _statusCode = 0;
std::string _contentType;
CesiumAsync::HttpHeaders _headers;
std::vector<std::byte> _result;
};
class UrlAssetRequest final : public CesiumAsync::IAssetRequest {
public:
UrlAssetRequest(std::string method, std::string url, CesiumAsync::HttpHeaders headers)
: _method(std::move(method))
, _url(std::move(url))
, _headers(std::move(headers)) {}
UrlAssetRequest(
std::string method,
std::string url,
const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers)
: _method(std::move(method))
, _url(std::move(url)) {
_headers.insert(headers.begin(), headers.end());
const auto app = carb::getCachedInterface<omni::kit::IApp>();
const auto& buildInfo = app->getBuildInfo();
const auto platformInfo = app->getPlatformInfo();
_headers.insert({"X-Cesium-Client", "Cesium for Omniverse"});
_headers.insert(
{"X-Cesium-Client-Version", fmt::format("v{} {}", CESIUM_OMNI_VERSION, CESIUM_OMNI_GIT_HASH_ABBREVIATED)});
_headers.insert({"X-Cesium-Client-Engine", fmt::format("Kit SDK {}", buildInfo.kitVersion)});
_headers.insert({"X-Cesium-Client-OS", platformInfo.platform});
}
const std::string& method() const override {
return _method;
}
const std::string& url() const override {
return _url;
}
const CesiumAsync::HttpHeaders& headers() const override {
return _headers;
}
const CesiumAsync::IAssetResponse* response() const override {
return _response.get();
}
void setResponse(std::unique_ptr<UrlAssetResponse> response) {
_response = std::move(response);
}
private:
std::string _method;
std::string _url;
CesiumAsync::HttpHeaders _headers;
std::unique_ptr<UrlAssetResponse> _response;
};
size_t UrlAssetResponse::headerCallback(char* buffer, size_t size, size_t nitems, void* userData) {
// size is supposed to always be 1, but who knows
const size_t cnt = size * nitems;
auto* response = static_cast<UrlAssetResponse*>(userData);
if (!response) {
return cnt;
}
auto* colon = static_cast<char*>(std::memchr(buffer, ':', nitems));
if (colon) {
char* value = colon + 1;
auto* end = std::find(value, buffer + cnt, '\r');
while (value < end && *value == ' ') {
++value;
}
response->_headers.insert({std::string(buffer, colon), std::string(value, end)});
auto contentTypeItr = response->_headers.find("content-type");
if (contentTypeItr != response->_headers.end()) {
response->_contentType = contentTypeItr->second;
}
}
return cnt;
}
size_t UrlAssetResponse::dataCallback(char* buffer, size_t size, size_t nitems, void* userData) {
const size_t cnt = size * nitems;
auto* response = static_cast<UrlAssetResponse*>(userData);
if (!response) {
return cnt;
}
std::transform(buffer, buffer + cnt, std::back_inserter(response->_result), [](char c) {
return std::byte{static_cast<unsigned char>(c)};
});
return cnt;
}
} //namespace cesium::omniverse
extern "C" size_t headerCallback(char* buffer, size_t size, size_t nitems, void* userData) {
return cesium::omniverse::UrlAssetResponse::headerCallback(buffer, size, nitems, userData);
}
extern "C" size_t dataCallback(char* buffer, size_t size, size_t nitems, void* userData) {
return cesium::omniverse::UrlAssetResponse::dataCallback(buffer, size, nitems, userData);
}
namespace cesium::omniverse {
void UrlAssetResponse::setCallbacks(CURL* curl) {
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ::dataCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, ::headerCallback);
curl_easy_setopt(curl, CURLOPT_HEADERDATA, this);
}
UrlAssetAccessor::UrlAssetAccessor(const std::filesystem::path& certificatePath)
: userAgent("Mozilla/5.0 Cesium for Omniverse")
, _certificatePath(certificatePath.generic_string()) {
// XXX Do we need to worry about the thread safety problems with this?
curl_global_init(CURL_GLOBAL_ALL);
}
UrlAssetAccessor::~UrlAssetAccessor() {
curl_global_cleanup();
}
curl_slist*
UrlAssetAccessor::setCommonOptions(CURL* curl, const std::string& url, const CesiumAsync::HttpHeaders& headers) {
curl_easy_setopt(curl, CURLOPT_USERAGENT, userAgent.c_str());
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
if (!_certificatePath.empty()) {
curl_easy_setopt(curl, CURLOPT_CAINFO, _certificatePath.c_str());
} else {
curl_easy_setopt(curl, CURLOPT_SSL_OPTIONS, CURLSSLOPT_NATIVE_CA);
}
curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "");
curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, CURL_BUFFERSIZE);
curl_easy_setopt(curl, CURLOPT_MAXCONNECTS, 20L);
curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, 300L);
// curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_slist* list = nullptr;
for (const auto& header : headers) {
std::string fullHeader = header.first + ":" + header.second;
list = curl_slist_append(list, fullHeader.c_str());
}
if (list) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
}
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
return list;
}
// RAII wrapper for the CurlCache.
class CurlHandle {
public:
CurlHandle(UrlAssetAccessor* accessor_)
: _accessor(accessor_)
{
_curl = _accessor->curlCache.get();
}
~CurlHandle() {
_accessor->curlCache.release(_curl);
}
CURL* operator()() const {
return _curl;
}
private:
UrlAssetAccessor* _accessor;
CURL* _curl;
};
CesiumAsync::Future<std::shared_ptr<CesiumAsync::IAssetRequest>> UrlAssetAccessor::get(
const CesiumAsync::AsyncSystem& asyncSystem,
const std::string& url,
const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers) {
return asyncSystem.createFuture<std::shared_ptr<CesiumAsync::IAssetRequest>>([&](const auto& promise) {
std::shared_ptr<UrlAssetRequest> request = std::make_shared<UrlAssetRequest>("GET", url, headers);
asyncSystem.runInWorkerThread([promise, request, this]() {
CESIUM_TRACE("UrlAssetAccessor::get");
CurlHandle curl(this);
curl_slist* list = setCommonOptions(curl(), request->url(), request->headers());
std::unique_ptr<UrlAssetResponse> response = std::make_unique<UrlAssetResponse>();
response->setCallbacks(curl());
CURLcode responseCode = curl_easy_perform(curl());
curl_slist_free_all(list);
if (responseCode == 0) {
long httpResponseCode = 0;
curl_easy_getinfo(curl(), CURLINFO_RESPONSE_CODE, &httpResponseCode);
response->_statusCode = static_cast<uint16_t>(httpResponseCode);
// The response header callback also sets _contentType, so not sure that this is
// necessary...
char* ct = nullptr;
curl_easy_getinfo(curl(), CURLINFO_CONTENT_TYPE, &ct);
if (ct) {
response->_contentType = ct;
}
request->setResponse(std::move(response));
promise.resolve(request);
} else {
std::string curlMsg("curl: ");
curlMsg += curl_easy_strerror(responseCode);
promise.reject(std::runtime_error(curlMsg));
}
});
});
}
// request() with a verb and argument is essentially a POST
CesiumAsync::Future<std::shared_ptr<CesiumAsync::IAssetRequest>> UrlAssetAccessor::request(
const CesiumAsync::AsyncSystem& asyncSystem,
const std::string& verb,
const std::string& url,
const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers,
const gsl::span<const std::byte>& contentPayload) {
return asyncSystem.createFuture<std::shared_ptr<CesiumAsync::IAssetRequest>>([&](const auto& promise) {
auto request = std::make_shared<UrlAssetRequest>(verb, url, headers);
auto payloadCopy = std::make_shared<std::vector<std::byte>>(contentPayload.begin(), contentPayload.end());
asyncSystem.runInWorkerThread([promise, request, payloadCopy, this]() {
CESIUM_TRACE("UrlAssetAccessor::request");
CurlHandle curl(this);
curl_slist* list = setCommonOptions(curl(), request->url(), request->headers());
if (payloadCopy->size() > 1UL << 31) {
curl_easy_setopt(curl(), CURLOPT_POSTFIELDSIZE_LARGE, payloadCopy->size());
} else {
curl_easy_setopt(curl(), CURLOPT_POSTFIELDSIZE, payloadCopy->size());
}
curl_easy_setopt(curl(), CURLOPT_COPYPOSTFIELDS, reinterpret_cast<const char*>(payloadCopy->data()));
curl_easy_setopt(curl(), CURLOPT_CUSTOMREQUEST, request->method().c_str());
std::unique_ptr<UrlAssetResponse> response = std::make_unique<UrlAssetResponse>();
response->setCallbacks(curl());
CURLcode responseCode = curl_easy_perform(curl());
curl_slist_free_all(list);
if (responseCode == 0) {
long httpResponseCode = 0;
curl_easy_getinfo(curl(), CURLINFO_RESPONSE_CODE, &httpResponseCode);
response->_statusCode = static_cast<uint16_t>(httpResponseCode);
char* ct = nullptr;
curl_easy_getinfo(curl(), CURLINFO_CONTENT_TYPE, &ct);
if (ct) {
response->_contentType = ct;
}
request->setResponse(std::move(response));
promise.resolve(request);
} else {
std::string curlMsg("curl: ");
curlMsg += curl_easy_strerror(responseCode);
promise.reject(std::runtime_error(curlMsg));
}
});
});
}
void UrlAssetAccessor::tick() noexcept {}
} //namespace cesium::omniverse
| 12,288 | C++ | 37.88924 | 119 | 0.645182 |
CesiumGS/cesium-omniverse/src/core/src/FabricPrepareRenderResources.cpp | #include "cesium/omniverse/FabricPrepareRenderResources.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/CppUtil.h"
#include "cesium/omniverse/FabricFeaturesInfo.h"
#include "cesium/omniverse/FabricFeaturesUtil.h"
#include "cesium/omniverse/FabricGeometry.h"
#include "cesium/omniverse/FabricMaterial.h"
#include "cesium/omniverse/FabricMesh.h"
#include "cesium/omniverse/FabricRasterOverlaysInfo.h"
#include "cesium/omniverse/FabricRenderResources.h"
#include "cesium/omniverse/FabricResourceManager.h"
#include "cesium/omniverse/FabricTexture.h"
#include "cesium/omniverse/FabricTextureData.h"
#include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/MetadataUtil.h"
#include "cesium/omniverse/OmniRasterOverlay.h"
#include "cesium/omniverse/OmniTileset.h"
#include "cesium/omniverse/UsdUtil.h"
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <Cesium3DTilesSelection/Tile.h>
#include <Cesium3DTilesSelection/Tileset.h>
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumGltfContent/GltfUtilities.h>
#include <omni/fabric/FabricUSD.h>
#include <omni/ui/ImageProvider/DynamicTextureProvider.h>
namespace cesium::omniverse {
namespace {
struct RasterOverlayLoadThreadResult {
std::shared_ptr<FabricTexture> pTexture;
};
struct RasterOverlayRenderResources {
std::shared_ptr<FabricTexture> pTexture;
};
struct LoadingMesh {
const glm::dmat4 gltfLocalToEcefTransform;
const uint64_t gltfMeshIndex;
const uint64_t gltfPrimitiveIndex;
};
struct TileLoadThreadResult {
std::vector<LoadingMesh> loadingMeshes;
std::vector<FabricMesh> fabricMeshes;
};
uint64_t getFeatureIdTextureCount(const FabricFeaturesInfo& fabricFeaturesInfo) {
return CppUtil::countIf(fabricFeaturesInfo.featureIds, [](const auto& featureId) {
return std::holds_alternative<FabricTextureInfo>(featureId.featureIdStorage);
});
}
std::vector<LoadingMesh> getLoadingMeshes(const glm::dmat4& tileToEcefTransform, const CesiumGltf::Model& model) {
CESIUM_TRACE("FabricPrepareRenderResources::getLoadingMeshes");
auto gltfWorldToTileTransform = glm::dmat4(1.0);
gltfWorldToTileTransform = CesiumGltfContent::GltfUtilities::applyRtcCenter(model, gltfWorldToTileTransform);
gltfWorldToTileTransform =
CesiumGltfContent::GltfUtilities::applyGltfUpAxisTransform(model, gltfWorldToTileTransform);
std::vector<LoadingMesh> loadingMeshes;
model.forEachPrimitiveInScene(
-1,
[&tileToEcefTransform, &gltfWorldToTileTransform, &loadingMeshes](
const CesiumGltf::Model& gltf,
[[maybe_unused]] const CesiumGltf::Node& node,
const CesiumGltf::Mesh& mesh,
const CesiumGltf::MeshPrimitive& primitive,
const glm::dmat4& gltfLocalToWorldTransform) {
const auto gltfMeshIndex = CppUtil::getIndexFromRef(gltf.meshes, mesh);
const auto gltfPrimitiveIndex = CppUtil::getIndexFromRef(mesh.primitives, primitive);
const auto gltfLocalToEcefTransform =
tileToEcefTransform * gltfWorldToTileTransform * gltfLocalToWorldTransform;
// In C++ 20 this can be emplace_back without the {}
loadingMeshes.push_back({
gltfLocalToEcefTransform,
gltfMeshIndex,
gltfPrimitiveIndex,
});
});
return loadingMeshes;
}
std::vector<FabricMesh> acquireFabricMeshes(
Context& context,
const CesiumGltf::Model& model,
const std::vector<LoadingMesh>& loadingMeshes,
const FabricRasterOverlaysInfo& rasterOverlaysInfo,
const OmniTileset& tileset) {
CESIUM_TRACE("FabricPrepareRenderResources::acquireFabricMeshes");
std::vector<FabricMesh> fabricMeshes;
fabricMeshes.reserve(loadingMeshes.size());
auto& fabricResourceManager = context.getFabricResourceManager();
const auto tilesetMaterialPath = tileset.getMaterialPath();
for (const auto& loadingMesh : loadingMeshes) {
auto& fabricMesh = fabricMeshes.emplace_back();
const auto& primitive = model.meshes[loadingMesh.gltfMeshIndex].primitives[loadingMesh.gltfPrimitiveIndex];
const auto materialInfo = GltfUtil::getMaterialInfo(model, primitive);
const auto featuresInfo = GltfUtil::getFeaturesInfo(model, primitive);
const auto shouldAcquireMaterial = fabricResourceManager.shouldAcquireMaterial(
primitive, rasterOverlaysInfo.overlayRenderMethods.size() > 0, tilesetMaterialPath);
fabricMesh.materialInfo = materialInfo;
fabricMesh.featuresInfo = featuresInfo;
fabricMesh.pGeometry =
fabricResourceManager.acquireGeometry(model, primitive, featuresInfo, tileset.getSmoothNormals());
if (shouldAcquireMaterial) {
fabricMesh.pMaterial = fabricResourceManager.acquireMaterial(
model,
primitive,
materialInfo,
featuresInfo,
rasterOverlaysInfo,
tileset.getTilesetId(),
tilesetMaterialPath);
}
if (materialInfo.baseColorTexture.has_value()) {
fabricMesh.pBaseColorTexture = fabricResourceManager.acquireTexture();
}
const auto featureIdTextureCount = getFeatureIdTextureCount(featuresInfo);
fabricMesh.featureIdTextures.reserve(featureIdTextureCount);
for (uint64_t i = 0; i < featureIdTextureCount; ++i) {
fabricMesh.featureIdTextures.push_back(fabricResourceManager.acquireTexture());
}
const auto propertyTextureCount = MetadataUtil::getPropertyTextureImages(context, model, primitive).size();
fabricMesh.propertyTextures.reserve(propertyTextureCount);
for (uint64_t i = 0; i < propertyTextureCount; ++i) {
fabricMesh.propertyTextures.push_back(fabricResourceManager.acquireTexture());
}
const auto propertyTableTextureCount = MetadataUtil::getPropertyTableTextureCount(context, model, primitive);
fabricMesh.propertyTableTextures.reserve(propertyTableTextureCount);
for (uint64_t i = 0; i < propertyTableTextureCount; ++i) {
fabricMesh.propertyTableTextures.push_back(fabricResourceManager.acquireTexture());
}
// Map glTF texcoord set index to primvar st index
const auto texcoordSetIndexes = GltfUtil::getTexcoordSetIndexes(model, primitive);
const auto rasterOverlayTexcoordSetIndexes = GltfUtil::getRasterOverlayTexcoordSetIndexes(model, primitive);
uint64_t primvarStIndex = 0;
for (const auto gltfSetIndex : texcoordSetIndexes) {
fabricMesh.texcoordIndexMapping[gltfSetIndex] = primvarStIndex++;
}
for (const auto gltfSetIndex : rasterOverlayTexcoordSetIndexes) {
fabricMesh.rasterOverlayTexcoordIndexMapping[gltfSetIndex] = primvarStIndex++;
}
// Map feature id types to set indexes
fabricMesh.featureIdIndexSetIndexMapping =
FabricFeaturesUtil::getSetIndexMapping(featuresInfo, FabricFeatureIdType::INDEX);
fabricMesh.featureIdAttributeSetIndexMapping =
FabricFeaturesUtil::getSetIndexMapping(featuresInfo, FabricFeatureIdType::ATTRIBUTE);
fabricMesh.featureIdTextureSetIndexMapping =
FabricFeaturesUtil::getSetIndexMapping(featuresInfo, FabricFeatureIdType::TEXTURE);
// Map glTF texture index to property texture (FabricTexture) index
fabricMesh.propertyTextureIndexMapping =
MetadataUtil::getPropertyTextureIndexMapping(context, model, primitive);
}
return fabricMeshes;
}
void setFabricTextures(
const Context& context,
const CesiumGltf::Model& model,
const std::vector<LoadingMesh>& loadingMeshes,
std::vector<FabricMesh>& fabricMeshes) {
CESIUM_TRACE("FabricPrepareRenderResources::setFabricTextures");
for (uint64_t i = 0; i < loadingMeshes.size(); ++i) {
const auto& loadingMesh = loadingMeshes[i];
const auto& primitive = model.meshes[loadingMesh.gltfMeshIndex].primitives[loadingMesh.gltfPrimitiveIndex];
auto& fabricMesh = fabricMeshes[i];
if (fabricMesh.pBaseColorTexture) {
const auto pBaseColorTextureImage = GltfUtil::getBaseColorTextureImage(model, primitive);
if (!pBaseColorTextureImage || context.getFabricResourceManager().getDisableTextures()) {
fabricMesh.pBaseColorTexture->setBytes(
{std::byte(255), std::byte(255), std::byte(255), std::byte(255)}, 1, 1, carb::Format::eRGBA8_SRGB);
} else {
fabricMesh.pBaseColorTexture->setImage(*pBaseColorTextureImage, TransferFunction::SRGB);
}
}
const auto featureIdTextureCount = fabricMesh.featureIdTextures.size();
for (uint64_t j = 0; j < featureIdTextureCount; ++j) {
const auto featureIdSetIndex = fabricMesh.featureIdTextureSetIndexMapping[j];
const auto pFeatureIdTextureImage = GltfUtil::getFeatureIdTextureImage(model, primitive, featureIdSetIndex);
if (!pFeatureIdTextureImage) {
fabricMesh.featureIdTextures[j]->setBytes(
{std::byte(0), std::byte(0), std::byte(0), std::byte(0)}, 1, 1, carb::Format::eRGBA8_SRGB);
} else {
fabricMesh.featureIdTextures[j]->setImage(*pFeatureIdTextureImage, TransferFunction::LINEAR);
}
}
const auto propertyTextureImages = MetadataUtil::getPropertyTextureImages(context, model, primitive);
const auto propertyTextureCount = fabricMesh.propertyTextures.size();
for (uint64_t j = 0; j < propertyTextureCount; ++j) {
fabricMesh.propertyTextures[j]->setImage(*propertyTextureImages[j], TransferFunction::LINEAR);
}
const auto propertyTableTextures = MetadataUtil::encodePropertyTables(context, model, primitive);
const auto propertyTableTextureCount = fabricMesh.propertyTableTextures.size();
for (uint64_t j = 0; j < propertyTableTextureCount; ++j) {
const auto& texture = propertyTableTextures[j];
fabricMesh.propertyTableTextures[j]->setBytes(texture.bytes, texture.width, texture.height, texture.format);
}
}
}
void setFabricMeshes(
const Context& context,
const CesiumGltf::Model& model,
const std::vector<LoadingMesh>& loadingMeshes,
std::vector<FabricMesh>& fabricMeshes,
const OmniTileset& tileset) {
CESIUM_TRACE("FabricPrepareRenderResources::setFabricMeshes");
const auto& tilesetMaterialPath = tileset.getMaterialPath();
const auto displayColor = tileset.getDisplayColor();
const auto displayOpacity = tileset.getDisplayOpacity();
const auto ecefToPrimWorldTransform =
UsdUtil::computeEcefToPrimWorldTransform(context, tileset.getResolvedGeoreferencePath(), tileset.getPath());
const auto tilesetId = tileset.getTilesetId();
const auto smoothNormals = tileset.getSmoothNormals();
for (uint64_t i = 0; i < loadingMeshes.size(); ++i) {
const auto& loadingMesh = loadingMeshes[i];
const auto& primitive = model.meshes[loadingMesh.gltfMeshIndex].primitives[loadingMesh.gltfPrimitiveIndex];
const auto& fabricMesh = fabricMeshes[i];
const auto pGeometry = fabricMesh.pGeometry;
const auto pMaterial = fabricMesh.pMaterial;
pGeometry->setGeometry(
tilesetId,
ecefToPrimWorldTransform,
loadingMesh.gltfLocalToEcefTransform,
model,
primitive,
fabricMesh.materialInfo,
smoothNormals,
fabricMesh.texcoordIndexMapping,
fabricMesh.rasterOverlayTexcoordIndexMapping);
if (pMaterial) {
pMaterial->setMaterial(
model,
primitive,
tilesetId,
fabricMesh.materialInfo,
fabricMesh.featuresInfo,
fabricMesh.pBaseColorTexture.get(),
fabricMesh.featureIdTextures,
fabricMesh.propertyTextures,
fabricMesh.propertyTableTextures,
displayColor,
displayOpacity,
fabricMesh.texcoordIndexMapping,
fabricMesh.featureIdIndexSetIndexMapping,
fabricMesh.featureIdAttributeSetIndexMapping,
fabricMesh.featureIdTextureSetIndexMapping,
fabricMesh.propertyTextureIndexMapping);
pGeometry->setMaterial(pMaterial->getPath());
} else if (!tilesetMaterialPath.IsEmpty()) {
pGeometry->setMaterial(FabricUtil::toFabricPath(tilesetMaterialPath));
}
}
}
void freeFabricMeshes(Context& context, const std::vector<FabricMesh>& fabricMeshes) {
auto& fabricResourceManager = context.getFabricResourceManager();
for (const auto& fabricMesh : fabricMeshes) {
if (fabricMesh.pGeometry) {
fabricResourceManager.releaseGeometry(fabricMesh.pGeometry);
}
if (fabricMesh.pMaterial) {
fabricResourceManager.releaseMaterial(fabricMesh.pMaterial);
}
if (fabricMesh.pBaseColorTexture) {
fabricResourceManager.releaseTexture(fabricMesh.pBaseColorTexture);
}
for (const auto& pFeatureIdTexture : fabricMesh.featureIdTextures) {
fabricResourceManager.releaseTexture(pFeatureIdTexture);
}
for (const auto& pPropertyTexture : fabricMesh.propertyTextures) {
fabricResourceManager.releaseTexture(pPropertyTexture);
}
for (const auto& pPropertyTableTexture : fabricMesh.propertyTableTextures) {
fabricResourceManager.releaseTexture(pPropertyTableTexture);
}
}
}
} // namespace
FabricPrepareRenderResources::FabricPrepareRenderResources(Context* pContext, OmniTileset* pTileset)
: _pContext(pContext)
, _pTileset(pTileset) {}
CesiumAsync::Future<Cesium3DTilesSelection::TileLoadResultAndRenderResources>
FabricPrepareRenderResources::prepareInLoadThread(
const CesiumAsync::AsyncSystem& asyncSystem,
Cesium3DTilesSelection::TileLoadResult&& tileLoadResult,
const glm::dmat4& tileToEcefTransform,
[[maybe_unused]] const std::any& rendererOptions) {
const auto pModel = std::get_if<CesiumGltf::Model>(&tileLoadResult.contentKind);
if (!pModel) {
return asyncSystem.createResolvedFuture(
Cesium3DTilesSelection::TileLoadResultAndRenderResources{std::move(tileLoadResult), nullptr});
}
if (!tilesetExists()) {
return asyncSystem.createResolvedFuture(
Cesium3DTilesSelection::TileLoadResultAndRenderResources{std::move(tileLoadResult), nullptr});
}
// We don't know how many raster overlays actually overlap this tile until attachRasterInMainThread is called
// but at least we have an upper bound. Unused texture slots are initialized with a 1x1 transparent pixel so
// blending still works.
const auto overlapsRasterOverlay = tileLoadResult.rasterOverlayDetails.has_value();
FabricRasterOverlaysInfo rasterOverlaysInfo;
if (overlapsRasterOverlay) {
for (const auto& rasterOverlayPath : _pTileset->getRasterOverlayPaths()) {
const auto& pRasterOverlay = _pContext->getAssetRegistry().getRasterOverlay(rasterOverlayPath);
const auto overlayRenderMethod =
pRasterOverlay ? pRasterOverlay->getOverlayRenderMethod() : FabricOverlayRenderMethod::OVERLAY;
rasterOverlaysInfo.overlayRenderMethods.push_back(overlayRenderMethod);
}
}
auto loadingMeshes = getLoadingMeshes(tileToEcefTransform, *pModel);
struct IntermediateLoadThreadResult {
Cesium3DTilesSelection::TileLoadResult tileLoadResult;
std::vector<LoadingMesh> loadingMeshes;
std::vector<FabricMesh> fabricMeshes;
};
return asyncSystem
.runInMainThread([this,
rasterOverlaysInfo = std::move(rasterOverlaysInfo),
loadingMeshes = std::move(loadingMeshes),
tileLoadResult = std::move(tileLoadResult)]() mutable {
if (!tilesetExists()) {
return IntermediateLoadThreadResult{
std::move(tileLoadResult),
{},
{},
};
}
const auto pModel = std::get_if<CesiumGltf::Model>(&tileLoadResult.contentKind);
auto fabricMeshes = acquireFabricMeshes(*_pContext, *pModel, loadingMeshes, rasterOverlaysInfo, *_pTileset);
return IntermediateLoadThreadResult{
std::move(tileLoadResult),
std::move(loadingMeshes),
std::move(fabricMeshes),
};
})
.thenInWorkerThread([this](IntermediateLoadThreadResult&& workerResult) mutable {
auto tileLoadResult = std::move(workerResult.tileLoadResult);
auto loadingMeshes = std::move(workerResult.loadingMeshes);
auto fabricMeshes = std::move(workerResult.fabricMeshes);
const auto pModel = std::get_if<CesiumGltf::Model>(&tileLoadResult.contentKind);
if (tilesetExists()) {
setFabricTextures(*_pContext, *pModel, loadingMeshes, fabricMeshes);
}
return Cesium3DTilesSelection::TileLoadResultAndRenderResources{
std::move(tileLoadResult),
new TileLoadThreadResult{
std::move(loadingMeshes),
std::move(fabricMeshes),
},
};
});
}
void* FabricPrepareRenderResources::prepareInMainThread(Cesium3DTilesSelection::Tile& tile, void* pLoadThreadResult) {
if (!pLoadThreadResult) {
return nullptr;
}
// Wrap in a unique_ptr so that pLoadThreadResult gets freed when this function returns
std::unique_ptr<TileLoadThreadResult> pTileLoadThreadResult(static_cast<TileLoadThreadResult*>(pLoadThreadResult));
const auto& loadingMeshes = pTileLoadThreadResult->loadingMeshes;
auto& fabricMeshes = pTileLoadThreadResult->fabricMeshes;
const auto& content = tile.getContent();
auto pRenderContent = content.getRenderContent();
if (!pRenderContent) {
return nullptr;
}
const auto& model = pRenderContent->getModel();
if (tilesetExists()) {
setFabricMeshes(*_pContext, model, loadingMeshes, fabricMeshes, *_pTileset);
}
return new FabricRenderResources{
std::move(fabricMeshes),
};
}
void FabricPrepareRenderResources::free(
[[maybe_unused]] Cesium3DTilesSelection::Tile& tile,
void* pLoadThreadResult,
void* pMainThreadResult) noexcept {
if (pLoadThreadResult) {
const auto pTileLoadThreadResult = static_cast<TileLoadThreadResult*>(pLoadThreadResult);
freeFabricMeshes(*_pContext, pTileLoadThreadResult->fabricMeshes);
delete pTileLoadThreadResult;
}
if (pMainThreadResult) {
const auto pFabricRenderResources = static_cast<FabricRenderResources*>(pMainThreadResult);
freeFabricMeshes(*_pContext, pFabricRenderResources->fabricMeshes);
delete pFabricRenderResources;
}
}
void* FabricPrepareRenderResources::prepareRasterInLoadThread(
CesiumGltf::ImageCesium& image,
[[maybe_unused]] const std::any& rendererOptions) {
if (!tilesetExists()) {
return nullptr;
}
const auto pTexture = _pContext->getFabricResourceManager().acquireTexture();
pTexture->setImage(image, TransferFunction::SRGB);
return new RasterOverlayLoadThreadResult{pTexture};
}
void* FabricPrepareRenderResources::prepareRasterInMainThread(
[[maybe_unused]] CesiumRasterOverlays::RasterOverlayTile& rasterTile,
void* pLoadThreadResult) {
if (!pLoadThreadResult) {
return nullptr;
}
// Wrap in a unique_ptr so that pLoadThreadResult gets freed when this function returns
std::unique_ptr<RasterOverlayLoadThreadResult> pRasterOverlayLoadThreadResult(
static_cast<RasterOverlayLoadThreadResult*>(pLoadThreadResult));
if (!tilesetExists()) {
return nullptr;
}
return new RasterOverlayRenderResources{pRasterOverlayLoadThreadResult->pTexture};
}
void FabricPrepareRenderResources::freeRaster(
[[maybe_unused]] const CesiumRasterOverlays::RasterOverlayTile& rasterTile,
void* pLoadThreadResult,
void* pMainThreadResult) noexcept {
if (pLoadThreadResult) {
const auto pRasterOverlayLoadThreadResult = static_cast<RasterOverlayLoadThreadResult*>(pLoadThreadResult);
_pContext->getFabricResourceManager().releaseTexture(pRasterOverlayLoadThreadResult->pTexture);
delete pRasterOverlayLoadThreadResult;
}
if (pMainThreadResult) {
const auto pRasterOverlayRenderResources = static_cast<RasterOverlayRenderResources*>(pMainThreadResult);
_pContext->getFabricResourceManager().releaseTexture(pRasterOverlayRenderResources->pTexture);
delete pRasterOverlayRenderResources;
}
}
void FabricPrepareRenderResources::attachRasterInMainThread(
const Cesium3DTilesSelection::Tile& tile,
int32_t overlayTextureCoordinateID,
[[maybe_unused]] const CesiumRasterOverlays::RasterOverlayTile& rasterTile,
void* pMainThreadRendererResources,
const glm::dvec2& translation,
const glm::dvec2& scale) {
auto pRasterOverlayRenderResources = static_cast<RasterOverlayRenderResources*>(pMainThreadRendererResources);
if (!pRasterOverlayRenderResources) {
return;
}
if (!tilesetExists()) {
return;
}
const auto pTexture = pRasterOverlayRenderResources->pTexture.get();
const auto& content = tile.getContent();
const auto pRenderContent = content.getRenderContent();
if (!pRenderContent) {
return;
}
const auto pFabricRenderResources = static_cast<FabricRenderResources*>(pRenderContent->getRenderResources());
if (!pFabricRenderResources) {
return;
}
const auto rasterOverlayPath = _pTileset->getRasterOverlayPathIfExists(rasterTile.getOverlay());
if (rasterOverlayPath.IsEmpty()) {
return;
}
const auto rasterOverlayPaths = _pTileset->getRasterOverlayPaths();
const auto rasterOverlayIndex = CppUtil::indexOf(_pTileset->getRasterOverlayPaths(), rasterOverlayPath);
if (rasterOverlayIndex == rasterOverlayPaths.size()) {
return;
}
const auto pRasterOverlay = _pContext->getAssetRegistry().getRasterOverlay(rasterOverlayPath);
if (!pRasterOverlay) {
return;
}
const auto alpha = glm::clamp(pRasterOverlay->getAlpha(), 0.0, 1.0);
for (const auto& fabricMesh : pFabricRenderResources->fabricMeshes) {
const auto pMaterial = fabricMesh.pMaterial;
if (pMaterial) {
const auto gltfSetIndex = static_cast<uint64_t>(overlayTextureCoordinateID);
const auto textureInfo = FabricTextureInfo{
translation,
0.0,
scale,
gltfSetIndex,
CesiumGltf::Sampler::WrapS::CLAMP_TO_EDGE,
CesiumGltf::Sampler::WrapT::CLAMP_TO_EDGE,
false,
{},
};
pMaterial->setRasterOverlay(
pTexture, textureInfo, rasterOverlayIndex, alpha, fabricMesh.rasterOverlayTexcoordIndexMapping);
}
}
}
void FabricPrepareRenderResources::detachRasterInMainThread(
const Cesium3DTilesSelection::Tile& tile,
[[maybe_unused]] int32_t overlayTextureCoordinateID,
const CesiumRasterOverlays::RasterOverlayTile& rasterTile,
[[maybe_unused]] void* pMainThreadRendererResources) noexcept {
const auto& content = tile.getContent();
const auto pRenderContent = content.getRenderContent();
if (!pRenderContent) {
return;
}
const auto pFabricRenderResources = static_cast<FabricRenderResources*>(pRenderContent->getRenderResources());
if (!pFabricRenderResources) {
return;
}
if (!tilesetExists()) {
return;
}
const auto rasterOverlayPath = _pTileset->getRasterOverlayPathIfExists(rasterTile.getOverlay());
if (rasterOverlayPath.IsEmpty()) {
return;
}
const auto rasterOverlayPaths = _pTileset->getRasterOverlayPaths();
const auto rasterOverlayIndex = CppUtil::indexOf(rasterOverlayPaths, rasterOverlayPath);
if (rasterOverlayIndex == rasterOverlayPaths.size()) {
return;
}
for (const auto& fabricMesh : pFabricRenderResources->fabricMeshes) {
const auto pMaterial = fabricMesh.pMaterial;
if (pMaterial) {
pMaterial->clearRasterOverlay(rasterOverlayIndex);
}
}
}
bool FabricPrepareRenderResources::tilesetExists() const {
// When a tileset is deleted there's a short period between the prim being deleted and TfNotice notifying us about the change.
// This function helps us know whether we should proceed with loading render resources.
return _pTileset && _pContext->hasUsdStage() && UsdUtil::primExists(_pContext->getUsdStage(), _pTileset->getPath());
}
void FabricPrepareRenderResources::detachTileset() {
_pTileset = nullptr;
}
} // namespace cesium::omniverse
| 25,459 | C++ | 39.094488 | 130 | 0.695196 |
CesiumGS/cesium-omniverse/src/core/src/Context.cpp | #include "cesium/omniverse/Context.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/CesiumIonServerManager.h"
#include "cesium/omniverse/FabricResourceManager.h"
#include "cesium/omniverse/FabricStatistics.h"
#include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/FilesystemUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/OmniData.h"
#include "cesium/omniverse/OmniIonRasterOverlay.h"
#include "cesium/omniverse/OmniTileset.h"
#include "cesium/omniverse/RenderStatistics.h"
#include "cesium/omniverse/SettingsWrapper.h"
#include "cesium/omniverse/TaskProcessor.h"
#include "cesium/omniverse/TilesetStatistics.h"
#include "cesium/omniverse/UrlAssetAccessor.h"
#include "cesium/omniverse/UsdNotificationHandler.h"
#include "cesium/omniverse/UsdUtil.h"
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <Cesium3DTilesContent/registerAllTileContentTypes.h>
#include <CesiumAsync/CachingAssetAccessor.h>
#include <CesiumAsync/SqliteCache.h>
#include <CesiumUtility/CreditSystem.h>
#include <omni/fabric/SimStageWithHistory.h>
#include <pxr/usd/sdf/path.h>
#include <pxr/usd/usdUtils/stageCache.h>
#include <chrono>
namespace cesium::omniverse {
namespace {
std::string getCacheDatabaseName() {
auto cacheDirPath = FilesystemUtil::getCesiumCacheDirectory();
if (!cacheDirPath.empty()) {
auto cacheFilePath = cacheDirPath / "cesium-request-cache.sqlite";
return cacheFilePath.generic_string();
}
return {};
}
std::shared_ptr<CesiumAsync::ICacheDatabase> makeCacheDatabase(const std::shared_ptr<Logger>& logger) {
uint64_t maxCacheItems = Settings::getMaxCacheItems();
if (maxCacheItems == 0) {
logger->oneTimeWarning("maxCacheItems set to 0, so disabling accessor cache");
return {};
} else if (auto dbName = getCacheDatabaseName(); !dbName.empty()) {
logger->oneTimeWarning(fmt::format("Cesium cache file: {}", dbName));
return std::make_shared<CesiumAsync::SqliteCache>(logger, dbName, maxCacheItems);
}
logger->oneTimeWarning("could not get name for cache database");
return {};
}
} // namespace
namespace {
uint64_t getSecondsSinceEpoch() {
const auto timePoint = std::chrono::system_clock::now();
return std::chrono::duration_cast<std::chrono::seconds>(timePoint.time_since_epoch()).count();
}
} // namespace
Context::Context(const std::filesystem::path& cesiumExtensionLocation)
: _cesiumExtensionLocation(cesiumExtensionLocation.lexically_normal())
, _certificatePath(_cesiumExtensionLocation / "certs" / "cacert.pem")
, _cesiumMdlPathToken(pxr::TfToken((_cesiumExtensionLocation / "mdl" / "cesium.mdl").generic_string()))
, _pTaskProcessor(std::make_shared<TaskProcessor>())
, _pAsyncSystem(std::make_unique<CesiumAsync::AsyncSystem>(_pTaskProcessor))
, _pLogger(std::make_shared<Logger>())
, _pCacheDatabase(makeCacheDatabase(_pLogger))
, _pCreditSystem(std::make_shared<CesiumUtility::CreditSystem>())
, _pAssetRegistry(std::make_unique<AssetRegistry>(this))
, _pFabricResourceManager(std::make_unique<FabricResourceManager>(this))
, _pCesiumIonServerManager(std::make_unique<CesiumIonServerManager>(this))
, _pUsdNotificationHandler(std::make_unique<UsdNotificationHandler>(this))
, _contextId(static_cast<int64_t>(getSecondsSinceEpoch())) {
if (_pCacheDatabase) {
_pAssetAccessor = std::make_shared<CesiumAsync::CachingAssetAccessor>(
_pLogger, std::make_shared<UrlAssetAccessor>(_certificatePath), _pCacheDatabase);
} else {
_pAssetAccessor = std::make_shared<UrlAssetAccessor>(_certificatePath);
}
Cesium3DTilesContent::registerAllTileContentTypes();
#if CESIUM_TRACING_ENABLED
const auto timeNow = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
const auto timeSinceEpoch = timeNow.time_since_epoch().count();
const auto path = cesiumExtensionLocation / fmt::format("cesium-trace-{}.json", timeSinceEpoch);
CESIUM_TRACE_INIT(path.string());
#endif
}
Context::~Context() {
clearStage();
CESIUM_TRACE_SHUTDOWN();
}
const std::filesystem::path& Context::getCesiumExtensionLocation() const {
return _cesiumExtensionLocation;
}
const std::filesystem::path& Context::getCertificatePath() const {
return _certificatePath;
}
const pxr::TfToken& Context::getCesiumMdlPathToken() const {
return _cesiumMdlPathToken;
}
std::shared_ptr<TaskProcessor> Context::getTaskProcessor() const {
return _pTaskProcessor;
}
const CesiumAsync::AsyncSystem& Context::getAsyncSystem() const {
return *_pAsyncSystem.get();
}
std::shared_ptr<CesiumAsync::IAssetAccessor> Context::getAssetAccessor() const {
return _pAssetAccessor;
}
std::shared_ptr<CesiumUtility::CreditSystem> Context::getCreditSystem() const {
return _pCreditSystem;
}
std::shared_ptr<Logger> Context::getLogger() const {
return _pLogger;
}
const AssetRegistry& Context::getAssetRegistry() const {
return *_pAssetRegistry.get();
}
AssetRegistry& Context::getAssetRegistry() {
return *_pAssetRegistry.get();
}
const FabricResourceManager& Context::getFabricResourceManager() const {
return *_pFabricResourceManager.get();
}
FabricResourceManager& Context::getFabricResourceManager() {
return *_pFabricResourceManager.get();
}
const CesiumIonServerManager& Context::getCesiumIonServerManager() const {
return *_pCesiumIonServerManager.get();
}
CesiumIonServerManager& Context::getCesiumIonServerManager() {
return *_pCesiumIonServerManager.get();
}
void Context::clearStage() {
// The order is important. Clear the asset registry first so that Fabric
// resources are released back into the pool. Then clear the pools.
_pAssetRegistry->clear();
_pFabricResourceManager->clear();
_pUsdNotificationHandler->clear();
}
void Context::reloadStage() {
clearStage();
// Populate the asset registry from prims already on the stage
_pUsdNotificationHandler->onStageLoaded();
// Update FabricResourceManager settings
auto pData = _pAssetRegistry->getFirstData();
if (pData) {
_pFabricResourceManager->setDisableMaterials(pData->getDebugDisableMaterials());
_pFabricResourceManager->setDisableTextures(pData->getDebugDisableTextures());
_pFabricResourceManager->setDisableGeometryPool(pData->getDebugDisableGeometryPool());
_pFabricResourceManager->setDisableMaterialPool(pData->getDebugDisableMaterialPool());
_pFabricResourceManager->setDisableTexturePool(pData->getDebugDisableTexturePool());
_pFabricResourceManager->setGeometryPoolInitialCapacity(pData->getDebugGeometryPoolInitialCapacity());
_pFabricResourceManager->setMaterialPoolInitialCapacity(pData->getDebugMaterialPoolInitialCapacity());
_pFabricResourceManager->setTexturePoolInitialCapacity(pData->getDebugTexturePoolInitialCapacity());
_pFabricResourceManager->setDebugRandomColors(pData->getDebugRandomColors());
}
}
void Context::clearAccessorCache() {
if (_pCacheDatabase) {
_pCacheDatabase->clearAll();
}
}
void Context::onUpdateFrame(const gsl::span<const Viewport>& viewports, bool waitForLoadingTiles) {
_pUsdNotificationHandler->onUpdateFrame();
_pAssetRegistry->onUpdateFrame(viewports, waitForLoadingTiles);
_pCesiumIonServerManager->onUpdateFrame();
}
void Context::onUsdStageChanged(int64_t usdStageId) {
if (_usdStageId == usdStageId) {
return;
}
// Remove references to the old stage
_pUsdStage = nullptr;
_pFabricStage = nullptr;
_usdStageId = 0;
// Now it's safe to clear anything else that references the old stage
clearStage();
if (usdStageId > 0) {
_pUsdStage =
pxr::UsdUtilsStageCache::Get().Find(pxr::UsdStageCache::Id::FromLongInt(static_cast<long>(usdStageId)));
const auto iFabricStage = carb::getCachedInterface<omni::fabric::IStageReaderWriter>();
const auto fabricStageId = iFabricStage->get(omni::fabric::UsdStageId(static_cast<uint64_t>(usdStageId)));
_pFabricStage = std::make_unique<omni::fabric::StageReaderWriter>(fabricStageId);
_usdStageId = usdStageId;
reloadStage();
}
}
const pxr::UsdStageWeakPtr& Context::getUsdStage() const {
return _pUsdStage;
}
pxr::UsdStageWeakPtr& Context::getUsdStage() {
return _pUsdStage;
}
int64_t Context::getUsdStageId() const {
return _usdStageId;
}
bool Context::hasUsdStage() const {
return getUsdStageId() != 0;
}
omni::fabric::StageReaderWriter& Context::getFabricStage() const {
return *_pFabricStage.get();
}
RenderStatistics Context::getRenderStatistics() const {
RenderStatistics renderStatistics;
if (!hasUsdStage()) {
return renderStatistics;
}
const auto fabricStatistics = FabricUtil::getStatistics(getFabricStage());
renderStatistics.materialsCapacity = fabricStatistics.materialsCapacity;
renderStatistics.materialsLoaded = fabricStatistics.materialsLoaded;
renderStatistics.geometriesCapacity = fabricStatistics.geometriesCapacity;
renderStatistics.geometriesLoaded = fabricStatistics.geometriesLoaded;
renderStatistics.geometriesRendered = fabricStatistics.geometriesRendered;
renderStatistics.trianglesLoaded = fabricStatistics.trianglesLoaded;
renderStatistics.trianglesRendered = fabricStatistics.trianglesRendered;
const auto& tilesets = _pAssetRegistry->getTilesets();
for (const auto& pTileset : tilesets) {
const auto tilesetStatistics = pTileset->getStatistics();
renderStatistics.tilesetCachedBytes += tilesetStatistics.tilesetCachedBytes;
renderStatistics.tilesVisited += tilesetStatistics.tilesVisited;
renderStatistics.culledTilesVisited += tilesetStatistics.culledTilesVisited;
renderStatistics.tilesRendered += tilesetStatistics.tilesRendered;
renderStatistics.tilesCulled += tilesetStatistics.tilesCulled;
renderStatistics.maxDepthVisited += tilesetStatistics.maxDepthVisited;
renderStatistics.tilesLoadingWorker += tilesetStatistics.tilesLoadingWorker;
renderStatistics.tilesLoadingMain += tilesetStatistics.tilesLoadingMain;
renderStatistics.tilesLoaded += tilesetStatistics.tilesLoaded;
}
return renderStatistics;
}
int64_t Context::getContextId() const {
// Creating a Fabric prim with the same path as a previously destroyed prim causes a crash.
// The contextId is randomly generated and ensures that Fabric prim paths are unique even across extension reloads.
return _contextId;
}
} // namespace cesium::omniverse
| 10,723 | C++ | 35.852234 | 119 | 0.743355 |
CesiumGS/cesium-omniverse/src/core/src/FabricGeometryPool.cpp | #include "cesium/omniverse/FabricGeometryPool.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/FabricVertexAttributeDescriptor.h"
#include "cesium/omniverse/GltfUtil.h"
#include <spdlog/fmt/fmt.h>
namespace cesium::omniverse {
FabricGeometryPool::FabricGeometryPool(
Context* pContext,
int64_t poolId,
const FabricGeometryDescriptor& geometryDescriptor,
uint64_t initialCapacity)
: ObjectPool<FabricGeometry>()
, _pContext(pContext)
, _poolId(poolId)
, _geometryDescriptor(geometryDescriptor) {
setCapacity(initialCapacity);
}
const FabricGeometryDescriptor& FabricGeometryPool::getGeometryDescriptor() const {
return _geometryDescriptor;
}
int64_t FabricGeometryPool::getPoolId() const {
return _poolId;
}
std::shared_ptr<FabricGeometry> FabricGeometryPool::createObject(uint64_t objectId) const {
const auto contextId = _pContext->getContextId();
const auto pathStr = fmt::format("/cesium_geometry_pool_{}_object_{}_context_{}", _poolId, objectId, contextId);
const auto path = omni::fabric::Path(pathStr.c_str());
return std::make_shared<FabricGeometry>(_pContext, path, _geometryDescriptor, _poolId);
}
void FabricGeometryPool::setActive(FabricGeometry* pGeometry, bool active) const {
pGeometry->setActive(active);
}
}; // namespace cesium::omniverse
| 1,348 | C++ | 30.372092 | 116 | 0.749258 |
CesiumGS/cesium-omniverse/src/core/src/MetadataUtil.cpp | #include "cesium/omniverse/MetadataUtil.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/DataType.h"
#include "cesium/omniverse/FabricPropertyDescriptor.h"
#include "cesium/omniverse/FabricTextureData.h"
namespace cesium::omniverse::MetadataUtil {
namespace {
const auto unsupportedPropertyCallbackNoop = []([[maybe_unused]] const std::string& propertyId,
[[maybe_unused]] const std::string& warning) {};
}
std::tuple<std::vector<FabricPropertyDescriptor>, std::map<std::string, std::string>> getStyleableProperties(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive) {
std::vector<FabricPropertyDescriptor> properties;
std::map<std::string, std::string> unsupportedPropertyWarnings;
const auto unsupportedPropertyCallback =
[&unsupportedPropertyWarnings](const std::string& propertyId, const std::string& warning) {
unsupportedPropertyWarnings.insert({propertyId, warning});
};
forEachStyleablePropertyAttributeProperty(
context,
model,
primitive,
[&properties](
const std::string& propertyId,
[[maybe_unused]] const auto& propertyAttributePropertyView,
const auto& property) {
constexpr auto type = std::decay_t<decltype(property)>::Type;
// In C++ 20 this can be emplace_back without the {}
properties.push_back({
FabricPropertyStorageType::ATTRIBUTE,
DataTypeUtil::getMdlInternalPropertyType<type>(),
propertyId,
0, // featureIdSetIndex not relevant for property attributes
});
},
unsupportedPropertyCallback);
forEachStyleablePropertyTextureProperty(
context,
model,
primitive,
[&properties](
const std::string& propertyId,
[[maybe_unused]] const auto& propertyTexturePropertyView,
const auto& property) {
constexpr auto type = std::decay_t<decltype(property)>::Type;
// In C++ 20 this can be emplace_back without the {}
properties.push_back({
FabricPropertyStorageType::TEXTURE,
DataTypeUtil::getMdlInternalPropertyType<type>(),
propertyId,
0, // featureIdSetIndex not relevant for property textures
});
},
unsupportedPropertyCallback);
forEachStyleablePropertyTableProperty(
context,
model,
primitive,
[&properties](
const std::string& propertyId,
[[maybe_unused]] const auto& propertyTablePropertyView,
const auto& property) {
constexpr auto type = std::decay_t<decltype(property)>::Type;
// In C++ 20 this can be emplace_back without the {}
properties.push_back({
FabricPropertyStorageType::TABLE,
DataTypeUtil::getMdlInternalPropertyType<type>(),
propertyId,
property.featureIdSetIndex,
});
},
unsupportedPropertyCallback);
// Sorting is important for checking FabricMaterialDescriptor equality
CppUtil::sort(properties, [](const auto& lhs, const auto& rhs) { return lhs.propertyId > rhs.propertyId; });
return {std::move(properties), std::move(unsupportedPropertyWarnings)};
}
std::vector<const CesiumGltf::ImageCesium*> getPropertyTextureImages(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive) {
std::vector<const CesiumGltf::ImageCesium*> images;
forEachStyleablePropertyTextureProperty(
context,
model,
primitive,
[&images](
[[maybe_unused]] const std::string& propertyId,
const auto& propertyTexturePropertyView,
[[maybe_unused]] const auto& property) {
const auto pImage = propertyTexturePropertyView.getImage();
assert(pImage); // Shouldn't have gotten this far if image is invalid
const auto imageIndex = CppUtil::indexOf(images, pImage);
if (imageIndex == images.size()) {
images.push_back(pImage);
}
},
unsupportedPropertyCallbackNoop);
return images;
}
std::unordered_map<uint64_t, uint64_t> getPropertyTextureIndexMapping(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive) {
std::vector<const CesiumGltf::ImageCesium*> images;
std::unordered_map<uint64_t, uint64_t> propertyTextureIndexMapping;
forEachStyleablePropertyTextureProperty(
context,
model,
primitive,
[&images, &propertyTextureIndexMapping](
[[maybe_unused]] const std::string& propertyId,
const auto& propertyTexturePropertyView,
[[maybe_unused]] const auto& property) {
const auto pImage = propertyTexturePropertyView.getImage();
assert(pImage); // Shouldn't have gotten this far if image is invalid
const auto imageIndex = CppUtil::indexOf(images, pImage);
if (imageIndex == images.size()) {
images.push_back(pImage);
}
const auto textureIndex = property.textureIndex;
propertyTextureIndexMapping[textureIndex] = imageIndex;
},
unsupportedPropertyCallbackNoop);
return propertyTextureIndexMapping;
}
std::vector<FabricTextureData> encodePropertyTables(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive) {
std::vector<FabricTextureData> textures;
forEachStyleablePropertyTableProperty(
context,
model,
primitive,
[&textures](
[[maybe_unused]] const std::string& propertyId,
const auto& propertyTablePropertyView,
const auto& property) {
constexpr auto type = std::decay_t<decltype(property)>::Type;
constexpr auto textureType = DataTypeUtil::getPropertyTableTextureType<type>();
constexpr auto textureFormat = DataTypeUtil::getTextureFormat<textureType>();
using TextureType = DataTypeUtil::GetNativeType<textureType>;
using TextureComponentType = DataTypeUtil::GetNativeType<DataTypeUtil::getComponentType<textureType>()>;
// The texture type should always be the same or larger type
static_assert(DataTypeUtil::getComponentCount<type>() <= DataTypeUtil::getComponentCount<textureType>());
// Matrix packing not implemented yet
static_assert(!DataTypeUtil::isMatrix<type>());
const auto size = static_cast<uint64_t>(propertyTablePropertyView.size());
assert(size > 0);
constexpr uint64_t maximumTextureWidth = 4096;
const auto width = glm::min(maximumTextureWidth, size);
const auto height = ((size - 1) / maximumTextureWidth) + 1;
constexpr auto texelByteLength = DataTypeUtil::getByteLength<textureType>();
const auto textureByteLength = width * height * texelByteLength;
std::vector<std::byte> texelBytes(textureByteLength, std::byte(0));
gsl::span<TextureType> texelValues(
reinterpret_cast<TextureType*>(texelBytes.data()), texelBytes.size() / texelByteLength);
for (uint64_t i = 0; i < size; ++i) {
auto& texelValue = texelValues[i];
const auto& rawValue = propertyTablePropertyView.getRaw(static_cast<int64_t>(i));
if constexpr (DataTypeUtil::isVector<type>()) {
for (uint64_t j = 0; j < DataTypeUtil::getComponentCount<type>(); ++j) {
texelValue[j] = static_cast<TextureComponentType>(rawValue[j]);
}
} else {
texelValue = static_cast<TextureType>(rawValue);
}
}
// In C++ 20 this can be push_back without the {}
textures.push_back({
std::move(texelBytes),
width,
height,
textureFormat,
});
},
unsupportedPropertyCallbackNoop);
return textures;
}
uint64_t getPropertyTableTextureCount(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive) {
uint64_t count = 0;
forEachStyleablePropertyTableProperty(
context,
model,
primitive,
[&count](
[[maybe_unused]] const std::string& propertyId,
[[maybe_unused]] const auto& propertyTablePropertyView,
[[maybe_unused]] const auto& property) { ++count; },
unsupportedPropertyCallbackNoop);
return count;
}
} // namespace cesium::omniverse::MetadataUtil
| 9,027 | C++ | 37.092827 | 117 | 0.622244 |
CesiumGS/cesium-omniverse/src/core/src/FabricMaterialPool.cpp | #include "cesium/omniverse/FabricMaterialPool.h"
#include "cesium/omniverse/FabricPropertyDescriptor.h"
#include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/MetadataUtil.h"
#include <spdlog/fmt/fmt.h>
namespace cesium::omniverse {
FabricMaterialPool::FabricMaterialPool(
Context* pContext,
int64_t poolId,
const FabricMaterialDescriptor& materialDescriptor,
uint64_t initialCapacity,
const pxr::TfToken& defaultWhiteTextureAssetPathToken,
const pxr::TfToken& defaultTransparentTextureAssetPathToken,
bool debugRandomColors)
: ObjectPool<FabricMaterial>()
, _pContext(pContext)
, _poolId(poolId)
, _materialDescriptor(materialDescriptor)
, _defaultWhiteTextureAssetPathToken(defaultWhiteTextureAssetPathToken)
, _defaultTransparentTextureAssetPathToken(defaultTransparentTextureAssetPathToken)
, _debugRandomColors(debugRandomColors) {
setCapacity(initialCapacity);
}
const FabricMaterialDescriptor& FabricMaterialPool::getMaterialDescriptor() const {
return _materialDescriptor;
}
int64_t FabricMaterialPool::getPoolId() const {
return _poolId;
}
void FabricMaterialPool::updateShaderInput(const pxr::SdfPath& shaderPath, const pxr::TfToken& attributeName) {
const auto& materials = getQueue();
for (auto& pMaterial : materials) {
pMaterial->updateShaderInput(FabricUtil::toFabricPath(shaderPath), FabricUtil::toFabricToken(attributeName));
}
}
std::shared_ptr<FabricMaterial> FabricMaterialPool::createObject(uint64_t objectId) const {
const auto contextId = _pContext->getContextId();
const auto pathStr = fmt::format("/cesium_material_pool_{}_object_{}_context_{}", _poolId, objectId, contextId);
const auto path = omni::fabric::Path(pathStr.c_str());
return std::make_shared<FabricMaterial>(
_pContext,
path,
_materialDescriptor,
_defaultWhiteTextureAssetPathToken,
_defaultTransparentTextureAssetPathToken,
_debugRandomColors,
_poolId);
}
void FabricMaterialPool::setActive(FabricMaterial* pMaterial, bool active) const {
pMaterial->setActive(active);
}
}; // namespace cesium::omniverse
| 2,181 | C++ | 34.193548 | 117 | 0.750573 |
CesiumGS/cesium-omniverse/src/core/src/OmniGlobeAnchor.cpp | #include "cesium/omniverse/OmniGlobeAnchor.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/CppUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/MathUtil.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/UsdTokens.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumGeospatial/Cartographic.h>
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumGeospatial/GlobeAnchor.h>
#include <CesiumGeospatial/LocalHorizontalCoordinateSystem.h>
#include <CesiumUsdSchemas/data.h>
#include <CesiumUsdSchemas/georeference.h>
#include <CesiumUsdSchemas/globeAnchorAPI.h>
#include <CesiumUsdSchemas/ionServer.h>
#include <CesiumUsdSchemas/rasterOverlay.h>
#include <CesiumUsdSchemas/session.h>
#include <CesiumUsdSchemas/tileset.h>
#include <CesiumUsdSchemas/tokens.h>
#include <CesiumUtility/Math.h>
#include <glm/ext/matrix_relational.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/euler_angles.hpp>
#include <pxr/usd/usdGeom/xform.h>
#include <pxr/usd/usdGeom/xformCommonAPI.h>
#include <tuple>
#include <utility>
namespace cesium::omniverse {
OmniGlobeAnchor::OmniGlobeAnchor(Context* pContext, const pxr::SdfPath& path)
: _pContext(pContext)
, _path(path) {
initialize();
}
OmniGlobeAnchor::~OmniGlobeAnchor() = default;
const pxr::SdfPath& OmniGlobeAnchor::getPath() const {
return _path;
}
bool OmniGlobeAnchor::getDetectTransformChanges() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumGlobeAnchor)) {
return true;
}
bool detectTransformChanges;
cesiumGlobeAnchor.GetDetectTransformChangesAttr().Get(&detectTransformChanges);
return detectTransformChanges;
}
bool OmniGlobeAnchor::getAdjustOrientation() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumGlobeAnchor)) {
return true;
}
bool adjustOrientation;
cesiumGlobeAnchor.GetAdjustOrientationForGlobeWhenMovingAttr().Get(&adjustOrientation);
return adjustOrientation;
}
pxr::SdfPath OmniGlobeAnchor::getResolvedGeoreferencePath() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumGlobeAnchor)) {
return {};
}
pxr::SdfPathVector targets;
cesiumGlobeAnchor.GetGeoreferenceBindingRel().GetForwardedTargets(&targets);
if (!targets.empty()) {
return targets.front();
}
// Fall back to using the first georeference if there's no explicit binding
const auto pGeoreference = _pContext->getAssetRegistry().getFirstGeoreference();
if (pGeoreference) {
return pGeoreference->getPath();
}
return {};
}
void OmniGlobeAnchor::updateByEcefPosition() {
initialize();
if (!isAnchorValid()) {
return;
}
const auto primLocalToEcefTranslation = getPrimLocalToEcefTranslation();
const auto tolerance = CesiumUtility::Math::Epsilon4;
if (MathUtil::epsilonEqual(primLocalToEcefTranslation, _cachedPrimLocalToEcefTranslation, tolerance)) {
// Short circuit if we don't need to do an actual update.
return;
}
auto primLocalToEcefTransform = _pAnchor->getAnchorToFixedTransform();
primLocalToEcefTransform[3] = glm::dvec4(primLocalToEcefTranslation, 1.0);
const auto pGeoreference = _pContext->getAssetRegistry().getGeoreference(getResolvedGeoreferencePath());
_pAnchor->setAnchorToFixedTransform(
primLocalToEcefTransform, getAdjustOrientation(), pGeoreference->getEllipsoid());
finalize();
}
void OmniGlobeAnchor::updateByGeographicCoordinates() {
initialize();
if (!isAnchorValid()) {
return;
}
const auto geographicCoordinates = getGeographicCoordinates();
const auto tolerance = CesiumUtility::Math::Epsilon7;
if (MathUtil::epsilonEqual(geographicCoordinates, _cachedGeographicCoordinates, tolerance)) {
// Short circuit if we don't need to do an actual update.
return;
}
const auto pGeoreference = _pContext->getAssetRegistry().getGeoreference(getResolvedGeoreferencePath());
const auto& ellipsoid = pGeoreference->getEllipsoid();
const auto primLocalToEcefTranslation = ellipsoid.cartographicToCartesian(geographicCoordinates);
auto primLocalToEcefTransform = _pAnchor->getAnchorToFixedTransform();
primLocalToEcefTransform[3] = glm::dvec4(primLocalToEcefTranslation, 1.0);
_pAnchor->setAnchorToFixedTransform(primLocalToEcefTransform, getAdjustOrientation(), ellipsoid);
finalize();
}
void OmniGlobeAnchor::updateByPrimLocalTransform(bool resetOrientation) {
initialize();
if (!isAnchorValid()) {
return;
}
const auto primLocalTranslation = getPrimLocalTranslation();
const auto primLocalRotation = getPrimLocalRotation();
const auto primLocalOrientation = getPrimLocalOrientation();
const auto primLocalScale = getPrimLocalScale();
const auto tolerance = CesiumUtility::Math::Epsilon4;
if (MathUtil::epsilonEqual(primLocalTranslation, _cachedPrimLocalTranslation, tolerance) &&
MathUtil::epsilonEqual(primLocalRotation, _cachedPrimLocalRotation, tolerance) &&
MathUtil::epsilonEqual(primLocalOrientation, _cachedPrimLocalOrientation, tolerance) &&
MathUtil::epsilonEqual(primLocalScale, _cachedPrimLocalScale, tolerance)) {
// Short circuit if we don't need to do an actual update.
return;
}
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
const auto xformable = pxr::UsdGeomXformable(cesiumGlobeAnchor);
const auto xformOps = UsdUtil::getOrCreateTranslateRotateScaleOps(xformable);
const auto opType = xformOps.value().rotateOrOrientOp.GetOpType();
glm::dmat4 primLocalTransform;
if (opType == pxr::UsdGeomXformOp::TypeOrient) {
primLocalTransform = MathUtil::compose(primLocalTranslation, primLocalOrientation, primLocalScale);
} else {
// xform ops are applied right to left, so xformOp:rotateXYZ actually applies a z-axis, then y-axis, then x-axis
// rotation. To compensate for that, we need to compose euler angles in the reverse order.
primLocalTransform = MathUtil::composeEuler(
primLocalTranslation,
primLocalRotation,
primLocalScale,
getReversedEulerAngleOrder(xformOps->eulerAngleOrder));
}
const auto pGeoreference = _pContext->getAssetRegistry().getGeoreference(getResolvedGeoreferencePath());
_pAnchor->setAnchorToLocalTransform(
pGeoreference->getLocalCoordinateSystem(),
primLocalTransform,
!resetOrientation && getAdjustOrientation(),
pGeoreference->getEllipsoid());
finalize();
}
void OmniGlobeAnchor::updateByGeoreference() {
initialize();
if (!isAnchorValid()) {
return;
}
finalize();
}
bool OmniGlobeAnchor::isAnchorValid() const {
const auto georeferencePath = getResolvedGeoreferencePath();
if (georeferencePath.IsEmpty()) {
return false;
}
const auto pGeoreference = _pContext->getAssetRegistry().getGeoreference(georeferencePath);
if (!pGeoreference) {
return false;
}
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
const auto xformable = pxr::UsdGeomXformable(cesiumGlobeAnchor);
if (!UsdUtil::isSchemaValid(xformable)) {
return false;
}
const auto xformOps = UsdUtil::getOrCreateTranslateRotateScaleOps(xformable);
if (!xformOps) {
_pContext->getLogger()->oneTimeWarning(
"Globe anchor xform op order must be [translate, rotate, scale] followed by any additional transforms.",
_path.GetText());
return false;
}
return true;
}
void OmniGlobeAnchor::initialize() {
if (!isAnchorValid()) {
_pAnchor = nullptr;
return;
}
if (_pAnchor) {
return;
}
// This function has the effect of baking the world transform into the local transform, which is unavoidable
// when using globe anchors.
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
const auto xformable = pxr::UsdGeomXformable(cesiumGlobeAnchor);
if (!UsdUtil::isSchemaValid(xformable)) {
return;
}
bool resetsXformStack;
const auto originalXformOps = xformable.GetOrderedXformOps(&resetsXformStack);
const auto translateRotateScaleXformOps = {originalXformOps[0], originalXformOps[1], originalXformOps[2]};
// Only use translate, rotate, and scale ops when computing the local to ecef transform.
// Additional transforms like xformOp:rotateX:unitsResolve are not baked into this transform.
xformable.SetXformOpOrder(translateRotateScaleXformOps);
// Compute the local to ecef transform
const auto primLocalToEcefTransform =
UsdUtil::computePrimLocalToEcefTransform(*_pContext, getResolvedGeoreferencePath(), _path);
// Now that the transform is computed, switch back to the original ops
xformable.SetXformOpOrder(originalXformOps);
// Disable inheriting parent transforms from now on
xformable.SetResetXformStack(true);
// Initialize the globe anchor
_pAnchor = std::make_unique<CesiumGeospatial::GlobeAnchor>(primLocalToEcefTransform);
// Use the ecef transform (if set) or geographic coordinates (if set) to reposition the globe anchor.
updateByEcefPosition();
updateByGeographicCoordinates();
// Update ecef position, geographic coordinates, and prim local transform from the globe anchor transform
finalize();
}
void OmniGlobeAnchor::finalize() {
savePrimLocalToEcefTranslation();
saveGeographicCoordinates();
savePrimLocalTransform();
}
glm::dvec3 OmniGlobeAnchor::getPrimLocalToEcefTranslation() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumGlobeAnchor)) {
return {0.0, 0.0, 0.0};
}
pxr::GfVec3d primLocalToEcefTranslation;
cesiumGlobeAnchor.GetPositionAttr().Get(&primLocalToEcefTranslation);
return UsdUtil::usdToGlmVector(primLocalToEcefTranslation);
}
CesiumGeospatial::Cartographic OmniGlobeAnchor::getGeographicCoordinates() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumGlobeAnchor)) {
return {0.0, 0.0, 0.0};
}
double longitude;
double latitude;
double height;
cesiumGlobeAnchor.GetAnchorLongitudeAttr().Get(&longitude);
cesiumGlobeAnchor.GetAnchorLatitudeAttr().Get(&latitude);
cesiumGlobeAnchor.GetAnchorHeightAttr().Get(&height);
return {glm::radians(longitude), glm::radians(latitude), height};
}
glm::dvec3 OmniGlobeAnchor::getPrimLocalTranslation() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
const auto xformable = pxr::UsdGeomXformable(cesiumGlobeAnchor);
if (!UsdUtil::isSchemaValid(xformable)) {
return {0.0, 0.0, 0.0};
}
const auto xformOps = UsdUtil::getOrCreateTranslateRotateScaleOps(xformable);
return UsdUtil::getTranslate(xformOps.value().translateOp);
}
glm::dvec3 OmniGlobeAnchor::getPrimLocalRotation() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
const auto xformable = pxr::UsdGeomXformable(cesiumGlobeAnchor);
if (!UsdUtil::isSchemaValid(xformable)) {
return {0.0, 0.0, 0.0};
}
const auto xformOps = UsdUtil::getOrCreateTranslateRotateScaleOps(xformable);
const auto& rotateOrOrientOp = xformOps.value().rotateOrOrientOp;
const auto opType = rotateOrOrientOp.GetOpType();
if (opType == pxr::UsdGeomXformOp::TypeOrient) {
return {0.0, 0.0, 0.0};
}
return glm::radians(UsdUtil::getRotate(rotateOrOrientOp));
}
glm::dquat OmniGlobeAnchor::getPrimLocalOrientation() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
const auto xformable = pxr::UsdGeomXformable(cesiumGlobeAnchor);
if (!UsdUtil::isSchemaValid(xformable)) {
return {1.0, 0.0, 0.0, 0.0};
}
const auto xformOps = UsdUtil::getOrCreateTranslateRotateScaleOps(xformable);
const auto& rotateOrOrientOp = xformOps.value().rotateOrOrientOp;
const auto opType = rotateOrOrientOp.GetOpType();
if (opType != pxr::UsdGeomXformOp::TypeOrient) {
return {1.0, 0.0, 0.0, 0.0};
}
return UsdUtil::getOrient(rotateOrOrientOp);
}
glm::dvec3 OmniGlobeAnchor::getPrimLocalScale() const {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
const auto xformable = pxr::UsdGeomXformable(cesiumGlobeAnchor);
if (!UsdUtil::isSchemaValid(xformable)) {
return {1.0, 1.0, 1.0};
}
const auto xformOps = UsdUtil::getOrCreateTranslateRotateScaleOps(xformable);
return UsdUtil::getScale(xformOps.value().scaleOp);
}
void OmniGlobeAnchor::savePrimLocalToEcefTranslation() {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumGlobeAnchor)) {
return;
}
const auto& primLocalToEcefTransform = _pAnchor->getAnchorToFixedTransform();
const auto primLocalToEcefTranslation = glm::dvec3(primLocalToEcefTransform[3]);
_cachedPrimLocalToEcefTranslation = primLocalToEcefTranslation;
cesiumGlobeAnchor.GetPositionAttr().Set(UsdUtil::glmToUsdVector(primLocalToEcefTranslation));
}
void OmniGlobeAnchor::saveGeographicCoordinates() {
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumGlobeAnchor)) {
return;
}
const auto pGeoreference = _pContext->getAssetRegistry().getGeoreference(getResolvedGeoreferencePath());
const auto& primLocalToEcefTransform = _pAnchor->getAnchorToFixedTransform();
const auto primLocalToEcefTranslation = glm::dvec3(primLocalToEcefTransform[3]);
const auto cartographic = pGeoreference->getEllipsoid().cartesianToCartographic(primLocalToEcefTranslation);
if (!cartographic) {
return;
}
_cachedGeographicCoordinates = *cartographic;
cesiumGlobeAnchor.GetAnchorLongitudeAttr().Set(glm::degrees(cartographic->longitude));
cesiumGlobeAnchor.GetAnchorLatitudeAttr().Set(glm::degrees(cartographic->latitude));
cesiumGlobeAnchor.GetAnchorHeightAttr().Set(cartographic->height);
}
void OmniGlobeAnchor::savePrimLocalTransform() {
// Ideally we would just use UsdGeomXformableAPI to set translation, rotation, scale, but this doesn't
// work when rotation and scale properties are double precision, which is common in Omniverse.
const auto cesiumGlobeAnchor = UsdUtil::getCesiumGlobeAnchor(_pContext->getUsdStage(), _path);
const auto xformable = pxr::UsdGeomXformable(cesiumGlobeAnchor);
if (!UsdUtil::isSchemaValid(xformable)) {
return;
}
auto xformOps = UsdUtil::getOrCreateTranslateRotateScaleOps(xformable);
auto& [translateOp, rotateOrOrientOp, scaleOp, eulerAngleOrder] = xformOps.value();
const auto opType = rotateOrOrientOp.GetOpType();
const auto pGeoreference = _pContext->getAssetRegistry().getGeoreference(getResolvedGeoreferencePath());
const auto primLocalToWorldTransform =
_pAnchor->getAnchorToLocalTransform(pGeoreference->getLocalCoordinateSystem());
if (opType == pxr::UsdGeomXformOp::TypeOrient) {
const auto decomposed = MathUtil::decompose(primLocalToWorldTransform);
_cachedPrimLocalTranslation = decomposed.translation;
_cachedPrimLocalOrientation = decomposed.rotation;
_cachedPrimLocalScale = decomposed.scale;
UsdUtil::setTranslate(translateOp, decomposed.translation);
UsdUtil::setOrient(rotateOrOrientOp, decomposed.rotation);
UsdUtil::setScale(scaleOp, decomposed.scale);
} else {
// xform ops are applied right to left, so xformOp:rotateXYZ actually applies a z-axis, then y-axis, then x-axis
// rotation. To compensate for that, we need to decompose euler angles in the reverse order.
const auto decomposed =
MathUtil::decomposeEuler(primLocalToWorldTransform, getReversedEulerAngleOrder(eulerAngleOrder));
_cachedPrimLocalTranslation = decomposed.translation;
_cachedPrimLocalRotation = decomposed.rotation;
_cachedPrimLocalScale = decomposed.scale;
UsdUtil::setTranslate(translateOp, decomposed.translation);
UsdUtil::setRotate(rotateOrOrientOp, glm::degrees(decomposed.rotation));
UsdUtil::setScale(scaleOp, decomposed.scale);
}
}
} // namespace cesium::omniverse
| 17,158 | C++ | 35.821888 | 120 | 0.732486 |
CesiumGS/cesium-omniverse/src/core/src/OmniTileset.cpp | #include "cesium/omniverse/OmniTileset.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Broadcast.h"
#include "cesium/omniverse/CesiumIonSession.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/FabricGeometry.h"
#include "cesium/omniverse/FabricMaterial.h"
#include "cesium/omniverse/FabricMesh.h"
#include "cesium/omniverse/FabricPrepareRenderResources.h"
#include "cesium/omniverse/FabricRenderResources.h"
#include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/OmniCartographicPolygon.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/OmniGlobeAnchor.h"
#include "cesium/omniverse/OmniIonServer.h"
#include "cesium/omniverse/OmniPolygonRasterOverlay.h"
#include "cesium/omniverse/OmniRasterOverlay.h"
#include "cesium/omniverse/TaskProcessor.h"
#include "cesium/omniverse/TilesetStatistics.h"
#include "cesium/omniverse/UsdUtil.h"
#include "cesium/omniverse/Viewport.h"
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <Cesium3DTilesSelection/Tileset.h>
#include <Cesium3DTilesSelection/ViewState.h>
#include <Cesium3DTilesSelection/ViewUpdateResult.h>
#include <CesiumUsdSchemas/rasterOverlay.h>
#include <CesiumUsdSchemas/tileset.h>
#include <pxr/usd/usd/prim.h>
#include <pxr/usd/usd/stage.h>
#include <pxr/usd/usdGeom/boundable.h>
#include <pxr/usd/usdShade/materialBindingAPI.h>
namespace cesium::omniverse {
namespace {
void forEachFabricMaterial(
Cesium3DTilesSelection::Tileset* pTileset,
const std::function<void(FabricMaterial& fabricMaterial)>& callback) {
pTileset->forEachLoadedTile([&callback](Cesium3DTilesSelection::Tile& tile) {
if (tile.getState() != Cesium3DTilesSelection::TileLoadState::Done) {
return;
}
const auto& content = tile.getContent();
const auto pRenderContent = content.getRenderContent();
if (!pRenderContent) {
return;
}
const auto pFabricRenderResources = static_cast<FabricRenderResources*>(pRenderContent->getRenderResources());
if (!pFabricRenderResources) {
return;
}
for (const auto& fabricMesh : pFabricRenderResources->fabricMeshes) {
if (fabricMesh.pMaterial) {
callback(*fabricMesh.pMaterial.get());
}
}
});
}
} // namespace
OmniTileset::OmniTileset(Context* pContext, const pxr::SdfPath& path, int64_t tilesetId)
: _pContext(pContext)
, _path(path)
, _tilesetId(tilesetId) {
reload();
}
OmniTileset::~OmniTileset() {
destroyNativeTileset();
}
const pxr::SdfPath& OmniTileset::getPath() const {
return _path;
}
int64_t OmniTileset::getTilesetId() const {
return _tilesetId;
}
TilesetStatistics OmniTileset::getStatistics() const {
TilesetStatistics statistics;
statistics.tilesetCachedBytes = static_cast<uint64_t>(_pTileset->getTotalDataBytes());
statistics.tilesLoaded = static_cast<uint64_t>(_pTileset->getNumberOfTilesLoaded());
if (_pViewUpdateResult) {
statistics.tilesVisited = static_cast<uint64_t>(_pViewUpdateResult->tilesVisited);
statistics.culledTilesVisited = static_cast<uint64_t>(_pViewUpdateResult->culledTilesVisited);
statistics.tilesRendered = static_cast<uint64_t>(_pViewUpdateResult->tilesToRenderThisFrame.size());
statistics.tilesCulled = static_cast<uint64_t>(_pViewUpdateResult->tilesCulled);
statistics.maxDepthVisited = static_cast<uint64_t>(_pViewUpdateResult->maxDepthVisited);
statistics.tilesLoadingWorker = static_cast<uint64_t>(_pViewUpdateResult->workerThreadTileLoadQueueLength);
statistics.tilesLoadingMain = static_cast<uint64_t>(_pViewUpdateResult->mainThreadTileLoadQueueLength);
}
return statistics;
}
TilesetSourceType OmniTileset::getSourceType() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return TilesetSourceType::ION;
}
pxr::TfToken sourceType;
cesiumTileset.GetSourceTypeAttr().Get(&sourceType);
if (sourceType == pxr::CesiumTokens->url) {
return TilesetSourceType::URL;
}
return TilesetSourceType::ION;
}
std::string OmniTileset::getUrl() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return "";
}
std::string url;
cesiumTileset.GetUrlAttr().Get(&url);
return url;
}
int64_t OmniTileset::getIonAssetId() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return 0;
}
int64_t ionAssetId;
cesiumTileset.GetIonAssetIdAttr().Get(&ionAssetId);
return ionAssetId;
}
CesiumIonClient::Token OmniTileset::getIonAccessToken() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return {};
}
std::string ionAccessToken;
cesiumTileset.GetIonAccessTokenAttr().Get(&ionAccessToken);
if (!ionAccessToken.empty()) {
CesiumIonClient::Token t;
t.token = ionAccessToken;
return t;
}
const auto ionServerPath = getResolvedIonServerPath();
if (ionServerPath.IsEmpty()) {
return {};
}
const auto pIonServer = _pContext->getAssetRegistry().getIonServer(ionServerPath);
if (!pIonServer) {
return {};
}
return pIonServer->getToken();
}
std::string OmniTileset::getIonApiUrl() const {
const auto ionServerPath = getResolvedIonServerPath();
if (ionServerPath.IsEmpty()) {
return {};
}
const auto pIonServer = _pContext->getAssetRegistry().getIonServer(ionServerPath);
if (!pIonServer) {
return {};
}
return pIonServer->getIonServerApiUrl();
}
pxr::SdfPath OmniTileset::getResolvedIonServerPath() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return {};
}
pxr::SdfPathVector targets;
cesiumTileset.GetIonServerBindingRel().GetForwardedTargets(&targets);
if (!targets.empty()) {
return targets.front();
}
// Fall back to using the first ion server if there's no explicit binding
const auto pIonServer = _pContext->getAssetRegistry().getFirstIonServer();
if (pIonServer) {
return pIonServer->getPath();
}
return {};
}
double OmniTileset::getMaximumScreenSpaceError() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return 16.0;
}
float maximumScreenSpaceError;
cesiumTileset.GetMaximumScreenSpaceErrorAttr().Get(&maximumScreenSpaceError);
return static_cast<double>(maximumScreenSpaceError);
}
bool OmniTileset::getPreloadAncestors() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return true;
}
bool preloadAncestors;
cesiumTileset.GetPreloadAncestorsAttr().Get(&preloadAncestors);
return preloadAncestors;
}
bool OmniTileset::getPreloadSiblings() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return true;
}
bool preloadSiblings;
cesiumTileset.GetPreloadSiblingsAttr().Get(&preloadSiblings);
return preloadSiblings;
}
bool OmniTileset::getForbidHoles() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return false;
}
bool forbidHoles;
cesiumTileset.GetForbidHolesAttr().Get(&forbidHoles);
return forbidHoles;
}
uint32_t OmniTileset::getMaximumSimultaneousTileLoads() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return 20;
}
uint32_t maximumSimultaneousTileLoads;
cesiumTileset.GetMaximumSimultaneousTileLoadsAttr().Get(&maximumSimultaneousTileLoads);
return maximumSimultaneousTileLoads;
}
uint64_t OmniTileset::getMaximumCachedBytes() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return 536870912;
}
uint64_t maximumCachedBytes;
cesiumTileset.GetMaximumCachedBytesAttr().Get(&maximumCachedBytes);
return maximumCachedBytes;
}
uint32_t OmniTileset::getLoadingDescendantLimit() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return 20;
}
uint32_t loadingDescendantLimit;
cesiumTileset.GetLoadingDescendantLimitAttr().Get(&loadingDescendantLimit);
return loadingDescendantLimit;
}
bool OmniTileset::getEnableFrustumCulling() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return true;
}
bool enableFrustumCulling;
cesiumTileset.GetEnableFrustumCullingAttr().Get(&enableFrustumCulling);
return enableFrustumCulling;
}
bool OmniTileset::getEnableFogCulling() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return true;
}
bool enableFogCulling;
cesiumTileset.GetEnableFogCullingAttr().Get(&enableFogCulling);
return enableFogCulling;
}
bool OmniTileset::getEnforceCulledScreenSpaceError() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return true;
}
bool enforceCulledScreenSpaceError;
cesiumTileset.GetEnforceCulledScreenSpaceErrorAttr().Get(&enforceCulledScreenSpaceError);
return enforceCulledScreenSpaceError;
}
double OmniTileset::getMainThreadLoadingTimeLimit() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return 0.0;
}
float mainThreadLoadingTimeLimit;
cesiumTileset.GetMainThreadLoadingTimeLimitAttr().Get(&mainThreadLoadingTimeLimit);
return static_cast<double>(mainThreadLoadingTimeLimit);
}
double OmniTileset::getCulledScreenSpaceError() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return 64.0;
}
float culledScreenSpaceError;
cesiumTileset.GetCulledScreenSpaceErrorAttr().Get(&culledScreenSpaceError);
return static_cast<double>(culledScreenSpaceError);
}
bool OmniTileset::getSuspendUpdate() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return false;
}
bool suspendUpdate;
cesiumTileset.GetSuspendUpdateAttr().Get(&suspendUpdate);
return suspendUpdate;
}
bool OmniTileset::getSmoothNormals() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return false;
}
bool smoothNormals;
cesiumTileset.GetSmoothNormalsAttr().Get(&smoothNormals);
return smoothNormals;
}
bool OmniTileset::getShowCreditsOnScreen() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return false;
}
bool showCreditsOnScreen;
cesiumTileset.GetShowCreditsOnScreenAttr().Get(&showCreditsOnScreen);
return showCreditsOnScreen;
}
pxr::SdfPath OmniTileset::getResolvedGeoreferencePath() const {
const auto pGlobeAnchor = _pContext->getAssetRegistry().getGlobeAnchor(_path);
if (pGlobeAnchor) {
// The georeference math has already happened in OmniGlobeAnchor, so this prevents it from happening again.
// By returning an empty path any ecefTo or toEcef conversions are really conversions to and from tile world
// space, which for non-georeferenced tilesets is some local coordinate system.
return {};
}
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return {};
}
pxr::SdfPathVector targets;
cesiumTileset.GetGeoreferenceBindingRel().GetForwardedTargets(&targets);
if (!targets.empty()) {
return targets.front();
}
// Fall back to using the first georeference if there's no explicit binding
const auto pGeoreference = _pContext->getAssetRegistry().getFirstGeoreference();
if (pGeoreference) {
return pGeoreference->getPath();
}
return {};
}
pxr::SdfPath OmniTileset::getMaterialPath() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
const auto materialBindingApi = pxr::UsdShadeMaterialBindingAPI(cesiumTileset);
if (!UsdUtil::isSchemaValid(materialBindingApi)) {
return {};
}
const auto materialBinding = materialBindingApi.GetDirectBinding();
const auto& materialPath = materialBinding.GetMaterialPath();
return materialPath;
}
glm::dvec3 OmniTileset::getDisplayColor() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return {1.0, 1.0, 1.0};
}
pxr::VtVec3fArray displayColorArray;
cesiumTileset.GetDisplayColorAttr().Get(&displayColorArray);
if (displayColorArray.size() == 0) {
return {1.0, 1.0, 1.0};
}
const auto& displayColor = displayColorArray[0];
return {
static_cast<double>(displayColor[0]),
static_cast<double>(displayColor[1]),
static_cast<double>(displayColor[2]),
};
}
double OmniTileset::getDisplayOpacity() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return 1.0;
}
pxr::VtFloatArray displayOpacityArray;
cesiumTileset.GetDisplayOpacityAttr().Get(&displayOpacityArray);
if (displayOpacityArray.size() == 0) {
return 1.0;
}
return static_cast<double>(displayOpacityArray[0]);
}
std::vector<pxr::SdfPath> OmniTileset::getRasterOverlayPaths() const {
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileset)) {
return {};
}
pxr::SdfPathVector targets;
cesiumTileset.GetRasterOverlayBindingRel().GetForwardedTargets(&targets);
return targets;
}
void OmniTileset::updateTilesetOptions() {
auto& options = _pTileset->getOptions();
options.maximumScreenSpaceError = getMaximumScreenSpaceError();
options.preloadAncestors = getPreloadAncestors();
options.preloadSiblings = getPreloadSiblings();
options.forbidHoles = getForbidHoles();
options.maximumSimultaneousTileLoads = getMaximumSimultaneousTileLoads();
options.maximumCachedBytes = static_cast<int64_t>(getMaximumCachedBytes());
options.loadingDescendantLimit = getLoadingDescendantLimit();
options.enableFrustumCulling = getEnableFrustumCulling();
options.enableFogCulling = getEnableFogCulling();
options.enforceCulledScreenSpaceError = getEnforceCulledScreenSpaceError();
options.culledScreenSpaceError = getCulledScreenSpaceError();
options.mainThreadLoadingTimeLimit = getMainThreadLoadingTimeLimit();
options.showCreditsOnScreen = getShowCreditsOnScreen();
}
void OmniTileset::reload() {
destroyNativeTileset();
_pRenderResourcesPreparer = std::make_shared<FabricPrepareRenderResources>(_pContext, this);
const auto externals = Cesium3DTilesSelection::TilesetExternals{
_pContext->getAssetAccessor(),
_pRenderResourcesPreparer,
_pContext->getAsyncSystem(),
_pContext->getCreditSystem(),
_pContext->getLogger()};
const auto sourceType = getSourceType();
const auto url = getUrl();
const auto tilesetPath = getPath();
const auto ionAssetId = getIonAssetId();
const auto ionAccessToken = getIonAccessToken();
const auto ionApiUrl = getIonApiUrl();
const auto name = UsdUtil::getName(_pContext->getUsdStage(), _path);
Cesium3DTilesSelection::TilesetOptions options;
options.maximumScreenSpaceError = static_cast<double>(getMaximumScreenSpaceError());
options.preloadAncestors = getPreloadAncestors();
options.preloadSiblings = getPreloadSiblings();
options.forbidHoles = getForbidHoles();
options.maximumSimultaneousTileLoads = getMaximumSimultaneousTileLoads();
options.maximumCachedBytes = static_cast<int64_t>(getMaximumCachedBytes());
options.loadingDescendantLimit = getLoadingDescendantLimit();
options.enableFrustumCulling = getEnableFrustumCulling();
options.enableFogCulling = getEnableFogCulling();
options.enforceCulledScreenSpaceError = getEnforceCulledScreenSpaceError();
options.culledScreenSpaceError = getCulledScreenSpaceError();
options.mainThreadLoadingTimeLimit = getMainThreadLoadingTimeLimit();
options.showCreditsOnScreen = getShowCreditsOnScreen();
options.loadErrorCallback =
[this, tilesetPath, ionAssetId, name](const Cesium3DTilesSelection::TilesetLoadFailureDetails& error) {
// Check for a 401 connecting to Cesium ion, which means the token is invalid
// (or perhaps the asset ID is). Also check for a 404, because ion returns 404
// when the token is valid but not authorized for the asset.
if (error.type == Cesium3DTilesSelection::TilesetLoadType::CesiumIon &&
(error.statusCode == 401 || error.statusCode == 404)) {
Broadcast::showTroubleshooter(tilesetPath, ionAssetId, name, 0, "", error.message);
}
_pContext->getLogger()->error(error.message);
};
options.contentOptions.ktx2TranscodeTargets = GltfUtil::getKtx2TranscodeTargets();
const auto rasterOverlayPaths = getRasterOverlayPaths();
for (const auto& rasterOverlayPath : rasterOverlayPaths) {
const auto pPolygonRasterOverlay = _pContext->getAssetRegistry().getPolygonRasterOverlay(rasterOverlayPath);
if (pPolygonRasterOverlay) {
const auto pExcluder = pPolygonRasterOverlay->getExcluder();
if (pExcluder) {
options.excluders.push_back(pExcluder);
}
}
}
_pViewUpdateResult = nullptr;
_extentSet = false;
_activeLoading = false;
switch (sourceType) {
case TilesetSourceType::ION:
if (ionAssetId <= 0 || ionApiUrl.empty()) {
_pTileset = std::make_unique<Cesium3DTilesSelection::Tileset>(externals, 0, "", options);
} else {
_pTileset = std::make_unique<Cesium3DTilesSelection::Tileset>(
externals, ionAssetId, ionAccessToken.token, options, ionApiUrl);
}
break;
case TilesetSourceType::URL:
_pTileset = std::make_unique<Cesium3DTilesSelection::Tileset>(externals, url, options);
break;
}
const auto boundRasterOverlayPaths = getRasterOverlayPaths();
for (const auto& boundRasterOverlayPath : boundRasterOverlayPaths) {
const auto pOmniRasterOverlay = _pContext->getAssetRegistry().getRasterOverlay(boundRasterOverlayPath);
if (pOmniRasterOverlay) {
pOmniRasterOverlay->reload();
addRasterOverlayIfExists(pOmniRasterOverlay);
}
}
}
pxr::SdfPath OmniTileset::getRasterOverlayPathIfExists(const CesiumRasterOverlays::RasterOverlay& rasterOverlay) {
const auto rasterOverlayPaths = getRasterOverlayPaths();
for (const auto& rasterOverlayPath : rasterOverlayPaths) {
const auto pRasterOverlay = _pContext->getAssetRegistry().getRasterOverlay(rasterOverlayPath);
if (pRasterOverlay) {
const auto pNativeRasterOverlay = pRasterOverlay->getRasterOverlay();
if (pNativeRasterOverlay == &rasterOverlay) {
return rasterOverlayPath;
}
}
}
return {};
}
void OmniTileset::updateRasterOverlayAlpha(const pxr::SdfPath& rasterOverlayPath) {
const auto rasterOverlayPaths = getRasterOverlayPaths();
const auto rasterOverlayIndex = CppUtil::indexOf(rasterOverlayPaths, rasterOverlayPath);
if (rasterOverlayIndex == rasterOverlayPaths.size()) {
return;
}
const auto pRasterOverlay = _pContext->getAssetRegistry().getRasterOverlay(rasterOverlayPath);
if (!pRasterOverlay) {
return;
}
const auto alpha = glm::clamp(pRasterOverlay->getAlpha(), 0.0, 1.0);
forEachFabricMaterial(_pTileset.get(), [rasterOverlayIndex, alpha](FabricMaterial& fabricMaterial) {
fabricMaterial.setRasterOverlayAlpha(rasterOverlayIndex, alpha);
});
}
void OmniTileset::updateDisplayColorAndOpacity() {
const auto displayColor = getDisplayColor();
const auto displayOpacity = getDisplayOpacity();
forEachFabricMaterial(_pTileset.get(), [&displayColor, &displayOpacity](FabricMaterial& fabricMaterial) {
fabricMaterial.setDisplayColorAndOpacity(displayColor, displayOpacity);
});
}
void OmniTileset::updateShaderInput(const pxr::SdfPath& shaderPath, const pxr::TfToken& attributeName) {
forEachFabricMaterial(_pTileset.get(), [&shaderPath, &attributeName](FabricMaterial& fabricMaterial) {
fabricMaterial.updateShaderInput(
FabricUtil::toFabricPath(shaderPath), FabricUtil::toFabricToken(attributeName));
});
}
void OmniTileset::onUpdateFrame(const gsl::span<const Viewport>& viewports, bool waitForLoadingTiles) {
if (!UsdUtil::primExists(_pContext->getUsdStage(), _path)) {
// TfNotice can be slow, and sometimes we get a frame or two before we actually get a chance to react on it.
// This guard prevents us from crashing if the prim no longer exists.
return;
}
updateTransform();
updateView(viewports, waitForLoadingTiles);
if (!_extentSet) {
_extentSet = updateExtent();
}
updateLoadStatus();
}
void OmniTileset::updateTransform() {
// computeEcefToPrimWorldTransform is a slightly expensive operation to do every frame but it is simple
// and exhaustive; it reacts to USD scene graph changes, up-axis changes, meters-per-unit changes, and georeference
// origin changes without us needing to subscribe to any events.
//
// The faster approach would be to subscribe to change events for _worldPosition, _worldOrientation, _worldScale.
// Alternatively, we could register a listener with Tf::Notice but this has the downside of only notifying us
// about changes to the current prim and not its ancestor prims. Also Tf::Notice may notify us in a thread other
// than the main thread and we would have to be careful to synchronize updates to Fabric in the main thread.
const auto georeferencePath = getResolvedGeoreferencePath();
const auto ecefToPrimWorldTransform = UsdUtil::computeEcefToPrimWorldTransform(*_pContext, georeferencePath, _path);
// Check for transform changes and update prims accordingly
if (ecefToPrimWorldTransform != _ecefToPrimWorldTransform) {
_ecefToPrimWorldTransform = ecefToPrimWorldTransform;
FabricUtil::setTilesetTransform(_pContext->getFabricStage(), _tilesetId, ecefToPrimWorldTransform);
_extentSet = updateExtent();
}
}
void OmniTileset::updateView(const gsl::span<const Viewport>& viewports, bool waitForLoadingTiles) {
const auto visible = UsdUtil::isPrimVisible(_pContext->getUsdStage(), _path);
if (visible && !getSuspendUpdate()) {
// Go ahead and select some tiles
const auto georeferencePath = getResolvedGeoreferencePath();
_viewStates.clear();
for (const auto& viewport : viewports) {
_viewStates.push_back(UsdUtil::computeViewState(*_pContext, georeferencePath, _path, viewport));
}
if (waitForLoadingTiles) {
_pViewUpdateResult = &_pTileset->updateViewOffline(_viewStates);
} else {
_pViewUpdateResult = &_pTileset->updateView(_viewStates);
}
}
if (!_pViewUpdateResult) {
// No tiles have ever been selected. Return early.
return;
}
// Hide tiles that we no longer need
for (const auto pTile : _pViewUpdateResult->tilesFadingOut) {
if (pTile->getState() == Cesium3DTilesSelection::TileLoadState::Done) {
const auto pRenderContent = pTile->getContent().getRenderContent();
if (pRenderContent) {
const auto pRenderResources =
static_cast<const FabricRenderResources*>(pRenderContent->getRenderResources());
if (pRenderResources) {
for (const auto& fabricMesh : pRenderResources->fabricMeshes) {
fabricMesh.pGeometry->setVisibility(false);
}
}
}
}
}
// Update visibility for selected tiles
for (const auto pTile : _pViewUpdateResult->tilesToRenderThisFrame) {
if (pTile->getState() == Cesium3DTilesSelection::TileLoadState::Done) {
const auto pRenderContent = pTile->getContent().getRenderContent();
if (pRenderContent) {
const auto pRenderResources =
static_cast<const FabricRenderResources*>(pRenderContent->getRenderResources());
if (pRenderResources) {
for (const auto& fabricMesh : pRenderResources->fabricMeshes) {
fabricMesh.pGeometry->setVisibility(visible);
}
}
}
}
}
}
bool OmniTileset::updateExtent() {
const auto pRootTile = _pTileset->getRootTile();
if (!pRootTile) {
return false;
}
const auto cesiumTileset = UsdUtil::getCesiumTileset(_pContext->getUsdStage(), _path);
const auto boundable = pxr::UsdGeomBoundable(cesiumTileset);
if (!UsdUtil::isSchemaValid(boundable)) {
return false;
}
const auto& boundingVolume = pRootTile->getBoundingVolume();
const auto ecefObb = Cesium3DTilesSelection::getOrientedBoundingBoxFromBoundingVolume(boundingVolume);
const auto georeferencePath = getResolvedGeoreferencePath();
const auto ecefToStageTransform = UsdUtil::computeEcefToStageTransform(*_pContext, georeferencePath);
const auto primObb = ecefObb.transform(ecefToStageTransform);
const auto primAabb = primObb.toAxisAligned();
const auto bottomLeft = glm::dvec3(primAabb.minimumX, primAabb.minimumY, primAabb.minimumZ);
const auto topRight = glm::dvec3(primAabb.maximumX, primAabb.maximumY, primAabb.maximumZ);
pxr::VtArray<pxr::GfVec3f> extent = {
UsdUtil::glmToUsdVector(glm::fvec3(bottomLeft)),
UsdUtil::glmToUsdVector(glm::fvec3(topRight)),
};
boundable.GetExtentAttr().Set(extent);
return true;
}
void OmniTileset::updateLoadStatus() {
const auto loadProgress = _pTileset->computeLoadProgress();
if (loadProgress < 100.0f) {
_activeLoading = true;
} else if (_activeLoading) {
Broadcast::tilesetLoaded(_path);
_activeLoading = false;
}
}
void OmniTileset::destroyNativeTileset() {
if (_pTileset) {
// Remove raster overlays before the native tileset is destroyed
// See comment above _pLoadedTiles in RasterOverlayCollection.h
while (_pTileset->getOverlays().size() > 0) {
_pTileset->getOverlays().remove(*_pTileset->getOverlays().begin());
}
}
if (_pRenderResourcesPreparer) {
_pRenderResourcesPreparer->detachTileset();
}
_pTileset = nullptr;
_pRenderResourcesPreparer = nullptr;
}
void OmniTileset::addRasterOverlayIfExists(const OmniRasterOverlay* pOmniRasterOverlay) {
const auto pNativeRasterOverlay = pOmniRasterOverlay->getRasterOverlay();
if (pNativeRasterOverlay) {
_pTileset->getOverlays().add(pNativeRasterOverlay);
}
}
} // namespace cesium::omniverse
| 28,867 | C++ | 34.639506 | 120 | 0.704438 |
CesiumGS/cesium-omniverse/src/core/src/OmniCartographicPolygon.cpp | #include "cesium/omniverse/OmniCartographicPolygon.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/OmniGlobeAnchor.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumGeospatial/Cartographic.h>
#include <CesiumUsdSchemas/globeAnchorAPI.h>
#include <glm/glm.hpp>
#include <pxr/usd/usdGeom/basisCurves.h>
namespace cesium::omniverse {
OmniCartographicPolygon::OmniCartographicPolygon(Context* pContext, const pxr::SdfPath& path)
: _pContext(pContext)
, _path(path) {}
const pxr::SdfPath& OmniCartographicPolygon::getPath() const {
return _path;
}
std::vector<CesiumGeospatial::Cartographic> OmniCartographicPolygon::getCartographics() const {
const auto pGlobeAnchor = _pContext->getAssetRegistry().getGlobeAnchor(_path);
if (!pGlobeAnchor) {
return {};
}
const auto georeferencePath = pGlobeAnchor->getResolvedGeoreferencePath();
if (georeferencePath.IsEmpty()) {
return {};
}
const auto pGeoreference = _pContext->getAssetRegistry().getGeoreference(georeferencePath);
if (!pGeoreference) {
return {};
}
const auto cesiumCartographicPolygon = UsdUtil::getCesiumCartographicPolygon(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumCartographicPolygon)) {
return {};
}
pxr::VtArray<pxr::GfVec3f> points;
cesiumCartographicPolygon.GetPointsAttr().Get(&points);
std::vector<glm::dvec3> positionsLocal;
positionsLocal.reserve(points.size());
for (const auto& point : points) {
positionsLocal.push_back(glm::dvec3(UsdUtil::usdToGlmVector(point)));
}
const auto primLocalToEcefTransform = UsdUtil::computePrimLocalToEcefTransform(*_pContext, georeferencePath, _path);
std::vector<CesiumGeospatial::Cartographic> cartographics;
cartographics.reserve(positionsLocal.size());
for (const auto& positionLocal : positionsLocal) {
const auto positionEcef = glm::dvec3(primLocalToEcefTransform * glm::dvec4(positionLocal, 1.0));
const auto positionCartographic = pGeoreference->getEllipsoid().cartesianToCartographic(positionEcef);
if (!positionCartographic.has_value()) {
return {};
}
cartographics.push_back(positionCartographic.value());
}
return cartographics;
}
} // namespace cesium::omniverse
| 2,437 | C++ | 31.945946 | 120 | 0.72261 |
CesiumGS/cesium-omniverse/src/core/src/FabricFeaturesUtil.cpp | #include "cesium/omniverse/FabricFeaturesUtil.h"
#include "cesium/omniverse/FabricFeaturesInfo.h"
namespace cesium::omniverse::FabricFeaturesUtil {
FabricFeatureIdType getFeatureIdType(const FabricFeatureId& featureId) {
if (std::holds_alternative<std::monostate>(featureId.featureIdStorage)) {
return FabricFeatureIdType::INDEX;
} else if (std::holds_alternative<uint64_t>(featureId.featureIdStorage)) {
return FabricFeatureIdType::ATTRIBUTE;
} else if (std::holds_alternative<FabricTextureInfo>(featureId.featureIdStorage)) {
return FabricFeatureIdType::TEXTURE;
}
return FabricFeatureIdType::INDEX;
}
std::vector<FabricFeatureIdType> getFeatureIdTypes(const FabricFeaturesInfo& featuresInfo) {
const auto& featureIds = featuresInfo.featureIds;
std::vector<FabricFeatureIdType> featureIdTypes;
featureIdTypes.reserve(featureIds.size());
for (const auto& featureId : featureIds) {
featureIdTypes.push_back(getFeatureIdType(featureId));
}
return featureIdTypes;
}
std::vector<uint64_t> getSetIndexMapping(const FabricFeaturesInfo& featuresInfo, FabricFeatureIdType type) {
const auto& featureIds = featuresInfo.featureIds;
std::vector<uint64_t> setIndexMapping;
setIndexMapping.reserve(featureIds.size());
for (uint64_t i = 0; i < featureIds.size(); ++i) {
if (getFeatureIdType(featureIds[i]) == type) {
setIndexMapping.push_back(i);
}
}
return setIndexMapping;
}
bool hasFeatureIdType(const FabricFeaturesInfo& featuresInfo, FabricFeatureIdType type) {
const auto& featureIds = featuresInfo.featureIds;
for (const auto& featureId : featureIds) {
if (getFeatureIdType(featureId) == type) {
return true;
}
}
return false;
}
} // namespace cesium::omniverse::FabricFeaturesUtil
| 1,864 | C++ | 30.083333 | 108 | 0.719957 |
CesiumGS/cesium-omniverse/src/core/src/OmniTileMapServiceRasterOverlay.cpp | #include "cesium/omniverse/OmniTileMapServiceRasterOverlay.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumRasterOverlays/TileMapServiceRasterOverlay.h>
#include <CesiumUsdSchemas/tileMapServiceRasterOverlay.h>
namespace cesium::omniverse {
OmniTileMapServiceRasterOverlay::OmniTileMapServiceRasterOverlay(Context* pContext, const pxr::SdfPath& path)
: OmniRasterOverlay(pContext, path) {
reload();
}
CesiumRasterOverlays::RasterOverlay* OmniTileMapServiceRasterOverlay::getRasterOverlay() const {
return _pTileMapServiceRasterOverlay.get();
}
std::string OmniTileMapServiceRasterOverlay::getUrl() const {
const auto cesiumTileMapServiceRasterOverlay =
UsdUtil::getCesiumTileMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileMapServiceRasterOverlay)) {
return "";
}
std::string url;
cesiumTileMapServiceRasterOverlay.GetUrlAttr().Get(&url);
return url;
}
int OmniTileMapServiceRasterOverlay::getMinimumZoomLevel() const {
const auto cesiumTileMapServiceRasterOverlay =
UsdUtil::getCesiumTileMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileMapServiceRasterOverlay)) {
return 0;
}
int minimumZoomLevel;
cesiumTileMapServiceRasterOverlay.GetMinimumZoomLevelAttr().Get(&minimumZoomLevel);
return minimumZoomLevel;
}
int OmniTileMapServiceRasterOverlay::getMaximumZoomLevel() const {
const auto cesiumTileMapServiceRasterOverlay =
UsdUtil::getCesiumTileMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileMapServiceRasterOverlay)) {
return 10;
}
int maximumZoomLevel;
cesiumTileMapServiceRasterOverlay.GetMaximumZoomLevelAttr().Get(&maximumZoomLevel);
return maximumZoomLevel;
}
bool OmniTileMapServiceRasterOverlay::getSpecifyZoomLevels() const {
const auto cesiumTileMapServiceRasterOverlay =
UsdUtil::getCesiumTileMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumTileMapServiceRasterOverlay)) {
return false;
}
bool value;
cesiumTileMapServiceRasterOverlay.GetSpecifyZoomLevelsAttr().Get(&value);
return value;
}
void OmniTileMapServiceRasterOverlay::reload() {
const auto rasterOverlayName = UsdUtil::getName(_pContext->getUsdStage(), _path);
auto options = createRasterOverlayOptions();
options.loadErrorCallback = [this](const CesiumRasterOverlays::RasterOverlayLoadFailureDetails& error) {
_pContext->getLogger()->error(error.message);
};
CesiumRasterOverlays::TileMapServiceRasterOverlayOptions tmsOptions;
const auto specifyZoomLevels = getSpecifyZoomLevels();
if (specifyZoomLevels) {
tmsOptions.minimumLevel = getMinimumZoomLevel();
tmsOptions.maximumLevel = getMaximumZoomLevel();
}
_pTileMapServiceRasterOverlay = new CesiumRasterOverlays::TileMapServiceRasterOverlay(
rasterOverlayName, getUrl(), std::vector<CesiumAsync::IAssetAccessor::THeader>(), tmsOptions, options);
}
} // namespace cesium::omniverse
| 3,371 | C++ | 34.87234 | 111 | 0.767725 |
CesiumGS/cesium-omniverse/src/core/src/OmniGeoreference.cpp | #include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumGeospatial/LocalHorizontalCoordinateSystem.h>
#include <CesiumUsdSchemas/georeference.h>
#include <glm/glm.hpp>
#include <pxr/usd/usdGeom/tokens.h>
namespace cesium::omniverse {
OmniGeoreference::OmniGeoreference(Context* pContext, const pxr::SdfPath& path)
: _pContext(pContext)
, _path(path)
, _ellipsoid(CesiumGeospatial::Ellipsoid::WGS84) {}
const pxr::SdfPath& OmniGeoreference::getPath() const {
return _path;
}
CesiumGeospatial::Cartographic OmniGeoreference::getOrigin() const {
const auto cesiumGeoreference = UsdUtil::getCesiumGeoreference(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumGeoreference)) {
return {0.0, 0.0, 0.0};
}
double longitude;
double latitude;
double height;
cesiumGeoreference.GetGeoreferenceOriginLongitudeAttr().Get(&longitude);
cesiumGeoreference.GetGeoreferenceOriginLatitudeAttr().Get(&latitude);
cesiumGeoreference.GetGeoreferenceOriginHeightAttr().Get(&height);
return {glm::radians(longitude), glm::radians(latitude), height};
}
const CesiumGeospatial::Ellipsoid& OmniGeoreference::getEllipsoid() const {
return _ellipsoid;
}
CesiumGeospatial::LocalHorizontalCoordinateSystem OmniGeoreference::getLocalCoordinateSystem() const {
const auto origin = getOrigin();
const auto upAxis = UsdUtil::getUsdUpAxis(_pContext->getUsdStage());
const auto scaleInMeters = UsdUtil::getUsdMetersPerUnit(_pContext->getUsdStage());
if (upAxis == pxr::UsdGeomTokens->z) {
return {
origin,
CesiumGeospatial::LocalDirection::East,
CesiumGeospatial::LocalDirection::North,
CesiumGeospatial::LocalDirection::Up,
scaleInMeters,
_ellipsoid,
};
}
return {
origin,
CesiumGeospatial::LocalDirection::East,
CesiumGeospatial::LocalDirection::Up,
CesiumGeospatial::LocalDirection::South,
scaleInMeters,
_ellipsoid,
};
}
} // namespace cesium::omniverse
| 2,209 | C++ | 29.694444 | 102 | 0.709371 |
CesiumGS/cesium-omniverse/src/core/src/CesiumIonSession.cpp | // Copyright 2023 CesiumGS, Inc. and Contributors
#include "cesium/omniverse/CesiumIonSession.h"
#include "cesium/omniverse/Broadcast.h"
#include "cesium/omniverse/SettingsWrapper.h"
#include <CesiumUtility/Uri.h>
#include <utility>
using namespace CesiumAsync;
using namespace CesiumIonClient;
using namespace cesium::omniverse;
CesiumIonSession::CesiumIonSession(
const CesiumAsync::AsyncSystem& asyncSystem,
std::shared_ptr<CesiumAsync::IAssetAccessor> pAssetAccessor,
std::string ionServerUrl,
std::string ionApiUrl,
int64_t ionApplicationId)
: _asyncSystem(asyncSystem)
, _pAssetAccessor(std::move(pAssetAccessor))
, _connection(std::nullopt)
, _profile(std::nullopt)
, _assets(std::nullopt)
, _tokens(std::nullopt)
, _isConnecting(false)
, _isResuming(false)
, _isLoadingProfile(false)
, _isLoadingAssets(false)
, _isLoadingTokens(false)
, _loadProfileQueued(false)
, _loadAssetsQueued(false)
, _loadTokensQueued(false)
, _authorizeUrl()
, _ionServerUrl(std::move(ionServerUrl))
, _ionApiUrl(std::move(ionApiUrl))
, _ionApplicationId(ionApplicationId) {}
void CesiumIonSession::connect() {
if (this->isConnecting() || this->isConnected() || this->isResuming()) {
return;
}
this->_isConnecting = true;
Connection::authorize(
this->_asyncSystem,
this->_pAssetAccessor,
"Cesium for Omniverse",
_ionApplicationId,
"/cesium-for-omniverse/oauth2/callback",
{"assets:list", "assets:read", "profile:read", "tokens:read", "tokens:write", "geocode"},
[this](const std::string& url) {
// NOTE: We open the browser in the Python code. Check in the sign in widget's on_update_frame function.
this->_authorizeUrl = url;
},
_ionApiUrl,
CesiumUtility::Uri::resolve(_ionServerUrl, "oauth"))
.thenInMainThread([this](CesiumIonClient::Connection&& connection) {
this->_isConnecting = false;
this->_connection = std::move(connection);
Settings::AccessToken token;
token.ionApiUrl = _ionApiUrl;
token.accessToken = this->_connection.value().getAccessToken();
Settings::setAccessToken(token);
Broadcast::connectionUpdated();
})
.catchInMainThread([this]([[maybe_unused]] std::exception&& e) {
this->_isConnecting = false;
this->_connection = std::nullopt;
Broadcast::connectionUpdated();
});
}
void CesiumIonSession::resume() {
if (this->isConnecting() || this->isConnected() || this->isResuming()) {
return;
}
auto tokens = Settings::getAccessTokens();
if (tokens.size() < 1) {
// No existing session to resume.
return;
}
std::string accessToken;
for (const auto& token : tokens) {
if (token.ionApiUrl == _ionApiUrl) {
accessToken = token.accessToken;
break;
}
}
if (accessToken.empty()) {
// No existing session to resume.
return;
}
this->_isResuming = true;
this->_connection = Connection(this->_asyncSystem, this->_pAssetAccessor, accessToken);
// Verify that the connection actually works.
this->_connection.value()
.me()
.thenInMainThread([this](Response<Profile>&& response) {
if (!response.value.has_value()) {
this->_connection.reset();
}
this->_isResuming = false;
Broadcast::connectionUpdated();
})
.catchInMainThread([this]([[maybe_unused]] std::exception&& e) {
this->_isResuming = false;
this->_connection.reset();
Broadcast::connectionUpdated();
});
}
void CesiumIonSession::disconnect() {
this->_connection.reset();
this->_profile.reset();
this->_assets.reset();
this->_tokens.reset();
Settings::removeAccessToken(_ionApiUrl);
Broadcast::connectionUpdated();
Broadcast::profileUpdated();
Broadcast::assetsUpdated();
Broadcast::tokensUpdated();
}
void CesiumIonSession::tick() {
this->_asyncSystem.dispatchMainThreadTasks();
}
void CesiumIonSession::refreshProfile() {
if (!this->_connection || this->_isLoadingProfile) {
this->_loadProfileQueued = true;
return;
}
this->_isLoadingProfile = true;
this->_loadProfileQueued = false;
this->_connection->me()
.thenInMainThread([this](Response<Profile>&& profile) {
this->_isLoadingProfile = false;
this->_profile = std::move(profile.value);
Broadcast::profileUpdated();
this->refreshProfileIfNeeded();
})
.catchInMainThread([this]([[maybe_unused]] std::exception&& e) {
this->_isLoadingProfile = false;
this->_profile = std::nullopt;
Broadcast::profileUpdated();
this->refreshProfileIfNeeded();
});
}
void CesiumIonSession::refreshAssets() {
if (!this->_connection || this->_isLoadingAssets) {
return;
}
this->_isLoadingAssets = true;
this->_loadAssetsQueued = false;
this->_connection->assets()
.thenInMainThread([this](Response<Assets>&& assets) {
this->_isLoadingAssets = false;
this->_assets = std::move(assets.value);
Broadcast::assetsUpdated();
this->refreshAssetsIfNeeded();
})
.catchInMainThread([this]([[maybe_unused]] std::exception&& e) {
this->_isLoadingAssets = false;
this->_assets = std::nullopt;
Broadcast::assetsUpdated();
this->refreshAssetsIfNeeded();
});
}
void CesiumIonSession::refreshTokens() {
if (!this->_connection || this->_isLoadingTokens) {
return;
}
this->_isLoadingTokens = true;
this->_loadTokensQueued = false;
this->_connection->tokens()
.thenInMainThread([this](Response<TokenList>&& tokens) {
this->_isLoadingTokens = false;
this->_tokens = tokens.value ? std::make_optional(std::move(tokens.value.value().items)) : std::nullopt;
Broadcast::tokensUpdated();
this->refreshTokensIfNeeded();
})
.catchInMainThread([this]([[maybe_unused]] std::exception&& e) {
this->_isLoadingTokens = false;
this->_tokens = std::nullopt;
Broadcast::tokensUpdated();
this->refreshTokensIfNeeded();
});
}
const std::optional<CesiumIonClient::Connection>& CesiumIonSession::getConnection() const {
return this->_connection;
}
const CesiumIonClient::Profile& CesiumIonSession::getProfile() {
static const CesiumIonClient::Profile empty{};
if (this->_profile) {
return *this->_profile;
} else {
this->refreshProfile();
return empty;
}
}
const CesiumIonClient::Assets& CesiumIonSession::getAssets() {
static const CesiumIonClient::Assets empty;
if (this->_assets) {
return *this->_assets;
} else {
this->refreshAssets();
return empty;
}
}
const std::vector<CesiumIonClient::Token>& CesiumIonSession::getTokens() {
static const std::vector<CesiumIonClient::Token> empty;
if (this->_tokens) {
return *this->_tokens;
} else {
this->refreshTokens();
return empty;
}
}
bool CesiumIonSession::refreshProfileIfNeeded() {
if (this->_loadProfileQueued || !this->_profile.has_value()) {
this->refreshProfile();
}
return this->isProfileLoaded();
}
bool CesiumIonSession::refreshAssetsIfNeeded() {
if (this->_loadAssetsQueued || !this->_assets.has_value()) {
this->refreshAssets();
}
return this->isAssetListLoaded();
}
bool CesiumIonSession::refreshTokensIfNeeded() {
if (this->_loadTokensQueued || !this->_tokens.has_value()) {
this->refreshTokens();
}
return this->isTokenListLoaded();
}
Future<Response<Token>> CesiumIonSession::findToken(const std::string& token) const {
if (!this->_connection) {
return _asyncSystem.createResolvedFuture(Response<Token>(0, "NOTCONNECTED", "Not connected to Cesium ion."));
}
std::optional<std::string> maybeTokenID = Connection::getIdFromToken(token);
if (!maybeTokenID) {
return _asyncSystem.createResolvedFuture(Response<Token>(0, "INVALIDTOKEN", "The token is not valid."));
}
return this->_connection->token(*maybeTokenID);
}
| 8,547 | C++ | 29.204947 | 117 | 0.615304 |
CesiumGS/cesium-omniverse/src/core/src/Logger.cpp | #include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/CppUtil.h"
#include "cesium/omniverse/LoggerSink.h"
namespace cesium::omniverse {
Logger::Logger()
: spdlog::logger(
std::string("cesium-omniverse"),
spdlog::sinks_init_list{
std::make_shared<LoggerSink>(omni::log::Level::eVerbose),
std::make_shared<LoggerSink>(omni::log::Level::eInfo),
std::make_shared<LoggerSink>(omni::log::Level::eWarn),
std::make_shared<LoggerSink>(omni::log::Level::eError),
std::make_shared<LoggerSink>(omni::log::Level::eFatal),
}) {}
} // namespace cesium::omniverse
| 666 | C++ | 32.349998 | 71 | 0.618619 |
CesiumGS/cesium-omniverse/src/core/src/GltfUtil.cpp | #include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/DataType.h"
#include "cesium/omniverse/FabricFeaturesInfo.h"
#include "cesium/omniverse/FabricMaterialInfo.h"
#include "cesium/omniverse/FabricTextureInfo.h"
#include "cesium/omniverse/FabricVertexAttributeDescriptor.h"
#include <CesiumGltf/Material.h>
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <CesiumGltf/Accessor.h>
#include <CesiumGltf/AccessorView.h>
#include <CesiumGltf/ExtensionExtMeshFeatures.h>
#include <CesiumGltf/ExtensionKhrMaterialsUnlit.h>
#include <CesiumGltf/ExtensionKhrTextureTransform.h>
#include <CesiumGltf/FeatureIdTexture.h>
#include <CesiumGltf/FeatureIdTextureView.h>
#include <CesiumGltf/Model.h>
#include <CesiumGltf/PropertyTextureProperty.h>
#include <CesiumGltf/TextureInfo.h>
#include <spdlog/fmt/fmt.h>
#include <charconv>
#include <numeric>
#include <optional>
namespace cesium::omniverse::GltfUtil {
namespace {
const CesiumGltf::Material defaultMaterial;
const CesiumGltf::MaterialPBRMetallicRoughness defaultPbrMetallicRoughness;
const CesiumGltf::Sampler defaultSampler;
const CesiumGltf::ExtensionKhrTextureTransform defaultTextureTransform;
const CesiumGltf::TextureInfo defaultTextureInfo;
template <typename IndexType>
IndicesAccessor getIndicesAccessor(
const CesiumGltf::MeshPrimitive& primitive,
const CesiumGltf::AccessorView<IndexType>& indicesAccessorView) {
if (indicesAccessorView.status() != CesiumGltf::AccessorViewStatus::Valid) {
return {};
}
if (primitive.mode == CesiumGltf::MeshPrimitive::Mode::TRIANGLES) {
if (indicesAccessorView.size() % 3 != 0) {
return {};
}
return IndicesAccessor(indicesAccessorView);
}
if (primitive.mode == CesiumGltf::MeshPrimitive::Mode::TRIANGLE_STRIP) {
if (indicesAccessorView.size() <= 2) {
return {};
}
return IndicesAccessor::FromTriangleStrips(indicesAccessorView);
}
if (primitive.mode == CesiumGltf::MeshPrimitive::Mode::TRIANGLE_FAN) {
if (indicesAccessorView.size() <= 2) {
return {};
}
return IndicesAccessor::FromTriangleFans(indicesAccessorView);
}
return {};
}
CesiumGltf::AccessorView<glm::fvec2> getTexcoordsView(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const std::string& semantic,
uint64_t setIndex) {
const auto it = primitive.attributes.find(fmt::format("{}_{}", semantic, setIndex));
if (it == primitive.attributes.end()) {
return {};
}
const auto pTexcoordAccessor = model.getSafe(&model.accessors, it->second);
if (!pTexcoordAccessor) {
return {};
}
const auto texcoordsView = CesiumGltf::AccessorView<glm::fvec2>(model, *pTexcoordAccessor);
if (texcoordsView.status() != CesiumGltf::AccessorViewStatus::Valid) {
return {};
}
return texcoordsView;
}
CesiumGltf::AccessorView<glm::fvec3>
getNormalsView(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
const auto it = primitive.attributes.find("NORMAL");
if (it == primitive.attributes.end()) {
return {};
}
const auto pNormalAccessor = model.getSafe(&model.accessors, it->second);
if (!pNormalAccessor) {
return {};
}
const auto normalsView = CesiumGltf::AccessorView<glm::fvec3>(model, *pNormalAccessor);
if (normalsView.status() != CesiumGltf::AccessorViewStatus::Valid) {
return {};
}
return normalsView;
}
CesiumGltf::AccessorView<glm::fvec3>
getPositionsView(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
const auto it = primitive.attributes.find("POSITION");
if (it == primitive.attributes.end()) {
return {};
}
const auto pPositionAccessor = model.getSafe(&model.accessors, it->second);
if (!pPositionAccessor) {
return {};
}
const auto positionsView = CesiumGltf::AccessorView<glm::fvec3>(model, *pPositionAccessor);
if (positionsView.status() != CesiumGltf::AccessorViewStatus::Valid) {
return {};
}
return positionsView;
}
TexcoordsAccessor getTexcoords(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const std::string& semantic,
uint64_t setIndex,
bool flipVertical) {
const auto texcoordsView = getTexcoordsView(model, primitive, semantic, setIndex);
if (texcoordsView.status() != CesiumGltf::AccessorViewStatus::Valid) {
return {};
}
return {texcoordsView, flipVertical};
}
template <typename VertexColorType>
VertexColorsAccessor getVertexColorsAccessor(const CesiumGltf::Model& model, const CesiumGltf::Accessor& accessor) {
CesiumGltf::AccessorView<VertexColorType> view(model, accessor);
if (view.status() == CesiumGltf::AccessorViewStatus::Valid) {
return VertexColorsAccessor(view);
}
return {};
}
double getAlphaCutoff(const CesiumGltf::Material& material) {
return material.alphaCutoff;
}
FabricAlphaMode getAlphaMode(const CesiumGltf::Material& material) {
if (material.alphaMode == CesiumGltf::Material::AlphaMode::OPAQUE) {
return FabricAlphaMode::OPAQUE;
} else if (material.alphaMode == CesiumGltf::Material::AlphaMode::MASK) {
return FabricAlphaMode::MASK;
} else if (material.alphaMode == CesiumGltf::Material::AlphaMode::BLEND) {
return FabricAlphaMode::BLEND;
}
return FabricAlphaMode::OPAQUE;
}
double getBaseAlpha(const CesiumGltf::MaterialPBRMetallicRoughness& pbrMetallicRoughness) {
return pbrMetallicRoughness.baseColorFactor[3];
}
glm::dvec3 getBaseColorFactor(const CesiumGltf::MaterialPBRMetallicRoughness& pbrMetallicRoughness) {
return {
pbrMetallicRoughness.baseColorFactor[0],
pbrMetallicRoughness.baseColorFactor[1],
pbrMetallicRoughness.baseColorFactor[2],
};
}
glm::dvec3 getEmissiveFactor(const CesiumGltf::Material& material) {
return {
material.emissiveFactor[0],
material.emissiveFactor[1],
material.emissiveFactor[2],
};
}
double getMetallicFactor(const CesiumGltf::MaterialPBRMetallicRoughness& pbrMetallicRoughness) {
return pbrMetallicRoughness.metallicFactor;
}
double getRoughnessFactor(const CesiumGltf::MaterialPBRMetallicRoughness& pbrMetallicRoughness) {
return pbrMetallicRoughness.roughnessFactor;
}
bool getDoubleSided(const CesiumGltf::Material& material) {
return material.doubleSided;
}
int32_t getWrapS(const CesiumGltf::Sampler& sampler) {
return sampler.wrapS;
}
int32_t getWrapT(const CesiumGltf::Sampler& sampler) {
return sampler.wrapT;
}
glm::dvec2 getTexcoordOffset(const CesiumGltf::ExtensionKhrTextureTransform& textureTransform) {
const auto& offset = textureTransform.offset;
return {offset[0], offset[1]};
}
double getTexcoordRotation(const CesiumGltf::ExtensionKhrTextureTransform& textureTransform) {
return textureTransform.rotation;
}
glm::dvec2 getTexcoordScale(const CesiumGltf::ExtensionKhrTextureTransform& textureTransform) {
const auto& scale = textureTransform.scale;
return {scale[0], scale[1]};
}
uint64_t getTexcoordSetIndex(const CesiumGltf::TextureInfo& textureInfo) {
return static_cast<uint64_t>(textureInfo.index);
}
double getDefaultAlphaCutoff() {
return getAlphaCutoff(defaultMaterial);
}
FabricAlphaMode getDefaultAlphaMode() {
return getAlphaMode(defaultMaterial);
}
double getDefaultBaseAlpha() {
return getBaseAlpha(defaultPbrMetallicRoughness);
}
glm::dvec3 getDefaultBaseColorFactor() {
return getBaseColorFactor(defaultPbrMetallicRoughness);
}
glm::dvec3 getDefaultEmissiveFactor() {
return getEmissiveFactor(defaultMaterial);
}
double getDefaultMetallicFactor() {
return getMetallicFactor(defaultPbrMetallicRoughness);
}
double getDefaultRoughnessFactor() {
return getRoughnessFactor(defaultPbrMetallicRoughness);
}
bool getDefaultDoubleSided() {
return getDoubleSided(defaultMaterial);
}
glm::dvec2 getDefaultTexcoordOffset() {
return getTexcoordOffset(defaultTextureTransform);
}
double getDefaultTexcoordRotation() {
return getTexcoordRotation(defaultTextureTransform);
}
glm::dvec2 getDefaultTexcoordScale() {
return getTexcoordScale(defaultTextureTransform);
}
uint64_t getDefaultTexcoordSetIndex() {
return getTexcoordSetIndex(defaultTextureInfo);
}
int32_t getDefaultWrapS() {
return getWrapS(defaultSampler);
}
int32_t getDefaultWrapT() {
return getWrapT(defaultSampler);
}
FabricTextureInfo getTextureInfo(const CesiumGltf::Model& model, const CesiumGltf::TextureInfo& textureInfoGltf) {
FabricTextureInfo textureInfo = getDefaultTextureInfo();
textureInfo.setIndex = static_cast<uint64_t>(textureInfoGltf.texCoord);
const auto pTextureTransform = textureInfoGltf.getExtension<CesiumGltf::ExtensionKhrTextureTransform>();
if (pTextureTransform) {
textureInfo.offset = getTexcoordOffset(*pTextureTransform);
textureInfo.rotation = getTexcoordRotation(*pTextureTransform);
textureInfo.scale = getTexcoordScale(*pTextureTransform);
}
const auto pTexture = model.getSafe(&model.textures, textureInfoGltf.index);
if (pTexture) {
const auto pSampler = model.getSafe(&model.samplers, pTexture->sampler);
if (pSampler) {
textureInfo.wrapS = getWrapS(*pSampler);
textureInfo.wrapT = getWrapT(*pSampler);
}
}
return textureInfo;
}
template <typename T> std::vector<uint8_t> getChannels(const T& textureInfoWithChannels) {
std::vector<uint8_t> channels;
channels.reserve(textureInfoWithChannels.channels.size());
for (const auto channel : textureInfoWithChannels.channels) {
channels.push_back(static_cast<uint8_t>(channel));
}
return channels;
}
FabricTextureInfo
getFeatureIdTextureInfo(const CesiumGltf::Model& model, const CesiumGltf::FeatureIdTexture& featureIdTexture) {
FabricTextureInfo textureInfo = getTextureInfo(model, featureIdTexture);
textureInfo.channels = getChannels(featureIdTexture);
return textureInfo;
}
const CesiumGltf::ImageCesium* getImageCesium(const CesiumGltf::Model& model, const CesiumGltf::Texture& texture) {
const auto pImage = model.getSafe(&model.images, texture.source);
if (pImage) {
return &pImage->cesium;
}
return nullptr;
}
std::pair<std::string, uint64_t> parseAttributeName(const std::string& attributeName) {
auto searchPosition = static_cast<int>(attributeName.size()) - 1;
auto lastUnderscorePosition = -1;
while (searchPosition > 0) {
const auto character = attributeName[static_cast<uint64_t>(searchPosition)];
if (!isdigit(character)) {
if (character == '_') {
lastUnderscorePosition = searchPosition;
}
break;
}
--searchPosition;
}
std::string semantic;
uint64_t setIndexU64 = 0;
if (lastUnderscorePosition == -1) {
semantic = attributeName;
} else {
semantic = attributeName.substr(0, static_cast<uint64_t>(lastUnderscorePosition));
std::from_chars(
attributeName.data() + lastUnderscorePosition + 1,
attributeName.data() + attributeName.size(),
setIndexU64);
}
return std::make_pair(semantic, setIndexU64);
}
std::optional<DataType> getVertexAttributeTypeFromGltf(const CesiumGltf::Accessor& accessor) {
const auto& type = accessor.type;
const auto componentType = accessor.componentType;
const auto normalized = accessor.normalized;
if (type == CesiumGltf::Accessor::Type::SCALAR) {
if (componentType == CesiumGltf::Accessor::ComponentType::BYTE) {
return normalized ? DataType::INT8_NORM : DataType::INT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_BYTE) {
return normalized ? DataType::UINT8_NORM : DataType::UINT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::SHORT) {
return normalized ? DataType::INT16_NORM : DataType::INT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_SHORT) {
return normalized ? DataType::UINT16_NORM : DataType::UINT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::FLOAT) {
return DataType::FLOAT32;
}
} else if (type == CesiumGltf::Accessor::Type::VEC2) {
if (componentType == CesiumGltf::Accessor::ComponentType::BYTE) {
return normalized ? DataType::VEC2_INT8_NORM : DataType::VEC2_INT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_BYTE) {
return normalized ? DataType::VEC2_UINT8_NORM : DataType::VEC2_UINT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::SHORT) {
return normalized ? DataType::VEC2_INT16_NORM : DataType::VEC2_INT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_SHORT) {
return normalized ? DataType::VEC2_UINT16_NORM : DataType::VEC2_UINT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::FLOAT) {
return DataType::VEC2_FLOAT32;
}
} else if (type == CesiumGltf::Accessor::Type::VEC3) {
if (componentType == CesiumGltf::Accessor::ComponentType::BYTE) {
return normalized ? DataType::VEC3_INT8_NORM : DataType::VEC3_INT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_BYTE) {
return normalized ? DataType::VEC3_UINT8_NORM : DataType::VEC3_UINT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::SHORT) {
return normalized ? DataType::VEC3_INT16_NORM : DataType::VEC3_INT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_SHORT) {
return normalized ? DataType::VEC3_UINT16_NORM : DataType::VEC3_UINT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::FLOAT) {
return DataType::VEC3_FLOAT32;
}
} else if (type == CesiumGltf::Accessor::Type::VEC4) {
if (componentType == CesiumGltf::Accessor::ComponentType::BYTE) {
return normalized ? DataType::VEC4_INT8_NORM : DataType::VEC4_INT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_BYTE) {
return normalized ? DataType::VEC4_UINT8_NORM : DataType::VEC4_UINT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::SHORT) {
return normalized ? DataType::VEC4_INT16_NORM : DataType::VEC4_INT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_SHORT) {
return normalized ? DataType::VEC4_UINT16_NORM : DataType::VEC4_UINT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::FLOAT) {
return DataType::VEC4_FLOAT32;
}
} else if (type == CesiumGltf::Accessor::Type::MAT2) {
if (componentType == CesiumGltf::Accessor::ComponentType::BYTE) {
return normalized ? DataType::MAT2_INT8_NORM : DataType::MAT2_INT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_BYTE) {
return normalized ? DataType::MAT2_UINT8_NORM : DataType::MAT2_UINT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::SHORT) {
return normalized ? DataType::MAT2_INT16_NORM : DataType::MAT2_INT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_SHORT) {
return normalized ? DataType::MAT2_UINT16_NORM : DataType::MAT2_UINT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::FLOAT) {
return DataType::MAT2_FLOAT32;
}
} else if (type == CesiumGltf::Accessor::Type::MAT3) {
if (componentType == CesiumGltf::Accessor::ComponentType::BYTE) {
return normalized ? DataType::MAT3_INT8_NORM : DataType::MAT3_INT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_BYTE) {
return normalized ? DataType::MAT3_UINT8_NORM : DataType::MAT3_UINT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::SHORT) {
return normalized ? DataType::MAT3_INT16_NORM : DataType::MAT3_INT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_SHORT) {
return normalized ? DataType::MAT3_UINT16_NORM : DataType::MAT3_UINT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::FLOAT) {
return DataType::MAT3_FLOAT32;
}
} else if (type == CesiumGltf::Accessor::Type::MAT4) {
if (componentType == CesiumGltf::Accessor::ComponentType::BYTE) {
return normalized ? DataType::MAT4_INT8_NORM : DataType::MAT4_INT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_BYTE) {
return normalized ? DataType::MAT4_UINT8_NORM : DataType::MAT4_UINT8;
} else if (componentType == CesiumGltf::Accessor::ComponentType::SHORT) {
return normalized ? DataType::MAT4_INT16_NORM : DataType::MAT4_INT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::UNSIGNED_SHORT) {
return normalized ? DataType::MAT4_UINT16_NORM : DataType::MAT4_UINT16;
} else if (componentType == CesiumGltf::Accessor::ComponentType::FLOAT) {
return DataType::MAT4_FLOAT32;
}
}
return std::nullopt;
}
} // namespace
PositionsAccessor getPositions(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
const auto positionsView = getPositionsView(model, primitive);
if (positionsView.status() != CesiumGltf::AccessorViewStatus::Valid) {
return {};
}
return {positionsView};
}
std::optional<std::array<glm::dvec3, 2>>
getExtent(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
const auto it = primitive.attributes.find("POSITION");
if (it == primitive.attributes.end()) {
return std::nullopt;
}
auto pPositionAccessor = model.getSafe(&model.accessors, it->second);
if (!pPositionAccessor) {
return std::nullopt;
}
const auto& min = pPositionAccessor->min;
const auto& max = pPositionAccessor->max;
if (min.size() != 3 || max.size() != 3) {
return std::nullopt;
}
return std::array<glm::dvec3, 2>{{glm::dvec3(min[0], min[1], min[2]), glm::dvec3(max[0], max[1], max[2])}};
}
IndicesAccessor getIndices(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const PositionsAccessor& positions) {
const auto pIndicesAccessor = model.getSafe(&model.accessors, primitive.indices);
if (!pIndicesAccessor) {
return {positions.size()};
}
if (pIndicesAccessor->componentType == CesiumGltf::AccessorSpec::ComponentType::UNSIGNED_BYTE) {
CesiumGltf::AccessorView<uint8_t> view(model, *pIndicesAccessor);
return getIndicesAccessor(primitive, view);
} else if (pIndicesAccessor->componentType == CesiumGltf::AccessorSpec::ComponentType::UNSIGNED_SHORT) {
CesiumGltf::AccessorView<uint16_t> view(model, *pIndicesAccessor);
return getIndicesAccessor(primitive, view);
} else if (pIndicesAccessor->componentType == CesiumGltf::AccessorSpec::ComponentType::UNSIGNED_INT) {
CesiumGltf::AccessorView<uint32_t> view(model, *pIndicesAccessor);
return getIndicesAccessor(primitive, view);
}
return {};
}
FaceVertexCountsAccessor getFaceVertexCounts(const IndicesAccessor& indices) {
return {indices.size() / 3};
}
NormalsAccessor getNormals(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const PositionsAccessor& positions,
const IndicesAccessor& indices,
bool smoothNormals) {
const auto normalsView = getNormalsView(model, primitive);
if (normalsView.status() == CesiumGltf::AccessorViewStatus::Valid) {
return {normalsView};
}
if (smoothNormals) {
return NormalsAccessor::GenerateSmooth(positions, indices);
}
// Otherwise if normals are missing and smoothNormals is false Omniverse will generate flat normals for us automatically
return {};
}
TexcoordsAccessor
getTexcoords(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive, uint64_t setIndex) {
return getTexcoords(model, primitive, "TEXCOORD", setIndex, true);
}
TexcoordsAccessor getRasterOverlayTexcoords(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
uint64_t setIndex) {
return getTexcoords(model, primitive, "_CESIUMOVERLAY", setIndex, false);
}
VertexColorsAccessor
getVertexColors(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive, uint64_t setIndex) {
const auto vertexColorAttribute = primitive.attributes.find(fmt::format("{}_{}", "COLOR", setIndex));
if (vertexColorAttribute == primitive.attributes.end()) {
return {};
}
const auto pVertexColorAccessor = model.getSafe(&model.accessors, vertexColorAttribute->second);
if (!pVertexColorAccessor) {
return {};
}
if (pVertexColorAccessor->componentType == CesiumGltf::AccessorSpec::ComponentType::UNSIGNED_BYTE) {
if (pVertexColorAccessor->type == CesiumGltf::AccessorSpec::Type::VEC3) {
return getVertexColorsAccessor<glm::u8vec3>(model, *pVertexColorAccessor);
} else if (pVertexColorAccessor->type == CesiumGltf::AccessorSpec::Type::VEC4) {
return getVertexColorsAccessor<glm::u8vec4>(model, *pVertexColorAccessor);
}
} else if (pVertexColorAccessor->componentType == CesiumGltf::AccessorSpec::ComponentType::UNSIGNED_SHORT) {
if (pVertexColorAccessor->type == CesiumGltf::AccessorSpec::Type::VEC3) {
return getVertexColorsAccessor<glm::u16vec3>(model, *pVertexColorAccessor);
} else if (pVertexColorAccessor->type == CesiumGltf::AccessorSpec::Type::VEC4) {
return getVertexColorsAccessor<glm::u16vec4>(model, *pVertexColorAccessor);
}
} else if (pVertexColorAccessor->componentType == CesiumGltf::AccessorSpec::ComponentType::FLOAT) {
if (pVertexColorAccessor->type == CesiumGltf::AccessorSpec::Type::VEC3) {
return getVertexColorsAccessor<glm::fvec3>(model, *pVertexColorAccessor);
} else if (pVertexColorAccessor->type == CesiumGltf::AccessorSpec::Type::VEC4) {
return getVertexColorsAccessor<glm::fvec4>(model, *pVertexColorAccessor);
}
}
return {};
}
VertexIdsAccessor getVertexIds(const PositionsAccessor& positionsAccessor) {
return {positionsAccessor.size()};
}
const CesiumGltf::ImageCesium*
getBaseColorTextureImage(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
if (!hasMaterial(primitive)) {
return nullptr;
}
const auto pMaterial = model.getSafe(&model.materials, primitive.material);
if (!pMaterial) {
return nullptr;
}
const auto& pbrMetallicRoughness = pMaterial->pbrMetallicRoughness;
if (pbrMetallicRoughness.has_value() && pbrMetallicRoughness.value().baseColorTexture.has_value()) {
const auto index = pbrMetallicRoughness.value().baseColorTexture.value().index;
const auto pBaseColorTexture = model.getSafe(&model.textures, index);
if (pBaseColorTexture) {
return getImageCesium(model, *pBaseColorTexture);
}
}
return nullptr;
}
const CesiumGltf::ImageCesium* getFeatureIdTextureImage(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
uint64_t featureIdSetIndex) {
const auto pMeshFeatures = primitive.getExtension<CesiumGltf::ExtensionExtMeshFeatures>();
if (!pMeshFeatures) {
return nullptr;
}
const auto pFeatureId = model.getSafe(&pMeshFeatures->featureIds, static_cast<int32_t>(featureIdSetIndex));
if (!pFeatureId) {
return nullptr;
}
if (!pFeatureId->texture.has_value()) {
return nullptr;
}
const auto featureIdTextureView = CesiumGltf::FeatureIdTextureView(model, pFeatureId->texture.value());
if (featureIdTextureView.status() != CesiumGltf::FeatureIdTextureViewStatus::Valid) {
return nullptr;
}
return featureIdTextureView.getImage();
}
FabricMaterialInfo getMaterialInfo(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
if (!hasMaterial(primitive)) {
return getDefaultMaterialInfo();
}
const auto pMaterial = model.getSafe(&model.materials, primitive.material);
if (!pMaterial) {
return getDefaultMaterialInfo();
}
// Ignore uninitialized member warning from gcc 11.2.0. This warning is not reported in gcc 11.4.0
#ifdef CESIUM_OMNI_GCC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
auto materialInfo = getDefaultMaterialInfo();
#ifdef CESIUM_OMNI_GCC
#pragma GCC diagnostic pop
#endif
materialInfo.alphaCutoff = getAlphaCutoff(*pMaterial);
materialInfo.alphaMode = getAlphaMode(*pMaterial);
materialInfo.emissiveFactor = getEmissiveFactor(*pMaterial);
materialInfo.doubleSided = getDoubleSided(*pMaterial);
const auto& pbrMetallicRoughness = pMaterial->pbrMetallicRoughness;
if (pbrMetallicRoughness.has_value()) {
materialInfo.baseAlpha = getBaseAlpha(pbrMetallicRoughness.value());
materialInfo.baseColorFactor = getBaseColorFactor(pbrMetallicRoughness.value());
materialInfo.metallicFactor = getMetallicFactor(pbrMetallicRoughness.value());
materialInfo.roughnessFactor = getRoughnessFactor(pbrMetallicRoughness.value());
if (pbrMetallicRoughness.value().baseColorTexture.has_value() && getBaseColorTextureImage(model, primitive)) {
materialInfo.baseColorTexture =
getTextureInfo(model, pbrMetallicRoughness.value().baseColorTexture.value());
}
}
if (pMaterial->hasExtension<CesiumGltf::ExtensionKhrMaterialsUnlit>()) {
// Unlit materials aren't supported in Omniverse yet but we can hard code the material values to something reasonable
materialInfo.metallicFactor = 0.0;
materialInfo.roughnessFactor = 1.0;
}
materialInfo.hasVertexColors = hasVertexColors(model, primitive, 0);
return materialInfo;
}
FabricFeaturesInfo getFeaturesInfo(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
const auto& pMeshFeatures = primitive.getExtension<CesiumGltf::ExtensionExtMeshFeatures>();
if (!pMeshFeatures) {
return {};
}
const auto& featureIds = pMeshFeatures->featureIds;
FabricFeaturesInfo featuresInfo;
featuresInfo.featureIds.reserve(featureIds.size());
for (const auto& featureId : featureIds) {
const auto nullFeatureId = CppUtil::castOptional<uint64_t>(featureId.nullFeatureId);
const auto featureCount = static_cast<uint64_t>(featureId.featureCount);
auto featureIdStorage = std::variant<std::monostate, uint64_t, FabricTextureInfo>();
if (featureId.attribute.has_value()) {
featureIdStorage = static_cast<uint64_t>(featureId.attribute.value());
} else if (featureId.texture.has_value()) {
featureIdStorage = getFeatureIdTextureInfo(model, featureId.texture.value());
} else {
featureIdStorage = std::monostate();
}
// In C++ 20 this can be emplace_back without the {}
featuresInfo.featureIds.push_back({nullFeatureId, featureCount, featureIdStorage});
}
return featuresInfo;
}
std::set<FabricVertexAttributeDescriptor>
getCustomVertexAttributes(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
constexpr std::array<std::string_view, 8> knownSemantics = {{
"POSITION",
"NORMAL",
"TANGENT",
"TEXCOORD",
"COLOR",
"JOINTS",
"WEIGHTS",
"_CESIUMOVERLAY",
}};
std::set<FabricVertexAttributeDescriptor> customVertexAttributes;
for (const auto& attribute : primitive.attributes) {
const auto& attributeName = attribute.first;
const auto [semantic, setIndex] = parseAttributeName(attributeName);
if (CppUtil::contains(knownSemantics, semantic)) {
continue;
}
auto pAccessor = model.getSafe(&model.accessors, static_cast<int32_t>(attribute.second));
if (!pAccessor) {
continue;
}
const auto valid = createAccessorView(model, *pAccessor, [](const auto& accessorView) {
return accessorView.status() == CesiumGltf::AccessorViewStatus::Valid;
});
if (!valid) {
continue;
}
const auto type = getVertexAttributeTypeFromGltf(*pAccessor);
if (!type.has_value()) {
continue;
}
const auto fabricAttributeNameStr = fmt::format("primvars:{}", attributeName);
const auto fabricAttributeName = omni::fabric::Token(fabricAttributeNameStr.c_str());
// In C++ 20 this can be emplace without the {}
customVertexAttributes.insert(FabricVertexAttributeDescriptor{
type.value(),
fabricAttributeName,
attributeName,
});
}
return customVertexAttributes;
}
const FabricMaterialInfo& getDefaultMaterialInfo() {
static const auto defaultInfo = FabricMaterialInfo{
getDefaultAlphaCutoff(),
getDefaultAlphaMode(),
getDefaultBaseAlpha(),
getDefaultBaseColorFactor(),
getDefaultEmissiveFactor(),
getDefaultMetallicFactor(),
getDefaultRoughnessFactor(),
getDefaultDoubleSided(),
false,
std::nullopt,
};
return defaultInfo;
}
const FabricTextureInfo& getDefaultTextureInfo() {
static const auto defaultInfo = FabricTextureInfo{
getDefaultTexcoordOffset(),
getDefaultTexcoordRotation(),
getDefaultTexcoordScale(),
getDefaultTexcoordSetIndex(),
getDefaultWrapS(),
getDefaultWrapT(),
true,
{},
};
return defaultInfo;
}
FabricTextureInfo getPropertyTexturePropertyInfo(
const CesiumGltf::Model& model,
const CesiumGltf::PropertyTextureProperty& propertyTextureProperty) {
FabricTextureInfo textureInfo = getTextureInfo(model, propertyTextureProperty);
textureInfo.channels = getChannels(propertyTextureProperty);
return textureInfo;
}
bool hasNormals(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive, bool smoothNormals) {
return smoothNormals || getNormalsView(model, primitive).status() == CesiumGltf::AccessorViewStatus::Valid;
}
bool hasTexcoords(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive, uint64_t setIndex) {
return getTexcoordsView(model, primitive, "TEXCOORD", setIndex).status() == CesiumGltf::AccessorViewStatus::Valid;
}
bool hasRasterOverlayTexcoords(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
uint64_t setIndex) {
return getTexcoordsView(model, primitive, "_CESIUMOVERLAY", setIndex).status() ==
CesiumGltf::AccessorViewStatus::Valid;
}
bool hasVertexColors(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive, uint64_t setIndex) {
return getVertexColors(model, primitive, setIndex).size() > 0;
}
bool hasMaterial(const CesiumGltf::MeshPrimitive& primitive) {
return primitive.material >= 0;
}
std::vector<uint64_t>
getTexcoordSetIndexes(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
auto setIndexes = std::vector<uint64_t>();
for (const auto& attribute : primitive.attributes) {
const auto [semantic, setIndex] = parseAttributeName(attribute.first);
if (semantic == "TEXCOORD") {
if (hasTexcoords(model, primitive, setIndex)) {
setIndexes.push_back(setIndex);
}
}
}
return setIndexes;
}
std::vector<uint64_t>
getRasterOverlayTexcoordSetIndexes(const CesiumGltf::Model& model, const CesiumGltf::MeshPrimitive& primitive) {
auto setIndexes = std::vector<uint64_t>();
for (const auto& attribute : primitive.attributes) {
const auto [semantic, setIndex] = parseAttributeName(attribute.first);
if (semantic == "_CESIUMOVERLAY") {
if (hasRasterOverlayTexcoords(model, primitive, setIndex)) {
setIndexes.push_back(setIndex);
}
}
}
return setIndexes;
}
CesiumGltf::Ktx2TranscodeTargets getKtx2TranscodeTargets() {
CesiumGltf::SupportedGpuCompressedPixelFormats supportedFormats;
// Only BCN compressed texture formats are supported in Omniverse
supportedFormats.ETC1_RGB = false;
supportedFormats.ETC2_RGBA = false;
supportedFormats.BC1_RGB = true;
supportedFormats.BC3_RGBA = true;
supportedFormats.BC4_R = true;
supportedFormats.BC5_RG = true;
supportedFormats.BC7_RGBA = true;
supportedFormats.PVRTC1_4_RGB = false;
supportedFormats.PVRTC1_4_RGBA = false;
supportedFormats.ASTC_4x4_RGBA = false;
supportedFormats.PVRTC2_4_RGB = false;
supportedFormats.PVRTC2_4_RGBA = false;
supportedFormats.ETC2_EAC_R11 = false;
supportedFormats.ETC2_EAC_RG11 = false;
return {supportedFormats, false};
}
} // namespace cesium::omniverse::GltfUtil
| 33,726 | C++ | 35.98136 | 125 | 0.698541 |
CesiumGS/cesium-omniverse/src/core/src/CesiumIonServerManager.cpp | #include "cesium/omniverse/CesiumIonServerManager.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Broadcast.h"
#include "cesium/omniverse/CesiumIonSession.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/CppUtil.h"
#include "cesium/omniverse/OmniData.h"
#include "cesium/omniverse/OmniIonRasterOverlay.h"
#include "cesium/omniverse/OmniIonServer.h"
#include "cesium/omniverse/OmniTileset.h"
#include "cesium/omniverse/TokenTroubleshootingDetails.h"
#include <CesiumIonClient/Connection.h>
namespace cesium::omniverse {
CesiumIonServerManager::CesiumIonServerManager(Context* pContext)
: _pContext(pContext) {}
void CesiumIonServerManager::onUpdateFrame() {
const auto& ionServers = _pContext->getAssetRegistry().getIonServers();
for (const auto& pIonServer : ionServers) {
pIonServer->getSession()->tick();
}
}
void CesiumIonServerManager::setProjectDefaultToken(const CesiumIonClient::Token& token) {
if (token.token.empty()) {
return;
}
const auto pCurrentIonServer = getCurrentIonServer();
if (!pCurrentIonServer) {
return;
}
pCurrentIonServer->setToken(token);
}
void CesiumIonServerManager::updateTokenTroubleshootingDetails(
int64_t ionAssetId,
const std::string& token,
uint64_t eventId,
TokenTroubleshootingDetails& details) {
const auto pSession = getCurrentIonSession();
if (!pSession) {
// TODO: Signal an error.
return;
}
details.showDetails = true;
const auto pConnection =
std::make_shared<CesiumIonClient::Connection>(pSession->getAsyncSystem(), pSession->getAssetAccessor(), token);
pConnection->me()
.thenInMainThread(
[ionAssetId, pConnection, &details](CesiumIonClient::Response<CesiumIonClient::Profile>&& profile) {
details.isValid = profile.value.has_value();
return pConnection->asset(ionAssetId);
})
.thenInMainThread([this, pConnection, &details](CesiumIonClient::Response<CesiumIonClient::Asset>&& asset) {
details.allowsAccessToAsset = asset.value.has_value();
const auto pIonSession = getCurrentIonSession();
pIonSession->resume();
const std::optional<CesiumIonClient::Connection>& userConnection = pIonSession->getConnection();
if (!userConnection) {
CesiumIonClient::Response<CesiumIonClient::TokenList> result{};
return pIonSession->getAsyncSystem().createResolvedFuture(std::move(result));
}
return userConnection.value().tokens();
})
.thenInMainThread(
[pConnection, &details, eventId](CesiumIonClient::Response<CesiumIonClient::TokenList>&& tokens) {
if (tokens.value.has_value()) {
details.associatedWithUserAccount = CppUtil::containsByMember(
tokens.value.value().items, &CesiumIonClient::Token::token, pConnection->getAccessToken());
}
Broadcast::sendMessageToBus(eventId);
});
}
void CesiumIonServerManager::updateAssetTroubleshootingDetails(
int64_t ionAssetId,
uint64_t eventId,
AssetTroubleshootingDetails& details) {
const auto pSession = getCurrentIonSession();
if (!pSession) {
return;
}
pSession->getConnection()
->asset(ionAssetId)
.thenInMainThread([eventId, &details](CesiumIonClient::Response<CesiumIonClient::Asset>&& asset) {
details.assetExistsInUserAccount = asset.value.has_value();
Broadcast::sendMessageToBus(eventId);
});
}
OmniIonServer* CesiumIonServerManager::getCurrentIonServer() const {
const auto pData = _pContext->getAssetRegistry().getFirstData();
if (!pData) {
return _pContext->getAssetRegistry().getFirstIonServer();
}
const auto selectedIonServerPath = pData->getSelectedIonServerPath();
if (selectedIonServerPath.IsEmpty()) {
return _pContext->getAssetRegistry().getFirstIonServer();
}
const auto pIonServer = _pContext->getAssetRegistry().getIonServer(selectedIonServerPath);
if (!pIonServer) {
return _pContext->getAssetRegistry().getFirstIonServer();
}
return pIonServer;
}
void CesiumIonServerManager::connectToIon() {
const auto pCurrentIonServer = getCurrentIonServer();
if (!pCurrentIonServer) {
return;
}
pCurrentIonServer->getSession()->connect();
}
std::shared_ptr<CesiumIonSession> CesiumIonServerManager::getCurrentIonSession() const {
// A lot of UI code will end up calling the session prior to us actually having a stage. The user won't see this
// but some major segfaults will occur without this check.
if (!_pContext->hasUsdStage()) {
return nullptr;
}
const auto pCurrentIonServer = getCurrentIonServer();
if (!pCurrentIonServer) {
return nullptr;
}
return pCurrentIonServer->getSession();
}
std::optional<CesiumIonClient::Token> CesiumIonServerManager::getDefaultToken() const {
const auto pCurrentIonServer = getCurrentIonServer();
if (!pCurrentIonServer) {
return std::nullopt;
}
const auto token = pCurrentIonServer->getToken();
if (token.token.empty()) {
return std::nullopt;
}
return token;
}
SetDefaultTokenResult CesiumIonServerManager::getSetDefaultTokenResult() const {
return _lastSetTokenResult;
}
bool CesiumIonServerManager::isDefaultTokenSet() const {
return getDefaultToken().has_value();
}
void CesiumIonServerManager::createToken(const std::string& name) {
const auto pCurrentIonServer = getCurrentIonServer();
if (!pCurrentIonServer) {
return;
}
const auto pConnection = pCurrentIonServer->getSession()->getConnection();
if (!pConnection.has_value()) {
_lastSetTokenResult = SetDefaultTokenResult{
SetDefaultTokenResultCode::NOT_CONNECTED_TO_ION,
std::string(SetDefaultTokenResultMessages::NOT_CONNECTED_TO_ION_MESSAGE),
};
return;
}
pConnection->createToken(name, {"assets:read"}, std::vector<int64_t>{1}, std::nullopt)
.thenInMainThread([this](CesiumIonClient::Response<CesiumIonClient::Token>&& response) {
if (response.value) {
setProjectDefaultToken(response.value.value());
_lastSetTokenResult = SetDefaultTokenResult{
SetDefaultTokenResultCode::OK,
std::string(SetDefaultTokenResultMessages::OK_MESSAGE),
};
} else {
_lastSetTokenResult = SetDefaultTokenResult{
SetDefaultTokenResultCode::CREATE_FAILED,
fmt::format(
SetDefaultTokenResultMessages::CREATE_FAILED_MESSAGE_BASE,
response.errorMessage,
response.errorCode),
};
}
Broadcast::setDefaultTokenComplete();
});
}
void CesiumIonServerManager::selectToken(const CesiumIonClient::Token& token) {
const auto pCurrentIonServer = getCurrentIonServer();
if (!pCurrentIonServer) {
return;
}
const auto& connection = pCurrentIonServer->getSession()->getConnection();
if (!connection.has_value()) {
_lastSetTokenResult = SetDefaultTokenResult{
SetDefaultTokenResultCode::NOT_CONNECTED_TO_ION,
std::string(SetDefaultTokenResultMessages::NOT_CONNECTED_TO_ION_MESSAGE),
};
} else {
setProjectDefaultToken(token);
_lastSetTokenResult = SetDefaultTokenResult{
SetDefaultTokenResultCode::OK,
std::string(SetDefaultTokenResultMessages::OK_MESSAGE),
};
}
Broadcast::setDefaultTokenComplete();
}
void CesiumIonServerManager::specifyToken(const std::string& token) {
const auto pCurrentIonServer = getCurrentIonServer();
if (!pCurrentIonServer) {
return;
}
const auto pSession = pCurrentIonServer->getSession();
pSession->findToken(token).thenInMainThread(
[this, token](CesiumIonClient::Response<CesiumIonClient::Token>&& response) {
if (response.value) {
setProjectDefaultToken(response.value.value());
} else {
CesiumIonClient::Token t;
t.token = token;
setProjectDefaultToken(t);
}
// We assume the user knows what they're doing if they specify a token not on their account.
_lastSetTokenResult = SetDefaultTokenResult{
SetDefaultTokenResultCode::OK,
std::string(SetDefaultTokenResultMessages::OK_MESSAGE),
};
Broadcast::setDefaultTokenComplete();
});
}
std::optional<AssetTroubleshootingDetails> CesiumIonServerManager::getAssetTroubleshootingDetails() const {
return _assetTroubleshootingDetails;
}
std::optional<TokenTroubleshootingDetails> CesiumIonServerManager::getAssetTokenTroubleshootingDetails() const {
return _assetTokenTroubleshootingDetails;
}
std::optional<TokenTroubleshootingDetails> CesiumIonServerManager::getDefaultTokenTroubleshootingDetails() const {
return _defaultTokenTroubleshootingDetails;
}
void CesiumIonServerManager::updateTroubleshootingDetails(
const pxr::SdfPath& tilesetPath,
int64_t tilesetIonAssetId,
uint64_t tokenEventId,
uint64_t assetEventId) {
const auto pTileset = _pContext->getAssetRegistry().getTileset(tilesetPath);
if (!pTileset) {
return;
}
_assetTroubleshootingDetails = AssetTroubleshootingDetails();
updateAssetTroubleshootingDetails(tilesetIonAssetId, assetEventId, _assetTroubleshootingDetails.value());
_defaultTokenTroubleshootingDetails = TokenTroubleshootingDetails();
const auto& defaultToken = getDefaultToken();
if (defaultToken.has_value()) {
const auto& token = defaultToken.value().token;
updateTokenTroubleshootingDetails(
tilesetIonAssetId, token, tokenEventId, _defaultTokenTroubleshootingDetails.value());
}
_assetTokenTroubleshootingDetails = TokenTroubleshootingDetails();
auto tilesetIonAccessToken = pTileset->getIonAccessToken();
if (!tilesetIonAccessToken.token.empty()) {
updateTokenTroubleshootingDetails(
tilesetIonAssetId, tilesetIonAccessToken.token, tokenEventId, _assetTokenTroubleshootingDetails.value());
}
}
void CesiumIonServerManager::updateTroubleshootingDetails(
const pxr::SdfPath& tilesetPath,
[[maybe_unused]] int64_t tilesetIonAssetId,
int64_t rasterOverlayIonAssetId,
uint64_t tokenEventId,
uint64_t assetEventId) {
const auto pTileset = _pContext->getAssetRegistry().getTileset(tilesetPath);
if (!pTileset) {
return;
}
const auto pIonRasterOverlay =
_pContext->getAssetRegistry().getIonRasterOverlayByIonAssetId(rasterOverlayIonAssetId);
if (!pIonRasterOverlay) {
return;
}
_assetTroubleshootingDetails = AssetTroubleshootingDetails();
updateAssetTroubleshootingDetails(rasterOverlayIonAssetId, assetEventId, _assetTroubleshootingDetails.value());
_defaultTokenTroubleshootingDetails = TokenTroubleshootingDetails();
const auto& defaultToken = getDefaultToken();
if (defaultToken.has_value()) {
const auto& token = defaultToken.value().token;
updateTokenTroubleshootingDetails(
rasterOverlayIonAssetId, token, tokenEventId, _defaultTokenTroubleshootingDetails.value());
}
_assetTokenTroubleshootingDetails = TokenTroubleshootingDetails();
auto rasterOverlayIonAccessToken = pIonRasterOverlay->getIonAccessToken();
if (!rasterOverlayIonAccessToken.token.empty()) {
updateTokenTroubleshootingDetails(
rasterOverlayIonAssetId,
rasterOverlayIonAccessToken.token,
tokenEventId,
_assetTokenTroubleshootingDetails.value());
}
}
} // namespace cesium::omniverse
| 12,101 | C++ | 33.380682 | 119 | 0.683332 |
CesiumGS/cesium-omniverse/src/core/src/FabricGeometryDescriptor.cpp | #include "cesium/omniverse/FabricGeometryDescriptor.h"
#include "cesium/omniverse/FabricFeaturesInfo.h"
#include "cesium/omniverse/FabricFeaturesUtil.h"
#include "cesium/omniverse/FabricVertexAttributeDescriptor.h"
#include "cesium/omniverse/GltfUtil.h"
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <CesiumGltf/Model.h>
namespace cesium::omniverse {
FabricGeometryDescriptor::FabricGeometryDescriptor(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const FabricFeaturesInfo& featuresInfo,
bool smoothNormals)
: _hasNormals(GltfUtil::hasNormals(model, primitive, smoothNormals))
, _hasVertexColors(GltfUtil::hasVertexColors(model, primitive, 0))
, _hasVertexIds(FabricFeaturesUtil::hasFeatureIdType(featuresInfo, FabricFeatureIdType::INDEX))
, _texcoordSetCount(
GltfUtil::getTexcoordSetIndexes(model, primitive).size() +
GltfUtil::getRasterOverlayTexcoordSetIndexes(model, primitive).size())
, _customVertexAttributes(GltfUtil::getCustomVertexAttributes(model, primitive)) {}
bool FabricGeometryDescriptor::hasNormals() const {
return _hasNormals;
}
bool FabricGeometryDescriptor::hasVertexColors() const {
return _hasVertexColors;
}
bool FabricGeometryDescriptor::hasVertexIds() const {
return _hasVertexIds;
}
uint64_t FabricGeometryDescriptor::getTexcoordSetCount() const {
return _texcoordSetCount;
}
const std::set<FabricVertexAttributeDescriptor>& FabricGeometryDescriptor::getCustomVertexAttributes() const {
return _customVertexAttributes;
}
bool FabricGeometryDescriptor::operator==(const FabricGeometryDescriptor& other) const {
return _hasNormals == other._hasNormals && _hasVertexColors == other._hasVertexColors &&
_hasVertexIds == other._hasVertexIds && _texcoordSetCount == other._texcoordSetCount &&
_customVertexAttributes == other._customVertexAttributes;
}
} // namespace cesium::omniverse
| 1,990 | C++ | 33.929824 | 110 | 0.770352 |
CesiumGS/cesium-omniverse/src/core/src/FabricResourceManager.cpp | #include "cesium/omniverse/FabricResourceManager.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/FabricGeometry.h"
#include "cesium/omniverse/FabricGeometryDescriptor.h"
#include "cesium/omniverse/FabricGeometryPool.h"
#include "cesium/omniverse/FabricMaterialDescriptor.h"
#include "cesium/omniverse/FabricMaterialInfo.h"
#include "cesium/omniverse/FabricMaterialPool.h"
#include "cesium/omniverse/FabricPropertyDescriptor.h"
#include "cesium/omniverse/FabricTexture.h"
#include "cesium/omniverse/FabricTexturePool.h"
#include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/FabricVertexAttributeDescriptor.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/MetadataUtil.h"
#include "cesium/omniverse/UsdUtil.h"
#include <omni/ui/ImageProvider/DynamicTextureProvider.h>
#include <spdlog/fmt/fmt.h>
namespace cesium::omniverse {
namespace {
const std::string_view DEFAULT_WHITE_TEXTURE_NAME = "cesium_default_white_texture";
const std::string_view DEFAULT_TRANSPARENT_TEXTURE_NAME = "cesium_default_transparent_texture";
std::unique_ptr<omni::ui::DynamicTextureProvider>
createSinglePixelTexture(const std::string_view& name, const std::array<uint8_t, 4>& bytes) {
const auto size = carb::Uint2{1, 1};
auto pTexture = std::make_unique<omni::ui::DynamicTextureProvider>(std::string(name));
pTexture->setBytesData(bytes.data(), size, omni::ui::kAutoCalculateStride, carb::Format::eRGBA8_SRGB);
return pTexture;
}
bool shouldAcquireSharedMaterial(const FabricMaterialDescriptor& materialDescriptor) {
if (materialDescriptor.hasBaseColorTexture() || materialDescriptor.getRasterOverlayRenderMethods().size() > 0 ||
!materialDescriptor.getFeatureIdTypes().empty() || !materialDescriptor.getStyleableProperties().empty()) {
return false;
}
return true;
}
} // namespace
FabricResourceManager::FabricResourceManager(Context* pContext)
: _pContext(pContext)
, _defaultWhiteTexture(createSinglePixelTexture(DEFAULT_WHITE_TEXTURE_NAME, {{255, 255, 255, 255}}))
, _defaultTransparentTexture(createSinglePixelTexture(DEFAULT_TRANSPARENT_TEXTURE_NAME, {{0, 0, 0, 0}}))
, _defaultWhiteTextureAssetPathToken(UsdUtil::getDynamicTextureProviderAssetPathToken(DEFAULT_WHITE_TEXTURE_NAME))
, _defaultTransparentTextureAssetPathToken(
UsdUtil::getDynamicTextureProviderAssetPathToken(DEFAULT_TRANSPARENT_TEXTURE_NAME))
{}
FabricResourceManager::~FabricResourceManager() = default;
bool FabricResourceManager::shouldAcquireMaterial(
const CesiumGltf::MeshPrimitive& primitive,
bool hasRasterOverlay,
const pxr::SdfPath& tilesetMaterialPath) const {
if (_disableMaterials) {
return false;
}
if (!tilesetMaterialPath.IsEmpty()) {
return FabricUtil::materialHasCesiumNodes(
_pContext->getFabricStage(), FabricUtil::toFabricPath(tilesetMaterialPath));
}
return hasRasterOverlay || GltfUtil::hasMaterial(primitive);
}
bool FabricResourceManager::getDisableTextures() const {
return _disableTextures;
}
std::shared_ptr<FabricGeometry> FabricResourceManager::acquireGeometry(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const FabricFeaturesInfo& featuresInfo,
bool smoothNormals) {
FabricGeometryDescriptor geometryDescriptor(model, primitive, featuresInfo, smoothNormals);
if (_disableGeometryPool) {
const auto contextId = _pContext->getContextId();
const auto pathStr = fmt::format("/cesium_geometry_{}_context_{}", getNextGeometryId(), contextId);
const auto path = omni::fabric::Path(pathStr.c_str());
return std::make_shared<FabricGeometry>(_pContext, path, geometryDescriptor, -1);
}
std::scoped_lock<std::mutex> lock(_poolMutex);
return acquireGeometryFromPool(geometryDescriptor);
}
std::shared_ptr<FabricMaterial> FabricResourceManager::acquireMaterial(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const FabricMaterialInfo& materialInfo,
const FabricFeaturesInfo& featuresInfo,
const FabricRasterOverlaysInfo& rasterOverlaysInfo,
int64_t tilesetId,
const pxr::SdfPath& tilesetMaterialPath) {
FabricMaterialDescriptor materialDescriptor(
*_pContext, model, primitive, materialInfo, featuresInfo, rasterOverlaysInfo, tilesetMaterialPath);
if (shouldAcquireSharedMaterial(materialDescriptor)) {
return acquireSharedMaterial(materialInfo, materialDescriptor, tilesetId);
}
if (_disableMaterialPool) {
return createMaterial(materialDescriptor);
}
std::scoped_lock<std::mutex> lock(_poolMutex);
return acquireMaterialFromPool(materialDescriptor);
}
std::shared_ptr<FabricTexture> FabricResourceManager::acquireTexture() {
if (_disableTexturePool) {
const auto contextId = _pContext->getContextId();
const auto name = fmt::format("/cesium_texture_{}_context_{}", getNextTextureId(), contextId);
return std::make_shared<FabricTexture>(_pContext, name, -1);
}
std::scoped_lock<std::mutex> lock(_poolMutex);
return acquireTextureFromPool();
}
void FabricResourceManager::releaseGeometry(std::shared_ptr<FabricGeometry> pGeometry) {
if (_disableGeometryPool) {
return;
}
std::scoped_lock<std::mutex> lock(_poolMutex);
const auto pGeometryPool = getGeometryPool(*pGeometry);
if (pGeometryPool) {
pGeometryPool->release(std::move(pGeometry));
}
}
void FabricResourceManager::releaseMaterial(std::shared_ptr<FabricMaterial> pMaterial) {
if (isSharedMaterial(*pMaterial)) {
releaseSharedMaterial(*pMaterial);
return;
}
if (_disableMaterialPool) {
return;
}
std::scoped_lock<std::mutex> lock(_poolMutex);
const auto pMaterialPool = getMaterialPool(*pMaterial);
if (pMaterialPool) {
pMaterialPool->release(std::move(pMaterial));
}
}
void FabricResourceManager::releaseTexture(std::shared_ptr<FabricTexture> pTexture) {
if (_disableTexturePool) {
return;
}
std::scoped_lock<std::mutex> lock(_poolMutex);
const auto pTexturePool = getTexturePool(*pTexture);
if (pTexturePool) {
pTexturePool->release(std::move(pTexture));
}
}
void FabricResourceManager::setDisableMaterials(bool disableMaterials) {
_disableMaterials = disableMaterials;
}
void FabricResourceManager::setDisableTextures(bool disableTextures) {
_disableTextures = disableTextures;
}
void FabricResourceManager::setDisableGeometryPool(bool disableGeometryPool) {
assert(_geometryPools.size() == 0);
_disableGeometryPool = disableGeometryPool;
}
void FabricResourceManager::setDisableMaterialPool(bool disableMaterialPool) {
assert(_materialPools.size() == 0);
_disableMaterialPool = disableMaterialPool;
}
void FabricResourceManager::setDisableTexturePool(bool disableTexturePool) {
assert(_texturePools.size() == 0);
_disableTexturePool = disableTexturePool;
}
void FabricResourceManager::setGeometryPoolInitialCapacity(uint64_t geometryPoolInitialCapacity) {
assert(_geometryPools.size() == 0);
_geometryPoolInitialCapacity = geometryPoolInitialCapacity;
}
void FabricResourceManager::setMaterialPoolInitialCapacity(uint64_t materialPoolInitialCapacity) {
assert(_materialPools.size() == 0);
_materialPoolInitialCapacity = materialPoolInitialCapacity;
}
void FabricResourceManager::setTexturePoolInitialCapacity(uint64_t texturePoolInitialCapacity) {
assert(_texturePools.size() == 0);
_texturePoolInitialCapacity = texturePoolInitialCapacity;
}
void FabricResourceManager::setDebugRandomColors(bool debugRandomColors) {
_debugRandomColors = debugRandomColors;
}
void FabricResourceManager::updateShaderInput(
const pxr::SdfPath& materialPath,
const pxr::SdfPath& shaderPath,
const pxr::TfToken& attributeName) const {
for (const auto& pMaterialPool : _materialPools) {
const auto& tilesetMaterialPath = pMaterialPool->getMaterialDescriptor().getTilesetMaterialPath();
if (tilesetMaterialPath == materialPath) {
pMaterialPool->updateShaderInput(shaderPath, attributeName);
}
}
}
void FabricResourceManager::clear() {
_geometryPools.clear();
_materialPools.clear();
_texturePools.clear();
_sharedMaterials.clear();
}
std::shared_ptr<FabricMaterial>
FabricResourceManager::createMaterial(const FabricMaterialDescriptor& materialDescriptor) {
const auto contextId = _pContext->getContextId();
const auto pathStr = fmt::format("/cesium_material_{}_context_{}", getNextMaterialId(), contextId);
const auto path = omni::fabric::Path(pathStr.c_str());
return std::make_shared<FabricMaterial>(
_pContext,
path,
materialDescriptor,
_defaultWhiteTextureAssetPathToken,
_defaultTransparentTextureAssetPathToken,
_debugRandomColors,
-1);
}
std::shared_ptr<FabricMaterial> FabricResourceManager::acquireSharedMaterial(
const FabricMaterialInfo& materialInfo,
const FabricMaterialDescriptor& materialDescriptor,
int64_t tilesetId) {
for (auto& sharedMaterial : _sharedMaterials) {
if (sharedMaterial.materialInfo == materialInfo && sharedMaterial.tilesetId == tilesetId) {
++sharedMaterial.referenceCount;
return sharedMaterial.pMaterial;
}
}
const auto material = createMaterial(materialDescriptor);
// In C++ 20 this can be emplace_back without the {}
_sharedMaterials.push_back({
material,
materialInfo,
tilesetId,
1,
});
return _sharedMaterials.back().pMaterial;
}
void FabricResourceManager::releaseSharedMaterial(const FabricMaterial& material) {
CppUtil::eraseIf(_sharedMaterials, [&material](auto& sharedMaterial) {
if (sharedMaterial.pMaterial.get() == &material) {
--sharedMaterial.referenceCount;
if (sharedMaterial.referenceCount == 0) {
return true;
}
}
return false;
});
}
bool FabricResourceManager::isSharedMaterial(const FabricMaterial& material) const {
for (auto& sharedMaterial : _sharedMaterials) {
if (sharedMaterial.pMaterial.get() == &material) {
return true;
}
}
return false;
}
std::shared_ptr<FabricGeometry>
FabricResourceManager::acquireGeometryFromPool(const FabricGeometryDescriptor& geometryDescriptor) {
for (const auto& pGeometryPool : _geometryPools) {
if (geometryDescriptor == pGeometryPool->getGeometryDescriptor()) {
// Found a pool with the same geometry descriptor
return pGeometryPool->acquire();
}
}
auto pGeometryPool = std::make_unique<FabricGeometryPool>(
_pContext, getNextGeometryPoolId(), geometryDescriptor, _geometryPoolInitialCapacity);
_geometryPools.push_back(std::move(pGeometryPool));
return _geometryPools.back()->acquire();
}
std::shared_ptr<FabricMaterial>
FabricResourceManager::acquireMaterialFromPool(const FabricMaterialDescriptor& materialDescriptor) {
for (const auto& pMaterialPool : _materialPools) {
if (materialDescriptor == pMaterialPool->getMaterialDescriptor()) {
// Found a pool with the same material descriptor
return pMaterialPool->acquire();
}
}
auto pMaterialPool = std::make_unique<FabricMaterialPool>(
_pContext,
getNextMaterialPoolId(),
materialDescriptor,
_materialPoolInitialCapacity,
_defaultWhiteTextureAssetPathToken,
_defaultTransparentTextureAssetPathToken,
_debugRandomColors);
_materialPools.push_back(std::move(pMaterialPool));
return _materialPools.back()->acquire();
}
std::shared_ptr<FabricTexture> FabricResourceManager::acquireTextureFromPool() {
if (!_texturePools.empty()) {
return _texturePools.front()->acquire();
}
auto pTexturePool =
std::make_unique<FabricTexturePool>(_pContext, getNextTexturePoolId(), _texturePoolInitialCapacity);
_texturePools.push_back(std::move(pTexturePool));
return _texturePools.back()->acquire();
}
FabricGeometryPool* FabricResourceManager::getGeometryPool(const FabricGeometry& geometry) const {
for (const auto& pGeometryPool : _geometryPools) {
if (pGeometryPool->getPoolId() == geometry.getPoolId()) {
return pGeometryPool.get();
}
}
return nullptr;
}
FabricMaterialPool* FabricResourceManager::getMaterialPool(const FabricMaterial& material) const {
for (const auto& pMaterialPool : _materialPools) {
if (pMaterialPool->getPoolId() == material.getPoolId()) {
return pMaterialPool.get();
}
}
return nullptr;
}
FabricTexturePool* FabricResourceManager::getTexturePool(const FabricTexture& texture) const {
for (const auto& pTexturePool : _texturePools) {
if (pTexturePool->getPoolId() == texture.getPoolId()) {
return pTexturePool.get();
}
}
return nullptr;
}
int64_t FabricResourceManager::getNextGeometryId() {
return _geometryId++;
}
int64_t FabricResourceManager::getNextMaterialId() {
return _materialId++;
}
int64_t FabricResourceManager::getNextTextureId() {
return _textureId++;
}
int64_t FabricResourceManager::getNextGeometryPoolId() {
return _geometryPoolId++;
}
int64_t FabricResourceManager::getNextMaterialPoolId() {
return _materialPoolId++;
}
int64_t FabricResourceManager::getNextTexturePoolId() {
return _texturePoolId++;
}
}; // namespace cesium::omniverse
| 13,698 | C++ | 32.169491 | 118 | 0.722295 |
CesiumGS/cesium-omniverse/src/core/src/FabricVertexAttributeAccessors.cpp | #include "cesium/omniverse/FabricVertexAttributeAccessors.h"
namespace cesium::omniverse {
PositionsAccessor::PositionsAccessor()
: _size(0) {}
PositionsAccessor::PositionsAccessor(const CesiumGltf::AccessorView<glm::fvec3>& view)
: _view(view)
, _size(static_cast<uint64_t>(view.size())) {}
void PositionsAccessor::fill(const gsl::span<glm::fvec3>& values) const {
for (uint64_t i = 0; i < _size; ++i) {
values[i] = _view[static_cast<int64_t>(i)];
}
}
const glm::fvec3& PositionsAccessor::get(uint64_t index) const {
return _view[static_cast<int64_t>(index)];
}
uint64_t PositionsAccessor::size() const {
return _size;
}
IndicesAccessor::IndicesAccessor()
: _size(0) {}
IndicesAccessor::IndicesAccessor(uint64_t size)
: _size(size) {}
IndicesAccessor::IndicesAccessor(const CesiumGltf::AccessorView<uint8_t>& uint8View)
: _uint8View(uint8View)
, _size(static_cast<uint64_t>(uint8View.size())) {}
IndicesAccessor::IndicesAccessor(const CesiumGltf::AccessorView<uint16_t>& uint16View)
: _uint16View(uint16View)
, _size(static_cast<uint64_t>(uint16View.size())) {}
IndicesAccessor::IndicesAccessor(const CesiumGltf::AccessorView<uint32_t>& uint32View)
: _uint32View(uint32View)
, _size(static_cast<uint64_t>(uint32View.size())) {}
template <typename T> IndicesAccessor IndicesAccessor::FromTriangleStrips(const CesiumGltf::AccessorView<T>& view) {
auto indices = std::vector<uint32_t>();
indices.reserve(static_cast<uint64_t>(view.size() - 2) * 3);
for (auto i = 0; i < view.size() - 2; ++i) {
if (i % 2) {
indices.push_back(static_cast<uint32_t>(view[i]));
indices.push_back(static_cast<uint32_t>(view[i + 2]));
indices.push_back(static_cast<uint32_t>(view[i + 1]));
} else {
indices.push_back(static_cast<uint32_t>(view[i]));
indices.push_back(static_cast<uint32_t>(view[i + 1]));
indices.push_back(static_cast<uint32_t>(view[i + 2]));
}
}
auto accessor = IndicesAccessor();
accessor._size = indices.size();
accessor._computed = std::move(indices);
return accessor;
}
// Explicit template instantiation
template IndicesAccessor IndicesAccessor::FromTriangleStrips<uint8_t>(const CesiumGltf::AccessorView<uint8_t>& view);
template IndicesAccessor IndicesAccessor::FromTriangleStrips<uint16_t>(const CesiumGltf::AccessorView<uint16_t>& view);
template IndicesAccessor IndicesAccessor::FromTriangleStrips<uint32_t>(const CesiumGltf::AccessorView<uint32_t>& view);
template <typename T> IndicesAccessor IndicesAccessor::FromTriangleFans(const CesiumGltf::AccessorView<T>& view) {
auto indices = std::vector<uint32_t>();
indices.reserve(static_cast<uint64_t>(view.size() - 2) * 3);
for (auto i = 0; i < view.size() - 2; ++i) {
indices.push_back(static_cast<uint32_t>(view[0]));
indices.push_back(static_cast<uint32_t>(view[i + 1]));
indices.push_back(static_cast<uint32_t>(view[i + 2]));
}
auto accessor = IndicesAccessor();
accessor._size = indices.size();
accessor._computed = std::move(indices);
return accessor;
}
// Explicit template instantiation
template IndicesAccessor IndicesAccessor::FromTriangleFans<uint8_t>(const CesiumGltf::AccessorView<uint8_t>& view);
template IndicesAccessor IndicesAccessor::FromTriangleFans<uint16_t>(const CesiumGltf::AccessorView<uint16_t>& view);
template IndicesAccessor IndicesAccessor::FromTriangleFans<uint32_t>(const CesiumGltf::AccessorView<uint32_t>& view);
void IndicesAccessor::fill(const gsl::span<int>& values) const {
const auto size = values.size();
assert(size == _size);
if (!_computed.empty()) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = static_cast<int>(_computed[i]);
}
} else if (_uint8View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = static_cast<int>(_uint8View[static_cast<int64_t>(i)]);
}
} else if (_uint16View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = static_cast<int>(_uint16View[static_cast<int64_t>(i)]);
}
} else if (_uint32View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = static_cast<int>(_uint32View[static_cast<int64_t>(i)]);
}
} else {
for (uint64_t i = 0; i < size; ++i) {
values[i] = static_cast<int>(i);
}
}
}
uint32_t IndicesAccessor::get(uint64_t index) const {
if (!_computed.empty()) {
return _computed[index];
} else if (_uint8View.status() == CesiumGltf::AccessorViewStatus::Valid) {
return static_cast<uint32_t>(_uint8View[static_cast<int64_t>(index)]);
} else if (_uint16View.status() == CesiumGltf::AccessorViewStatus::Valid) {
return static_cast<uint32_t>(_uint16View[static_cast<int64_t>(index)]);
} else if (_uint32View.status() == CesiumGltf::AccessorViewStatus::Valid) {
return static_cast<uint32_t>(_uint32View[static_cast<int64_t>(index)]);
} else {
return static_cast<uint32_t>(index);
}
}
uint64_t IndicesAccessor::size() const {
return _size;
}
NormalsAccessor::NormalsAccessor()
: _size(0) {}
NormalsAccessor::NormalsAccessor(const CesiumGltf::AccessorView<glm::fvec3>& view)
: _view(view)
, _size(static_cast<uint64_t>(view.size())) {}
NormalsAccessor NormalsAccessor::GenerateSmooth(const PositionsAccessor& positions, const IndicesAccessor& indices) {
auto normals = std::vector<glm::fvec3>(positions.size(), glm::fvec3(0.0f));
for (uint64_t i = 0; i < indices.size(); i += 3) {
const auto idx0 = static_cast<uint64_t>(indices.get(i));
const auto idx1 = static_cast<uint64_t>(indices.get(i + 1));
const auto idx2 = static_cast<uint64_t>(indices.get(i + 2));
const auto& p0 = positions.get(idx0);
const auto& p1 = positions.get(idx1);
const auto& p2 = positions.get(idx2);
auto n = glm::normalize(glm::cross(p1 - p0, p2 - p0));
normals[idx0] += n;
normals[idx1] += n;
normals[idx2] += n;
}
for (auto& n : normals) {
n = glm::normalize(n);
}
auto accessor = NormalsAccessor();
accessor._computed = std::move(normals);
accessor._size = indices.size();
return accessor;
}
void NormalsAccessor::fill(const gsl::span<glm::fvec3>& values) const {
const auto size = values.size();
assert(size == _size);
if (!_computed.empty()) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = _computed[i];
}
} else {
for (uint64_t i = 0; i < size; ++i) {
values[i] = _view[static_cast<int64_t>(i)];
}
}
}
uint64_t NormalsAccessor::size() const {
return _size;
}
TexcoordsAccessor::TexcoordsAccessor()
: _size(0) {}
TexcoordsAccessor::TexcoordsAccessor(const CesiumGltf::AccessorView<glm::fvec2>& view, bool flipVertical)
: _view(view)
, _flipVertical(flipVertical)
, _size(static_cast<uint64_t>(view.size())) {}
void TexcoordsAccessor::fill(const gsl::span<glm::fvec2>& values) const {
const auto size = values.size();
assert(size == _size);
for (uint64_t i = 0; i < size; ++i) {
values[i] = _view[static_cast<int64_t>(i)];
}
if (_flipVertical) {
for (uint64_t i = 0; i < size; ++i) {
values[i][1] = 1.0f - values[i][1];
}
}
}
uint64_t TexcoordsAccessor::size() const {
return _size;
}
VertexColorsAccessor::VertexColorsAccessor()
: _size(0) {}
VertexColorsAccessor::VertexColorsAccessor(const CesiumGltf::AccessorView<glm::u8vec3>& uint8Vec3View)
: _uint8Vec3View(uint8Vec3View)
, _size(static_cast<uint64_t>(uint8Vec3View.size())) {}
VertexColorsAccessor::VertexColorsAccessor(const CesiumGltf::AccessorView<glm::u8vec4>& uint8Vec4View)
: _uint8Vec4View(uint8Vec4View)
, _size(static_cast<uint64_t>(uint8Vec4View.size())) {}
VertexColorsAccessor::VertexColorsAccessor(const CesiumGltf::AccessorView<glm::u16vec3>& uint16Vec3View)
: _uint16Vec3View(uint16Vec3View)
, _size(static_cast<uint64_t>(uint16Vec3View.size())) {}
VertexColorsAccessor::VertexColorsAccessor(const CesiumGltf::AccessorView<glm::u16vec4>& uint16Vec4View)
: _uint16Vec4View(uint16Vec4View)
, _size(static_cast<uint64_t>(uint16Vec4View.size())) {}
VertexColorsAccessor::VertexColorsAccessor(const CesiumGltf::AccessorView<glm::fvec3>& float32Vec3View)
: _float32Vec3View(float32Vec3View)
, _size(static_cast<uint64_t>(float32Vec3View.size())) {}
VertexColorsAccessor::VertexColorsAccessor(const CesiumGltf::AccessorView<glm::fvec4>& float32Vec4View)
: _float32Vec4View(float32Vec4View)
, _size(static_cast<uint64_t>(float32Vec4View.size())) {}
void VertexColorsAccessor::fill(const gsl::span<glm::fvec4>& values, uint64_t repeat) const {
constexpr auto MAX_UINT8 = static_cast<float>(std::numeric_limits<uint8_t>::max());
constexpr auto MAX_UINT16 = static_cast<float>(std::numeric_limits<uint16_t>::max());
const auto size = values.size();
assert(size == _size * repeat);
if (_uint8Vec3View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = glm::fvec4(
static_cast<float>(_uint8Vec3View[static_cast<int64_t>(i / repeat)].x) / MAX_UINT8,
static_cast<float>(_uint8Vec3View[static_cast<int64_t>(i / repeat)].y) / MAX_UINT8,
static_cast<float>(_uint8Vec3View[static_cast<int64_t>(i / repeat)].z) / MAX_UINT8,
1.0);
}
} else if (_uint8Vec4View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = glm::fvec4(
static_cast<float>(_uint8Vec4View[static_cast<int64_t>(i / repeat)].x) / MAX_UINT8,
static_cast<float>(_uint8Vec4View[static_cast<int64_t>(i / repeat)].y) / MAX_UINT8,
static_cast<float>(_uint8Vec4View[static_cast<int64_t>(i / repeat)].z) / MAX_UINT8,
static_cast<float>(_uint8Vec4View[static_cast<int64_t>(i / repeat)].w) / MAX_UINT8);
}
} else if (_uint16Vec3View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = glm::fvec4(
static_cast<float>(_uint16Vec3View[static_cast<int64_t>(i / repeat)].x) / MAX_UINT16,
static_cast<float>(_uint16Vec3View[static_cast<int64_t>(i / repeat)].y) / MAX_UINT16,
static_cast<float>(_uint16Vec3View[static_cast<int64_t>(i / repeat)].z) / MAX_UINT16,
1.0);
}
} else if (_uint16Vec4View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = glm::fvec4(
static_cast<float>(_uint16Vec4View[static_cast<int64_t>(i / repeat)].x) / MAX_UINT16,
static_cast<float>(_uint16Vec4View[static_cast<int64_t>(i / repeat)].y) / MAX_UINT16,
static_cast<float>(_uint16Vec4View[static_cast<int64_t>(i / repeat)].z) / MAX_UINT16,
static_cast<float>(_uint16Vec4View[static_cast<int64_t>(i / repeat)].w) / MAX_UINT16);
}
} else if (_float32Vec3View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = glm::fvec4(_float32Vec3View[static_cast<int64_t>(i / repeat)], 1.0f);
}
} else if (_float32Vec4View.status() == CesiumGltf::AccessorViewStatus::Valid) {
for (uint64_t i = 0; i < size; ++i) {
values[i] = _float32Vec4View[static_cast<int64_t>(i / repeat)];
}
}
}
uint64_t VertexColorsAccessor::size() const {
return _size;
}
VertexIdsAccessor::VertexIdsAccessor()
: _size(0) {}
VertexIdsAccessor::VertexIdsAccessor(uint64_t size)
: _size(size) {}
void VertexIdsAccessor::fill(const gsl::span<float>& values, uint64_t repeat) const {
const auto size = values.size();
assert(size == _size * repeat);
for (uint64_t i = 0; i < size; ++i) {
// NOLINTNEXTLINE(bugprone-integer-division)
values[i] = static_cast<float>(i / repeat);
}
}
uint64_t VertexIdsAccessor::size() const {
return _size;
}
FaceVertexCountsAccessor::FaceVertexCountsAccessor()
: _size(0) {}
FaceVertexCountsAccessor::FaceVertexCountsAccessor(uint64_t size)
: _size(size) {}
void FaceVertexCountsAccessor::fill(const gsl::span<int>& values) const {
const auto size = values.size();
assert(size == _size);
for (uint64_t i = 0; i < size; ++i) {
values[i] = 3;
}
}
uint64_t FaceVertexCountsAccessor::size() const {
return _size;
}
} // namespace cesium::omniverse
| 12,982 | C++ | 37.297935 | 119 | 0.63642 |
CesiumGS/cesium-omniverse/src/core/src/TaskProcessor.cpp | #include "cesium/omniverse/TaskProcessor.h"
namespace cesium::omniverse {
void TaskProcessor::startTask(std::function<void()> f) {
_dispatcher.Run(f);
}
} // namespace cesium::omniverse
| 191 | C++ | 22.999997 | 56 | 0.732984 |
CesiumGS/cesium-omniverse/src/core/src/FabricAttributesBuilder.cpp | #include "cesium/omniverse/FabricAttributesBuilder.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/UsdUtil.h"
#include <omni/fabric/SimStageWithHistory.h>
namespace cesium::omniverse {
FabricAttributesBuilder::FabricAttributesBuilder(Context* pContext)
: _pContext(pContext) {}
void FabricAttributesBuilder::addAttribute(const omni::fabric::Type& type, const omni::fabric::Token& name) {
assert(_size < MAX_ATTRIBUTES);
_attributes[_size++] = omni::fabric::AttrNameAndType(type, name);
}
void FabricAttributesBuilder::createAttributes(const omni::fabric::Path& path) const {
// Somewhat annoyingly, fabricStage.createAttributes takes an std::array instead of a gsl::span. This is fine if
// you know exactly which set of attributes to create at compile time but we don't. For example, not all prims will
// have texture coordinates or materials. This class allows attributes to be added dynamically up to a hardcoded maximum
// count (MAX_ATTRIBUTES) and avoids heap allocations. The downside is that we need this ugly if/else chain below.
auto& fabricStage = _pContext->getFabricStage();
// clang-format off
if (_size == 0) fabricStage.createAttributes<0>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 0>*>(_attributes.data()));
else if (_size == 1) fabricStage.createAttributes<1>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 1>*>(_attributes.data()));
else if (_size == 2) fabricStage.createAttributes<2>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 2>*>(_attributes.data()));
else if (_size == 3) fabricStage.createAttributes<3>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 3>*>(_attributes.data()));
else if (_size == 4) fabricStage.createAttributes<4>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 4>*>(_attributes.data()));
else if (_size == 5) fabricStage.createAttributes<5>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 5>*>(_attributes.data()));
else if (_size == 6) fabricStage.createAttributes<6>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 6>*>(_attributes.data()));
else if (_size == 7) fabricStage.createAttributes<7>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 7>*>(_attributes.data()));
else if (_size == 8) fabricStage.createAttributes<8>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 8>*>(_attributes.data()));
else if (_size == 9) fabricStage.createAttributes<9>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 9>*>(_attributes.data()));
else if (_size == 10) fabricStage.createAttributes<10>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 10>*>(_attributes.data()));
else if (_size == 11) fabricStage.createAttributes<11>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 11>*>(_attributes.data()));
else if (_size == 12) fabricStage.createAttributes<12>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 12>*>(_attributes.data()));
else if (_size == 13) fabricStage.createAttributes<13>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 13>*>(_attributes.data()));
else if (_size == 14) fabricStage.createAttributes<14>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 14>*>(_attributes.data()));
else if (_size == 15) fabricStage.createAttributes<15>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 15>*>(_attributes.data()));
else if (_size == 16) fabricStage.createAttributes<16>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 16>*>(_attributes.data()));
else if (_size == 17) fabricStage.createAttributes<17>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 17>*>(_attributes.data()));
else if (_size == 18) fabricStage.createAttributes<18>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 18>*>(_attributes.data()));
else if (_size == 19) fabricStage.createAttributes<19>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 19>*>(_attributes.data()));
else if (_size == 20) fabricStage.createAttributes<20>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 20>*>(_attributes.data()));
else if (_size == 21) fabricStage.createAttributes<21>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 21>*>(_attributes.data()));
else if (_size == 22) fabricStage.createAttributes<22>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 22>*>(_attributes.data()));
else if (_size == 23) fabricStage.createAttributes<23>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 23>*>(_attributes.data()));
else if (_size == 24) fabricStage.createAttributes<24>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 24>*>(_attributes.data()));
else if (_size == 25) fabricStage.createAttributes<25>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 25>*>(_attributes.data()));
else if (_size == 26) fabricStage.createAttributes<26>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 26>*>(_attributes.data()));
else if (_size == 27) fabricStage.createAttributes<27>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 27>*>(_attributes.data()));
else if (_size == 28) fabricStage.createAttributes<28>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 28>*>(_attributes.data()));
else if (_size == 29) fabricStage.createAttributes<29>(path, *reinterpret_cast<const std::array<omni::fabric::AttrNameAndType, 29>*>(_attributes.data()));
// clang-format on
}
} // namespace cesium::omniverse
| 5,966 | C++ | 98.449998 | 158 | 0.722595 |
CesiumGS/cesium-omniverse/src/core/src/FabricMaterialDescriptor.cpp | #include "cesium/omniverse/FabricMaterialDescriptor.h"
#include "cesium/omniverse/FabricFeaturesInfo.h"
#include "cesium/omniverse/FabricFeaturesUtil.h"
#include "cesium/omniverse/FabricMaterialInfo.h"
#include "cesium/omniverse/FabricPropertyDescriptor.h"
#include "cesium/omniverse/FabricRasterOverlaysInfo.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/MetadataUtil.h"
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <CesiumGltf/Model.h>
namespace cesium::omniverse {
FabricMaterialDescriptor::FabricMaterialDescriptor(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const FabricMaterialInfo& materialInfo,
const FabricFeaturesInfo& featuresInfo,
const FabricRasterOverlaysInfo& rasterOverlaysInfo,
const pxr::SdfPath& tilesetMaterialPath)
: _hasVertexColors(materialInfo.hasVertexColors)
, _hasBaseColorTexture(materialInfo.baseColorTexture.has_value())
, _featureIdTypes(FabricFeaturesUtil::getFeatureIdTypes(featuresInfo))
, _rasterOverlayRenderMethods(rasterOverlaysInfo.overlayRenderMethods)
, _tilesetMaterialPath(tilesetMaterialPath) {
// Ignore styleable properties unless the tileset has a material
if (!_tilesetMaterialPath.IsEmpty()) {
std::tie(_styleableProperties, _unsupportedPropertyWarnings) =
MetadataUtil::getStyleableProperties(context, model, primitive);
}
}
bool FabricMaterialDescriptor::hasVertexColors() const {
return _hasVertexColors;
}
bool FabricMaterialDescriptor::hasBaseColorTexture() const {
return _hasBaseColorTexture;
}
const std::vector<FabricFeatureIdType>& FabricMaterialDescriptor::getFeatureIdTypes() const {
return _featureIdTypes;
}
const std::vector<FabricOverlayRenderMethod>& FabricMaterialDescriptor::getRasterOverlayRenderMethods() const {
return _rasterOverlayRenderMethods;
}
bool FabricMaterialDescriptor::hasTilesetMaterial() const {
return !_tilesetMaterialPath.IsEmpty();
}
const pxr::SdfPath& FabricMaterialDescriptor::getTilesetMaterialPath() const {
return _tilesetMaterialPath;
}
const std::vector<FabricPropertyDescriptor>& FabricMaterialDescriptor::getStyleableProperties() const {
return _styleableProperties;
}
const std::map<std::string, std::string>& FabricMaterialDescriptor::getUnsupportedPropertyWarnings() const {
return _unsupportedPropertyWarnings;
}
// Make sure to update this function when adding new fields to the class
bool FabricMaterialDescriptor::operator==(const FabricMaterialDescriptor& other) const {
// clang-format off
return _hasVertexColors == other._hasVertexColors &&
_hasBaseColorTexture == other._hasBaseColorTexture &&
_featureIdTypes == other._featureIdTypes &&
_rasterOverlayRenderMethods == other._rasterOverlayRenderMethods &&
_tilesetMaterialPath == other._tilesetMaterialPath &&
_styleableProperties == other._styleableProperties;
// _unsupportedPropertyWarnings is intentionally not checked because it adds unecessary overhead
// clang-format on
}
} // namespace cesium::omniverse
| 3,197 | C++ | 35.75862 | 111 | 0.772599 |
CesiumGS/cesium-omniverse/src/core/src/FilesystemUtil.cpp | #include "cesium/omniverse/FilesystemUtil.h"
#include <carb/Framework.h>
#include <carb/tokens/ITokens.h>
#include <carb/tokens/TokensUtils.h>
#include <cstdlib>
#include <filesystem>
#if defined(__linux__)
#include <pwd.h>
#include <sys/types.h>
#include <unistd.h>
#include <cerrno>
#endif
namespace cesium::omniverse::FilesystemUtil {
std::filesystem::path getCesiumCacheDirectory() {
auto f = carb::getFramework();
auto* tokensInterface = f->tryAcquireInterface<carb::tokens::ITokens>();
std::string cacheDir;
if (tokensInterface) {
cacheDir = carb::tokens::resolveString(tokensInterface, "${omni_global_cache}");
}
if (!cacheDir.empty()) {
std::filesystem::path cacheDirPath(cacheDir);
if (exists(cacheDirPath)) {
return cacheDirPath;
}
// Should we create the directory if it doesn't exist? It's hard to believe that Omniverse
// won't have already created it.
}
auto homeDirPath = getUserHomeDirectory();
if (!homeDirPath.empty()) {
auto cacheDirPath = homeDirPath / ".nvidia-omniverse";
if (exists(cacheDirPath)) {
return cacheDirPath;
}
}
return {};
}
// Quite a lot of ceremony to get the home directory.
std::filesystem::path getUserHomeDirectory() {
std::string homeDir;
#if defined(__linux__)
if (char* cString = std::getenv("HOME")) {
homeDir = cString;
} else {
passwd pwd;
long bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
if (bufsize == -1) {
bufsize = 16384;
}
char* buf = new char[static_cast<size_t>(bufsize)];
passwd* result = nullptr;
int getResult = getpwuid_r(getuid(), &pwd, buf, static_cast<size_t>(bufsize), &result);
if (getResult == 0) {
homeDir = pwd.pw_dir;
}
delete[] buf;
}
#elif defined(_WIN32)
if (char* cString = std::getenv("USERPROFILE")) {
homeDir = cString;
}
#endif
return homeDir;
}
} // namespace cesium::omniverse::FilesystemUtil
| 2,066 | C++ | 26.932432 | 98 | 0.617135 |
CesiumGS/cesium-omniverse/src/core/src/UsdUtil.cpp | #include "cesium/omniverse/UsdUtil.h"
#include "CesiumUsdSchemas/webMapServiceRasterOverlay.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/CppUtil.h"
#include "cesium/omniverse/MathUtil.h"
#include "cesium/omniverse/OmniData.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/UsdScopedEdit.h"
#include "cesium/omniverse/UsdTokens.h"
#include "cesium/omniverse/Viewport.h"
#include <Cesium3DTilesSelection/ViewState.h>
#include <CesiumGeometry/Transforms.h>
#include <CesiumGeospatial/Cartographic.h>
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumGeospatial/GlobeAnchor.h>
#include <CesiumGeospatial/GlobeTransforms.h>
#include <CesiumGeospatial/LocalHorizontalCoordinateSystem.h>
#include <CesiumUsdSchemas/data.h>
#include <CesiumUsdSchemas/georeference.h>
#include <CesiumUsdSchemas/globeAnchorAPI.h>
#include <CesiumUsdSchemas/ionRasterOverlay.h>
#include <CesiumUsdSchemas/ionServer.h>
#include <CesiumUsdSchemas/polygonRasterOverlay.h>
#include <CesiumUsdSchemas/session.h>
#include <CesiumUsdSchemas/tileMapServiceRasterOverlay.h>
#include <CesiumUsdSchemas/tileset.h>
#include <CesiumUsdSchemas/webMapServiceRasterOverlay.h>
#include <CesiumUsdSchemas/webMapTileServiceRasterOverlay.h>
#include <glm/gtc/matrix_access.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <omni/ui/ImageProvider/DynamicTextureProvider.h>
#include <pxr/base/gf/rotation.h>
#include <pxr/usd/sdf/primSpec.h>
#include <pxr/usd/usd/prim.h>
#include <pxr/usd/usd/stage.h>
#include <pxr/usd/usd/timeCode.h>
#include <pxr/usd/usdGeom/metrics.h>
#include <pxr/usd/usdGeom/xform.h>
#include <pxr/usd/usdGeom/xformCommonAPI.h>
#include <pxr/usd/usdShade/material.h>
#include <pxr/usd/usdShade/shader.h>
#include <spdlog/fmt/fmt.h>
#include <cctype>
namespace cesium::omniverse::UsdUtil {
namespace {
bool getDebugDisableGeoreferencing(const Context& context) {
const auto pData = context.getAssetRegistry().getFirstData();
if (!pData) {
return false;
}
return pData->getDebugDisableGeoreferencing();
}
} // namespace
glm::dvec3 usdToGlmVector(const pxr::GfVec3d& vector) {
return {vector[0], vector[1], vector[2]};
}
glm::fvec3 usdToGlmVector(const pxr::GfVec3f& vector) {
return {vector[0], vector[1], vector[2]};
}
glm::dmat4 usdToGlmMatrix(const pxr::GfMatrix4d& matrix) {
// USD is row-major with left-to-right matrix multiplication
// glm is column-major with right-to-left matrix multiplication
// This means they have the same data layout
return {
matrix[0][0],
matrix[0][1],
matrix[0][2],
matrix[0][3],
matrix[1][0],
matrix[1][1],
matrix[1][2],
matrix[1][3],
matrix[2][0],
matrix[2][1],
matrix[2][2],
matrix[2][3],
matrix[3][0],
matrix[3][1],
matrix[3][2],
matrix[3][3],
};
}
glm::dquat usdToGlmQuat(const pxr::GfQuatd& quat) {
const auto real = quat.GetReal();
const auto imaginary = usdToGlmVector(quat.GetImaginary());
return {real, imaginary.x, imaginary.y, imaginary.z};
}
glm::fquat usdToGlmQuat(const pxr::GfQuatf& quat) {
const auto real = quat.GetReal();
const auto imaginary = usdToGlmVector(quat.GetImaginary());
return {real, imaginary.x, imaginary.y, imaginary.z};
}
std::array<glm::dvec3, 2> usdToGlmExtent(const pxr::GfRange3d& extent) {
return {{usdToGlmVector(extent.GetMin()), usdToGlmVector(extent.GetMax())}};
}
pxr::GfVec3d glmToUsdVector(const glm::dvec3& vector) {
return {vector.x, vector.y, vector.z};
}
pxr::GfVec2f glmToUsdVector(const glm::fvec2& vector) {
return {vector.x, vector.y};
}
pxr::GfVec3f glmToUsdVector(const glm::fvec3& vector) {
return {vector.x, vector.y, vector.z};
}
pxr::GfVec4f glmToUsdVector(const glm::fvec4& vector) {
return {vector.x, vector.y, vector.z, vector.w};
}
pxr::GfRange3d glmToUsdExtent(const std::array<glm::dvec3, 2>& extent) {
return {glmToUsdVector(extent[0]), glmToUsdVector(extent[1])};
}
pxr::GfQuatd glmToUsdQuat(const glm::dquat& quat) {
return {quat.w, quat.x, quat.y, quat.z};
}
pxr::GfQuatf glmToUsdQuat(const glm::fquat& quat) {
return {quat.w, quat.x, quat.y, quat.z};
}
pxr::GfMatrix4d glmToUsdMatrix(const glm::dmat4& matrix) {
// USD is row-major with left-to-right matrix multiplication
// glm is column-major with right-to-left matrix multiplication
// This means they have the same data layout
return pxr::GfMatrix4d{
matrix[0][0],
matrix[0][1],
matrix[0][2],
matrix[0][3],
matrix[1][0],
matrix[1][1],
matrix[1][2],
matrix[1][3],
matrix[2][0],
matrix[2][1],
matrix[2][2],
matrix[2][3],
matrix[3][0],
matrix[3][1],
matrix[3][2],
matrix[3][3],
};
}
glm::dmat4 computePrimLocalToWorldTransform(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
const auto xform = pxr::UsdGeomXformable(prim);
if (!isSchemaValid(xform)) {
return glm::dmat4(1.0);
}
const auto time = pxr::UsdTimeCode::Default();
const auto transform = xform.ComputeLocalToWorldTransform(time);
return usdToGlmMatrix(transform);
}
glm::dmat4 computePrimWorldToLocalTransform(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return glm::affineInverse(computePrimLocalToWorldTransform(pStage, path));
}
glm::dmat4 computeEcefToStageTransform(const Context& context, const pxr::SdfPath& georeferencePath) {
const auto disableGeoreferencing = getDebugDisableGeoreferencing(context);
const auto pGeoreference =
georeferencePath.IsEmpty() ? nullptr : context.getAssetRegistry().getGeoreference(georeferencePath);
if (disableGeoreferencing || !pGeoreference) {
const auto zUp = getUsdUpAxis(context.getUsdStage()) == pxr::UsdGeomTokens->z;
const auto axisConversion = zUp ? glm::dmat4(1.0) : CesiumGeometry::Transforms::Z_UP_TO_Y_UP;
const auto scale = glm::scale(glm::dmat4(1.0), glm::dvec3(1.0 / getUsdMetersPerUnit(context.getUsdStage())));
return scale * axisConversion;
}
return pGeoreference->getLocalCoordinateSystem().getEcefToLocalTransformation();
}
glm::dmat4 computeEcefToPrimWorldTransform(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath) {
const auto ecefToStageTransform = computeEcefToStageTransform(context, georeferencePath);
const auto primLocalToWorldTransform = computePrimLocalToWorldTransform(context.getUsdStage(), primPath);
return primLocalToWorldTransform * ecefToStageTransform;
}
glm::dmat4 computePrimWorldToEcefTransform(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath) {
return glm::affineInverse(computeEcefToPrimWorldTransform(context, georeferencePath, primPath));
}
glm::dmat4 computeEcefToPrimLocalTransform(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath) {
const auto ecefToStageTransform = computeEcefToStageTransform(context, georeferencePath);
const auto primWorldToLocalTransform = computePrimWorldToLocalTransform(context.getUsdStage(), primPath);
return primWorldToLocalTransform * ecefToStageTransform;
}
glm::dmat4 computePrimLocalToEcefTransform(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath) {
return glm::affineInverse(computeEcefToPrimLocalTransform(context, georeferencePath, primPath));
}
Cesium3DTilesSelection::ViewState computeViewState(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath,
const Viewport& viewport) {
const auto& viewMatrix = viewport.viewMatrix;
const auto& projMatrix = viewport.projMatrix;
const auto width = viewport.width;
const auto height = viewport.height;
const auto primWorldToEcefTransform = computePrimWorldToEcefTransform(context, georeferencePath, primPath);
const auto inverseView = glm::affineInverse(viewMatrix);
const auto usdCameraUp = glm::dvec3(inverseView[1]);
const auto usdCameraFwd = glm::dvec3(-inverseView[2]);
const auto usdCameraPosition = glm::dvec3(inverseView[3]);
const auto cameraUp = glm::normalize(glm::dvec3(primWorldToEcefTransform * glm::dvec4(usdCameraUp, 0.0)));
const auto cameraFwd = glm::normalize(glm::dvec3(primWorldToEcefTransform * glm::dvec4(usdCameraFwd, 0.0)));
const auto cameraPosition = glm::dvec3(primWorldToEcefTransform * glm::dvec4(usdCameraPosition, 1.0));
const auto aspect = width / height;
const auto verticalFov = 2.0 * glm::atan(1.0 / projMatrix[1][1]);
const auto horizontalFov = 2.0 * glm::atan(glm::tan(verticalFov * 0.5) * aspect);
return Cesium3DTilesSelection::ViewState::create(
cameraPosition, cameraFwd, cameraUp, glm::dvec2(width, height), horizontalFov, verticalFov);
}
bool primExists(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pStage->GetPrimAtPath(path).IsValid();
}
bool isSchemaValid(const pxr::UsdSchemaBase& schema) {
return schema.GetPrim().IsValid() && schema.GetSchemaKind() != pxr::UsdSchemaKind::Invalid;
}
bool isPrimVisible(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
// This is similar to isPrimVisible in kit-sdk/dev/include/omni/usd/UsdUtils.h
const auto prim = pStage->GetPrimAtPath(path);
const auto imageable = pxr::UsdGeomImageable(prim);
if (!isSchemaValid(imageable)) {
return false;
}
const auto time = pxr::UsdTimeCode::Default();
const auto visibility = imageable.ComputeVisibility(time);
return visibility != pxr::UsdGeomTokens->invisible;
}
const std::string& getName(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pStage->GetPrimAtPath(path).GetName().GetString();
}
pxr::TfToken getUsdUpAxis(const pxr::UsdStageWeakPtr& pStage) {
return pxr::UsdGeomGetStageUpAxis(pStage);
}
double getUsdMetersPerUnit(const pxr::UsdStageWeakPtr& pStage) {
return pxr::UsdGeomGetStageMetersPerUnit(pStage);
}
pxr::SdfPath getRootPath(const pxr::UsdStageWeakPtr& pStage) {
return pStage->GetPseudoRoot().GetPath();
}
pxr::SdfPath
makeUniquePath(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& parentPath, const std::string& name) {
pxr::UsdPrim prim;
pxr::SdfPath path;
auto copy = 0;
do {
const auto copyName = copy > 0 ? fmt::format("{}_{}", name, copy) : name;
path = parentPath.AppendChild(pxr::TfToken(copyName));
prim = pStage->GetPrimAtPath(path);
++copy;
} while (prim.IsValid());
return path;
}
std::string getSafeName(const std::string& name) {
auto safeName = name;
for (auto& c : safeName) {
if (!std::isalnum(c)) {
c = '_';
}
}
return safeName;
}
pxr::TfToken getDynamicTextureProviderAssetPathToken(const std::string_view& name) {
return pxr::TfToken(pxr::SdfAssetPath(fmt::format("dynamic://{}", name)).GetAssetPath());
}
pxr::CesiumData defineCesiumData(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumData::Define(pStage, path);
}
pxr::CesiumTileset defineCesiumTileset(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumTileset::Define(pStage, path);
}
pxr::CesiumIonRasterOverlay defineCesiumIonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumIonRasterOverlay::Define(pStage, path);
}
pxr::CesiumPolygonRasterOverlay
defineCesiumPolygonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumPolygonRasterOverlay::Define(pStage, path);
}
pxr::CesiumGeoreference defineCesiumGeoreference(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumGeoreference::Define(pStage, path);
}
pxr::CesiumIonServer defineCesiumIonServer(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumIonServer::Define(pStage, path);
}
pxr::CesiumGlobeAnchorAPI applyCesiumGlobeAnchor(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
assert(prim.IsValid() && prim.IsA<pxr::UsdGeomXformable>());
return pxr::CesiumGlobeAnchorAPI::Apply(prim);
}
pxr::CesiumSession defineCesiumSession(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumSession::Define(pStage, path);
}
pxr::CesiumData getCesiumData(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumData::Get(pStage, path);
}
pxr::CesiumTileset getCesiumTileset(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumTileset::Get(pStage, path);
}
pxr::CesiumRasterOverlay getCesiumRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumRasterOverlay::Get(pStage, path);
}
pxr::CesiumIonRasterOverlay getCesiumIonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumIonRasterOverlay::Get(pStage, path);
}
pxr::CesiumPolygonRasterOverlay
getCesiumPolygonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumPolygonRasterOverlay::Get(pStage, path);
}
pxr::CesiumWebMapServiceRasterOverlay
getCesiumWebMapServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumWebMapServiceRasterOverlay::Get(pStage, path);
}
pxr::CesiumTileMapServiceRasterOverlay
getCesiumTileMapServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumTileMapServiceRasterOverlay::Get(pStage, path);
}
pxr::CesiumWebMapTileServiceRasterOverlay
getCesiumWebMapTileServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumWebMapTileServiceRasterOverlay::Get(pStage, path);
}
pxr::CesiumGeoreference getCesiumGeoreference(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumGeoreference::Get(pStage, path);
}
pxr::CesiumGlobeAnchorAPI getCesiumGlobeAnchor(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumGlobeAnchorAPI::Get(pStage, path);
}
pxr::CesiumIonServer getCesiumIonServer(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::CesiumIonServer::Get(pStage, path);
}
// This is currently a pass-through to getUsdBasisCurves until
// issue with crashes in prims that inherit from BasisCurves is resolved
pxr::UsdGeomBasisCurves getCesiumCartographicPolygon(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return getUsdBasisCurves(pStage, path);
}
pxr::UsdShadeShader getUsdShader(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::UsdShadeShader::Get(pStage, path);
}
pxr::UsdGeomBasisCurves getUsdBasisCurves(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
return pxr::UsdGeomBasisCurves::Get(pStage, path);
}
pxr::CesiumSession getOrCreateCesiumSession(const pxr::UsdStageWeakPtr& pStage) {
static const auto CesiumSessionPath = pxr::SdfPath("/CesiumSession");
if (isCesiumSession(pStage, CesiumSessionPath)) {
return pxr::CesiumSession::Get(pStage, CesiumSessionPath);
}
// Ensures that CesiumSession is created in the session layer
const UsdScopedEdit scopedEdit(pStage);
// Create the CesiumSession
const auto cesiumSession = defineCesiumSession(pStage, CesiumSessionPath);
// Prevent CesiumSession from being traversed and composed into the stage
cesiumSession.GetPrim().SetActive(false);
return cesiumSession;
}
bool isCesiumData(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumData>();
}
bool isCesiumTileset(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumTileset>();
}
bool isCesiumRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumRasterOverlay>();
}
bool isCesiumIonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumIonRasterOverlay>();
}
bool isCesiumPolygonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumPolygonRasterOverlay>();
}
bool isCesiumWebMapServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumWebMapServiceRasterOverlay>();
}
bool isCesiumTileMapServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumTileMapServiceRasterOverlay>();
}
bool isCesiumWebMapTileServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumWebMapTileServiceRasterOverlay>();
}
bool isCesiumGeoreference(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumGeoreference>();
}
bool isCesiumIonServer(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumIonServer>();
}
bool isCesiumCartographicPolygon(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
if (!prim.IsA<pxr::UsdGeomBasisCurves>()) {
return false;
}
return prim.HasAPI<pxr::CesiumGlobeAnchorAPI>();
}
bool isCesiumSession(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::CesiumSession>();
}
bool hasCesiumGlobeAnchor(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::UsdGeomXformable>() && prim.HasAPI<pxr::CesiumGlobeAnchorAPI>();
}
bool isUsdShader(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::UsdShadeShader>();
}
bool isUsdMaterial(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path) {
const auto prim = pStage->GetPrimAtPath(path);
if (!prim.IsValid()) {
return false;
}
return prim.IsA<pxr::UsdShadeMaterial>();
}
glm::dvec3 getTranslate(const pxr::UsdGeomXformOp& translateOp) {
if (translateOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionDouble) {
pxr::GfVec3d translation;
translateOp.Get(&translation);
return UsdUtil::usdToGlmVector(translation);
} else if (translateOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionFloat) {
pxr::GfVec3f translation;
translateOp.Get(&translation);
return glm::dvec3(UsdUtil::usdToGlmVector(translation));
}
return glm::dvec3(0.0);
}
glm::dvec3 getRotate(const pxr::UsdGeomXformOp& rotateOp) {
if (rotateOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionDouble) {
pxr::GfVec3d rotation;
rotateOp.Get(&rotation);
return UsdUtil::usdToGlmVector(rotation);
} else if (rotateOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionFloat) {
pxr::GfVec3f rotation;
rotateOp.Get(&rotation);
return glm::dvec3(UsdUtil::usdToGlmVector(rotation));
}
return glm::dvec3(0.0);
}
glm::dquat getOrient(const pxr::UsdGeomXformOp& orientOp) {
if (orientOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionDouble) {
pxr::GfQuatd orient;
orientOp.Get(&orient);
return UsdUtil::usdToGlmQuat(orient);
} else if (orientOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionFloat) {
pxr::GfQuatf orient;
orientOp.Get(&orient);
return glm::dquat(UsdUtil::usdToGlmQuat(orient));
}
return {1.0, 0.0, 0.0, 0.0};
}
glm::dvec3 getScale(const pxr::UsdGeomXformOp& scaleOp) {
if (scaleOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionDouble) {
pxr::GfVec3d scale;
scaleOp.Get(&scale);
return UsdUtil::usdToGlmVector(scale);
} else if (scaleOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionFloat) {
pxr::GfVec3f scale;
scaleOp.Get(&scale);
return glm::dvec3(UsdUtil::usdToGlmVector(scale));
}
return glm::dvec3(1.0);
}
void setTranslate(pxr::UsdGeomXformOp& translateOp, const glm::dvec3& translate) {
if (translateOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionDouble) {
translateOp.Set(UsdUtil::glmToUsdVector(translate));
} else if (translateOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionFloat) {
translateOp.Set(UsdUtil::glmToUsdVector(glm::fvec3(translate)));
}
}
void setRotate(pxr::UsdGeomXformOp& rotateOp, const glm::dvec3& rotate) {
if (rotateOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionDouble) {
rotateOp.Set(UsdUtil::glmToUsdVector(rotate));
} else if (rotateOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionFloat) {
rotateOp.Set(UsdUtil::glmToUsdVector(glm::fvec3(rotate)));
}
}
void setOrient(pxr::UsdGeomXformOp& orientOp, const glm::dquat& orient) {
if (orientOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionDouble) {
orientOp.Set(UsdUtil::glmToUsdQuat(orient));
} else if (orientOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionFloat) {
orientOp.Set(UsdUtil::glmToUsdQuat(glm::fquat(orient)));
}
}
void setScale(pxr::UsdGeomXformOp& scaleOp, const glm::dvec3& scale) {
if (scaleOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionDouble) {
scaleOp.Set(UsdUtil::glmToUsdVector(scale));
} else if (scaleOp.GetPrecision() == pxr::UsdGeomXformOp::PrecisionFloat) {
scaleOp.Set(UsdUtil::glmToUsdVector(glm::fvec3(scale)));
}
}
std::optional<TranslateRotateScaleOps> getOrCreateTranslateRotateScaleOps(const pxr::UsdGeomXformable& xformable) {
pxr::UsdGeomXformOp translateOp;
pxr::UsdGeomXformOp rotateOp;
pxr::UsdGeomXformOp orientOp;
pxr::UsdGeomXformOp scaleOp;
int64_t translateOpIndex = -1;
int64_t rotateOpIndex = -1;
int64_t orientOpIndex = -1;
int64_t scaleOpIndex = -1;
int64_t opCount = 0;
bool resetsXformStack;
const auto xformOps = xformable.GetOrderedXformOps(&resetsXformStack);
auto eulerAngleOrder = MathUtil::EulerAngleOrder::XYZ;
for (const auto& xformOp : xformOps) {
switch (xformOp.GetOpType()) {
case pxr::UsdGeomXformOp::TypeTranslate:
if (translateOpIndex == -1) {
translateOp = xformOp;
translateOpIndex = opCount;
}
break;
case pxr::UsdGeomXformOp::TypeRotateXYZ:
if (rotateOpIndex == -1) {
eulerAngleOrder = MathUtil::EulerAngleOrder::XYZ;
rotateOp = xformOp;
rotateOpIndex = opCount;
}
break;
case pxr::UsdGeomXformOp::TypeRotateXZY:
if (rotateOpIndex == -1) {
eulerAngleOrder = MathUtil::EulerAngleOrder::XZY;
rotateOp = xformOp;
rotateOpIndex = opCount;
}
break;
case pxr::UsdGeomXformOp::TypeRotateYXZ:
if (rotateOpIndex == -1) {
eulerAngleOrder = MathUtil::EulerAngleOrder::YXZ;
rotateOp = xformOp;
rotateOpIndex = opCount;
}
break;
case pxr::UsdGeomXformOp::TypeRotateYZX:
if (rotateOpIndex == -1) {
eulerAngleOrder = MathUtil::EulerAngleOrder::YZX;
rotateOp = xformOp;
rotateOpIndex = opCount;
}
break;
case pxr::UsdGeomXformOp::TypeRotateZXY:
if (rotateOpIndex == -1) {
eulerAngleOrder = MathUtil::EulerAngleOrder::ZXY;
rotateOp = xformOp;
rotateOpIndex = opCount;
}
break;
case pxr::UsdGeomXformOp::TypeRotateZYX:
if (rotateOpIndex == -1) {
eulerAngleOrder = MathUtil::EulerAngleOrder::ZYX;
rotateOp = xformOp;
rotateOpIndex = opCount;
}
break;
case pxr::UsdGeomXformOp::TypeOrient:
if (orientOpIndex == -1) {
orientOp = xformOp;
orientOpIndex = opCount;
}
break;
case pxr::UsdGeomXformOp::TypeScale:
if (scaleOpIndex == -1) {
scaleOp = xformOp;
scaleOpIndex = opCount;
}
break;
default:
break;
}
++opCount;
}
const auto translateOpDefined = translateOp.IsDefined();
const auto rotateOpDefined = rotateOp.IsDefined();
const auto orientOpDefined = orientOp.IsDefined();
const auto scaleOpDefined = scaleOp.IsDefined();
if (rotateOpDefined && orientOpDefined) {
return std::nullopt;
}
opCount = 0;
if (translateOpDefined && translateOpIndex != opCount++) {
return std::nullopt;
}
if (rotateOpDefined && rotateOpIndex != opCount++) {
return std::nullopt;
}
if (orientOpDefined && orientOpIndex != opCount++) {
return std::nullopt;
}
if (scaleOpDefined && scaleOpIndex != opCount++) {
return std::nullopt;
}
const auto isPrecisionSupported = [](pxr::UsdGeomXformOp::Precision precision) {
return precision == pxr::UsdGeomXformOp::PrecisionDouble || precision == pxr::UsdGeomXformOp::PrecisionFloat;
};
if (translateOpDefined && !isPrecisionSupported(translateOp.GetPrecision())) {
return std::nullopt;
}
if (rotateOpDefined && !isPrecisionSupported(rotateOp.GetPrecision())) {
return std::nullopt;
}
if (orientOpDefined && !isPrecisionSupported(orientOp.GetPrecision())) {
return std::nullopt;
}
if (scaleOpDefined && !isPrecisionSupported(scaleOp.GetPrecision())) {
return std::nullopt;
}
if (!translateOpDefined) {
translateOp = xformable.AddTranslateOp(pxr::UsdGeomXformOp::PrecisionDouble);
translateOp.Set(UsdUtil::glmToUsdVector(glm::dvec3(0.0)));
}
if (!rotateOpDefined && !orientOpDefined) {
rotateOp = xformable.AddRotateXYZOp(pxr::UsdGeomXformOp::PrecisionDouble);
rotateOp.Set(UsdUtil::glmToUsdVector(glm::dvec3(0.0)));
}
if (!scaleOpDefined) {
scaleOp = xformable.AddScaleOp(pxr::UsdGeomXformOp::PrecisionDouble);
scaleOp.Set(UsdUtil::glmToUsdVector(glm::dvec3(1.0)));
}
if (!translateOpDefined || (!rotateOpDefined && !orientOpDefined) || !scaleOpDefined) {
std::vector<pxr::UsdGeomXformOp> reorderedXformOps;
if (orientOpDefined) {
reorderedXformOps = {translateOp, orientOp, scaleOp};
} else {
reorderedXformOps = {translateOp, rotateOp, scaleOp};
}
// Add back additional xform ops like xformOp:rotateX:unitsResolve
reorderedXformOps.insert(reorderedXformOps.end(), xformOps.begin() + opCount, xformOps.end());
xformable.SetXformOpOrder(reorderedXformOps);
}
if (orientOpDefined) {
return TranslateRotateScaleOps{translateOp, orientOp, scaleOp, eulerAngleOrder};
}
return TranslateRotateScaleOps{translateOp, rotateOp, scaleOp, eulerAngleOrder};
}
} // namespace cesium::omniverse::UsdUtil
| 29,345 | C++ | 33.935714 | 120 | 0.684376 |
CesiumGS/cesium-omniverse/src/core/src/Broadcast.cpp | #include "cesium/omniverse/Broadcast.h"
#include <omni/kit/IApp.h>
#include <pxr/usd/sdf/path.h>
namespace cesium::omniverse::Broadcast {
namespace {
const std::string_view ASSETS_UPDATED_EVENT_KEY = "cesium.omniverse.ASSETS_UPDATED";
const std::string_view CONNECTION_UPDATED_EVENT_KEY = "cesium.omniverse.CONNECTION_UPDATED";
const std::string_view PROFILE_UPDATED_EVENT_KEY = "cesium.omniverse.PROFILE_UPDATED";
const std::string_view TOKENS_UPDATED_EVENT_KEY = "cesium.omniverse.TOKENS_UPDATED";
const std::string_view SHOW_TROUBLESHOOTER_EVENT_KEY = "cesium.omniverse.SHOW_TROUBLESHOOTER";
const std::string_view SET_DEFAULT_PROJECT_TOKEN_COMPLETE_KEY = "cesium.omniverse.SET_DEFAULT_PROJECT_TOKEN_COMPLETE";
const std::string_view TILESET_LOADED_KEY = "cesium.omniverse.TILESET_LOADED";
template <typename... ValuesT>
void sendMessageToBusWithPayload(carb::events::EventType eventType, ValuesT&&... payload) {
const auto iApp = carb::getCachedInterface<omni::kit::IApp>();
const auto bus = iApp->getMessageBusEventStream();
bus->push(eventType, std::forward<ValuesT>(payload)...);
}
template <typename... ValuesT>
void sendMessageToBusWithPayload(const std::string_view& eventKey, ValuesT&&... payload) {
const auto eventType = carb::events::typeFromString(eventKey.data());
sendMessageToBusWithPayload(eventType, std::forward<ValuesT>(payload)...);
}
} // namespace
void assetsUpdated() {
sendMessageToBus(ASSETS_UPDATED_EVENT_KEY);
}
void connectionUpdated() {
sendMessageToBus(CONNECTION_UPDATED_EVENT_KEY);
}
void profileUpdated() {
sendMessageToBus(PROFILE_UPDATED_EVENT_KEY);
}
void tokensUpdated() {
sendMessageToBus(TOKENS_UPDATED_EVENT_KEY);
}
void showTroubleshooter(
const pxr::SdfPath& tilesetPath,
int64_t tilesetIonAssetId,
const std::string& tilesetName,
int64_t rasterOverlayIonAssetId,
const std::string& rasterOverlayName,
const std::string& message) {
sendMessageToBusWithPayload(
SHOW_TROUBLESHOOTER_EVENT_KEY,
std::make_pair("tilesetPath", tilesetPath.GetText()),
std::make_pair("tilesetIonAssetId", tilesetIonAssetId),
std::make_pair("tilesetName", tilesetName.c_str()),
std::make_pair("rasterOverlayIonAssetId", rasterOverlayIonAssetId),
std::make_pair("rasterOverlayName", rasterOverlayName.c_str()),
std::make_pair("message", message.c_str()));
}
void setDefaultTokenComplete() {
sendMessageToBus(SET_DEFAULT_PROJECT_TOKEN_COMPLETE_KEY);
}
void tilesetLoaded(const pxr::SdfPath& tilesetPath) {
sendMessageToBusWithPayload(TILESET_LOADED_KEY, std::make_pair("tilesetPath", tilesetPath.GetText()));
}
void sendMessageToBus(carb::events::EventType eventType) {
const auto iApp = carb::getCachedInterface<omni::kit::IApp>();
const auto bus = iApp->getMessageBusEventStream();
bus->push(eventType);
}
void sendMessageToBus(const std::string_view& eventKey) {
const auto eventType = carb::events::typeFromString(eventKey.data());
sendMessageToBus(eventType);
}
} // namespace cesium::omniverse::Broadcast
| 3,094 | C++ | 35.411764 | 118 | 0.739819 |
CesiumGS/cesium-omniverse/src/core/src/OmniWebMapServiceRasterOverlay.cpp | #include "cesium/omniverse/OmniWebMapServiceRasterOverlay.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumRasterOverlays/WebMapServiceRasterOverlay.h>
#include <CesiumUsdSchemas/webMapServiceRasterOverlay.h>
namespace cesium::omniverse {
OmniWebMapServiceRasterOverlay::OmniWebMapServiceRasterOverlay(Context* pContext, const pxr::SdfPath& path)
: OmniRasterOverlay(pContext, path) {
reload();
}
CesiumRasterOverlays::RasterOverlay* OmniWebMapServiceRasterOverlay::getRasterOverlay() const {
return _pWebMapServiceRasterOverlay.get();
}
std::string OmniWebMapServiceRasterOverlay::getBaseUrl() const {
const auto cesiumWebMapServiceRasterOverlay =
UsdUtil::getCesiumWebMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapServiceRasterOverlay)) {
return "";
}
std::string baseUrl;
cesiumWebMapServiceRasterOverlay.GetBaseUrlAttr().Get(&baseUrl);
return baseUrl;
}
int OmniWebMapServiceRasterOverlay::getMinimumLevel() const {
const auto cesiumWebMapServiceRasterOverlay =
UsdUtil::getCesiumWebMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapServiceRasterOverlay)) {
return 0;
}
int minimumLevel;
cesiumWebMapServiceRasterOverlay.GetMinimumLevelAttr().Get(&minimumLevel);
return minimumLevel;
}
int OmniWebMapServiceRasterOverlay::getMaximumLevel() const {
const auto cesiumWebMapServiceRasterOverlay =
UsdUtil::getCesiumWebMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapServiceRasterOverlay)) {
return 14;
}
int maximumLevel;
cesiumWebMapServiceRasterOverlay.GetMaximumLevelAttr().Get(&maximumLevel);
return maximumLevel;
}
int OmniWebMapServiceRasterOverlay::getTileWidth() const {
const auto cesiumWebMapServiceRasterOverlay =
UsdUtil::getCesiumWebMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapServiceRasterOverlay)) {
return 256;
}
int tileWidth;
cesiumWebMapServiceRasterOverlay.GetTileWidthAttr().Get(&tileWidth);
return tileWidth;
}
int OmniWebMapServiceRasterOverlay::getTileHeight() const {
const auto cesiumWebMapServiceRasterOverlay =
UsdUtil::getCesiumWebMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapServiceRasterOverlay)) {
return 256;
}
int tileHeight;
cesiumWebMapServiceRasterOverlay.GetTileHeightAttr().Get(&tileHeight);
return tileHeight;
}
std::string OmniWebMapServiceRasterOverlay::getLayers() const {
const auto cesiumWebMapServiceRasterOverlay =
UsdUtil::getCesiumWebMapServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapServiceRasterOverlay)) {
return "1";
}
std::string layers;
cesiumWebMapServiceRasterOverlay.GetLayersAttr().Get(&layers);
return layers;
}
void OmniWebMapServiceRasterOverlay::reload() {
const auto rasterOverlayName = UsdUtil::getName(_pContext->getUsdStage(), _path);
auto options = createRasterOverlayOptions();
options.loadErrorCallback = [this](const CesiumRasterOverlays::RasterOverlayLoadFailureDetails& error) {
_pContext->getLogger()->error(error.message);
};
CesiumRasterOverlays::WebMapServiceRasterOverlayOptions wmsOptions;
const auto minimumLevel = getMinimumLevel();
const auto maximumLevel = getMaximumLevel();
const auto tileWidth = getTileWidth();
const auto tileHeight = getTileHeight();
std::string layers = getLayers();
wmsOptions.minimumLevel = minimumLevel;
wmsOptions.maximumLevel = maximumLevel;
wmsOptions.layers = layers;
wmsOptions.tileWidth = tileWidth;
wmsOptions.tileHeight = tileHeight;
_pWebMapServiceRasterOverlay = new CesiumRasterOverlays::WebMapServiceRasterOverlay(
rasterOverlayName, getBaseUrl(), std::vector<CesiumAsync::IAssetAccessor::THeader>(), wmsOptions, options);
}
} // namespace cesium::omniverse
| 4,354 | C++ | 34.406504 | 115 | 0.758842 |
CesiumGS/cesium-omniverse/src/core/src/OmniPolygonRasterOverlay.cpp | #include "cesium/omniverse/OmniPolygonRasterOverlay.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/OmniCartographicPolygon.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/OmniGlobeAnchor.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumRasterOverlays/RasterizedPolygonsOverlay.h>
#include <CesiumUsdSchemas/polygonRasterOverlay.h>
namespace cesium::omniverse {
OmniPolygonRasterOverlay::OmniPolygonRasterOverlay(Context* pContext, const pxr::SdfPath& path)
: OmniRasterOverlay(pContext, path) {}
std::vector<pxr::SdfPath> OmniPolygonRasterOverlay::getCartographicPolygonPaths() const {
const auto cesiumPolygonRasterOverlay = UsdUtil::getCesiumPolygonRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumPolygonRasterOverlay)) {
return {};
}
pxr::SdfPathVector targets;
cesiumPolygonRasterOverlay.GetCartographicPolygonBindingRel().GetForwardedTargets(&targets);
return targets;
}
CesiumRasterOverlays::RasterOverlay* OmniPolygonRasterOverlay::getRasterOverlay() const {
return _pPolygonRasterOverlay.get();
}
bool OmniPolygonRasterOverlay::getInvertSelection() const {
const auto cesiumPolygonRasterOverlay = UsdUtil::getCesiumPolygonRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumPolygonRasterOverlay)) {
return false;
}
bool invertSelection;
cesiumPolygonRasterOverlay.GetInvertSelectionAttr().Get(&invertSelection);
return invertSelection;
}
bool OmniPolygonRasterOverlay::getExcludeSelectedTiles() const {
auto cesiumPolygonRasterOverlay = UsdUtil::getCesiumPolygonRasterOverlay(_pContext->getUsdStage(), _path);
bool val;
cesiumPolygonRasterOverlay.GetExcludeSelectedTilesAttr().Get(&val);
return val;
}
std::shared_ptr<Cesium3DTilesSelection::RasterizedPolygonsTileExcluder> OmniPolygonRasterOverlay::getExcluder() {
return _pExcluder;
}
void OmniPolygonRasterOverlay::reload() {
const auto rasterOverlayName = UsdUtil::getName(_pContext->getUsdStage(), _path);
const auto cartographicPolygonPaths = getCartographicPolygonPaths();
std::vector<CesiumGeospatial::CartographicPolygon> polygons;
const CesiumGeospatial::Ellipsoid* pEllipsoid = nullptr;
for (const auto& cartographicPolygonPath : cartographicPolygonPaths) {
const auto pCartographicPolygon = _pContext->getAssetRegistry().getCartographicPolygon(cartographicPolygonPath);
if (!pCartographicPolygon) {
continue;
}
const auto pGlobeAnchor = _pContext->getAssetRegistry().getGlobeAnchor(cartographicPolygonPath);
if (!pGlobeAnchor) {
continue;
}
const auto georeferencePath = pGlobeAnchor->getResolvedGeoreferencePath();
if (georeferencePath.IsEmpty()) {
continue;
}
const auto pGeoreference = _pContext->getAssetRegistry().getGeoreference(georeferencePath);
if (!pGeoreference) {
continue;
}
const auto& ellipsoid = pGeoreference->getEllipsoid();
if (!pEllipsoid) {
pEllipsoid = &ellipsoid;
} else if (*pEllipsoid != ellipsoid) {
return; // All cartographic polygons must use the same ellipsoid
}
const auto cartographics = pCartographicPolygon->getCartographics();
std::vector<glm::dvec2> polygon;
for (const auto& cartographic : cartographics) {
polygon.emplace_back(cartographic.longitude, cartographic.latitude);
}
polygons.emplace_back(polygon);
}
if (polygons.empty()) {
return;
}
if (!pEllipsoid) {
return;
}
const auto projection = CesiumGeospatial::GeographicProjection(*pEllipsoid);
auto options = createRasterOverlayOptions();
options.loadErrorCallback = [this](const CesiumRasterOverlays::RasterOverlayLoadFailureDetails& error) {
_pContext->getLogger()->error(error.message);
};
_pPolygonRasterOverlay = new CesiumRasterOverlays::RasterizedPolygonsOverlay(
rasterOverlayName, polygons, getInvertSelection(), *pEllipsoid, projection, options);
if (getExcludeSelectedTiles()) {
auto pPolygons = _pPolygonRasterOverlay.get();
_pExcluder = std::make_shared<Cesium3DTilesSelection::RasterizedPolygonsTileExcluder>(pPolygons);
}
}
} // namespace cesium::omniverse
| 4,610 | C++ | 34.198473 | 120 | 0.7282 |
CesiumGS/cesium-omniverse/src/core/src/AssetRegistry.cpp | #include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/CppUtil.h"
#include "cesium/omniverse/OmniCartographicPolygon.h"
#include "cesium/omniverse/OmniData.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/OmniGlobeAnchor.h"
#include "cesium/omniverse/OmniIonRasterOverlay.h"
#include "cesium/omniverse/OmniIonServer.h"
#include "cesium/omniverse/OmniPolygonRasterOverlay.h"
#include "cesium/omniverse/OmniTileMapServiceRasterOverlay.h"
#include "cesium/omniverse/OmniTileset.h"
#include "cesium/omniverse/OmniWebMapServiceRasterOverlay.h"
#include "cesium/omniverse/OmniWebMapTileServiceRasterOverlay.h"
#include "cesium/omniverse/UsdUtil.h"
#include "cesium/omniverse/Viewport.h"
namespace cesium::omniverse {
AssetRegistry::AssetRegistry(Context* pContext)
: _pContext(pContext) {}
AssetRegistry::~AssetRegistry() = default;
void AssetRegistry::onUpdateFrame(const gsl::span<const Viewport>& viewports, bool waitForLoadingTiles) {
for (const auto& pTileset : _tilesets) {
pTileset->onUpdateFrame(viewports, waitForLoadingTiles);
}
}
OmniData& AssetRegistry::addData(const pxr::SdfPath& path) {
return *_datas.insert(_datas.end(), std::make_unique<OmniData>(_pContext, path))->get();
}
void AssetRegistry::removeData(const pxr::SdfPath& path) {
CppUtil::eraseIf(_datas, [&path](const auto& pData) { return pData->getPath() == path; });
}
OmniData* AssetRegistry::getData(const pxr::SdfPath& path) const {
for (const auto& pData : _datas) {
if (pData->getPath() == path) {
return pData.get();
}
}
return nullptr;
}
OmniData* AssetRegistry::getFirstData() const {
if (_datas.empty()) {
return nullptr;
}
return _datas.front().get();
}
OmniTileset& AssetRegistry::addTileset(const pxr::SdfPath& path) {
return *_tilesets.insert(_tilesets.end(), std::make_unique<OmniTileset>(_pContext, path, _tilesetId++))->get();
}
void AssetRegistry::removeTileset(const pxr::SdfPath& path) {
CppUtil::eraseIf(_tilesets, [&path](const auto& pTileset) { return pTileset->getPath() == path; });
}
OmniTileset* AssetRegistry::getTileset(const pxr::SdfPath& path) const {
for (const auto& pTileset : _tilesets) {
if (pTileset->getPath() == path) {
return pTileset.get();
}
}
return nullptr;
}
const std::vector<std::unique_ptr<OmniTileset>>& AssetRegistry::getTilesets() const {
return _tilesets;
}
OmniIonRasterOverlay& AssetRegistry::addIonRasterOverlay(const pxr::SdfPath& path) {
return *_ionRasterOverlays
.insert(_ionRasterOverlays.end(), std::make_unique<OmniIonRasterOverlay>(_pContext, path))
->get();
}
void AssetRegistry::removeIonRasterOverlay(const pxr::SdfPath& path) {
CppUtil::eraseIf(
_ionRasterOverlays, [&path](const auto& pIonRasterOverlay) { return pIonRasterOverlay->getPath() == path; });
}
OmniIonRasterOverlay* AssetRegistry::getIonRasterOverlay(const pxr::SdfPath& path) const {
for (const auto& pIonRasterOverlay : _ionRasterOverlays) {
if (pIonRasterOverlay->getPath() == path) {
return pIonRasterOverlay.get();
}
}
return nullptr;
}
OmniIonRasterOverlay* AssetRegistry::getIonRasterOverlayByIonAssetId(int64_t ionAssetId) const {
for (const auto& pIonRasterOverlay : _ionRasterOverlays) {
if (pIonRasterOverlay->getIonAssetId() == ionAssetId) {
return pIonRasterOverlay.get();
}
}
return nullptr;
}
const std::vector<std::unique_ptr<OmniIonRasterOverlay>>& AssetRegistry::getIonRasterOverlays() const {
return _ionRasterOverlays;
}
OmniPolygonRasterOverlay& AssetRegistry::addPolygonRasterOverlay(const pxr::SdfPath& path) {
return *_polygonRasterOverlays
.insert(_polygonRasterOverlays.end(), std::make_unique<OmniPolygonRasterOverlay>(_pContext, path))
->get();
}
void AssetRegistry::removePolygonRasterOverlay(const pxr::SdfPath& path) {
CppUtil::eraseIf(_polygonRasterOverlays, [&path](const auto& pPolygonRasterOverlay) {
return pPolygonRasterOverlay->getPath() == path;
});
}
OmniPolygonRasterOverlay* AssetRegistry::getPolygonRasterOverlay(const pxr::SdfPath& path) const {
for (const auto& pPolygonRasterOverlay : _polygonRasterOverlays) {
if (pPolygonRasterOverlay->getPath() == path) {
return pPolygonRasterOverlay.get();
}
}
return nullptr;
}
OmniWebMapServiceRasterOverlay& AssetRegistry::addWebMapServiceRasterOverlay(const pxr::SdfPath& path) {
return *_webMapServiceRasterOverlays
.insert(
_webMapServiceRasterOverlays.end(),
std::make_unique<OmniWebMapServiceRasterOverlay>(_pContext, path))
->get();
}
void AssetRegistry::removeWebMapServiceRasterOverlay(const pxr::SdfPath& path) {
CppUtil::eraseIf(_webMapServiceRasterOverlays, [&path](const auto& pWebMapServiceRasterOverlay) {
return pWebMapServiceRasterOverlay->getPath() == path;
});
}
OmniWebMapServiceRasterOverlay* AssetRegistry::getWebMapServiceRasterOverlay(const pxr::SdfPath& path) const {
for (const auto& pWebMapServiceRasterOverlay : _webMapServiceRasterOverlays) {
if (pWebMapServiceRasterOverlay->getPath() == path) {
return pWebMapServiceRasterOverlay.get();
}
}
return nullptr;
}
OmniTileMapServiceRasterOverlay& AssetRegistry::addTileMapServiceRasterOverlay(const pxr::SdfPath& path) {
return *_tileMapServiceRasterOverlays
.insert(
_tileMapServiceRasterOverlays.end(),
std::make_unique<OmniTileMapServiceRasterOverlay>(_pContext, path))
->get();
}
void AssetRegistry::removeTileMapServiceRasterOverlay(const pxr::SdfPath& path) {
CppUtil::eraseIf(_tileMapServiceRasterOverlays, [&path](const auto& pTileMapServiceRasterOverlay) {
return pTileMapServiceRasterOverlay->getPath() == path;
});
}
OmniTileMapServiceRasterOverlay* AssetRegistry::getTileMapServiceRasterOverlay(const pxr::SdfPath& path) const {
for (const auto& pTileMapServiceRasterOverlay : _tileMapServiceRasterOverlays) {
if (pTileMapServiceRasterOverlay->getPath() == path) {
return pTileMapServiceRasterOverlay.get();
}
}
return nullptr;
}
OmniWebMapTileServiceRasterOverlay& AssetRegistry::addWebMapTileServiceRasterOverlay(const pxr::SdfPath& path) {
return *_webMapTileServiceRasterOverlays
.insert(
_webMapTileServiceRasterOverlays.end(),
std::make_unique<OmniWebMapTileServiceRasterOverlay>(_pContext, path))
->get();
}
void AssetRegistry::removeWebMapTileServiceRasterOverlay(const pxr::SdfPath& path) {
CppUtil::eraseIf(_webMapTileServiceRasterOverlays, [&path](const auto& pWebMapTileServiceRasterOverlay) {
return pWebMapTileServiceRasterOverlay->getPath() == path;
});
}
OmniWebMapTileServiceRasterOverlay* AssetRegistry::getWebMapTileServiceRasterOverlay(const pxr::SdfPath& path) const {
for (const auto& pWebMapTileServiceRasterOverlay : _webMapTileServiceRasterOverlays) {
if (pWebMapTileServiceRasterOverlay->getPath() == path) {
return pWebMapTileServiceRasterOverlay.get();
}
}
return nullptr;
}
const std::vector<std::unique_ptr<OmniPolygonRasterOverlay>>& AssetRegistry::getPolygonRasterOverlays() const {
return _polygonRasterOverlays;
}
OmniRasterOverlay* AssetRegistry::getRasterOverlay(const pxr::SdfPath& path) const {
const auto pIonRasterOverlay = getIonRasterOverlay(path);
if (pIonRasterOverlay) {
return pIonRasterOverlay;
}
const auto pPolygonRasterOverlay = getPolygonRasterOverlay(path);
if (pPolygonRasterOverlay) {
return pPolygonRasterOverlay;
}
const auto pWebMapServiceRasterOverlay = getWebMapServiceRasterOverlay(path);
if (pWebMapServiceRasterOverlay) {
return pWebMapServiceRasterOverlay;
}
const auto pTileMapServiceRasterOverlay = getTileMapServiceRasterOverlay(path);
if (pTileMapServiceRasterOverlay) {
return pTileMapServiceRasterOverlay;
}
const auto pWebMapTileServiceRasterOverlay = getWebMapTileServiceRasterOverlay(path);
if (pWebMapTileServiceRasterOverlay) {
return pWebMapTileServiceRasterOverlay;
}
return nullptr;
}
OmniGeoreference& AssetRegistry::addGeoreference(const pxr::SdfPath& path) {
return *_georeferences.insert(_georeferences.end(), std::make_unique<OmniGeoreference>(_pContext, path))->get();
}
void AssetRegistry::removeGeoreference(const pxr::SdfPath& path) {
CppUtil::eraseIf(_georeferences, [&path](const auto& pGeoreference) { return pGeoreference->getPath() == path; });
}
OmniGeoreference* AssetRegistry::getGeoreference(const pxr::SdfPath& path) const {
for (const auto& pGeoreference : _georeferences) {
if (pGeoreference->getPath() == path) {
return pGeoreference.get();
}
}
return nullptr;
}
const std::vector<std::unique_ptr<OmniGeoreference>>& AssetRegistry::getGeoreferences() const {
return _georeferences;
}
OmniGeoreference* AssetRegistry::getFirstGeoreference() const {
if (_georeferences.empty()) {
return nullptr;
}
return _georeferences.front().get();
}
OmniGlobeAnchor& AssetRegistry::addGlobeAnchor(const pxr::SdfPath& path) {
return *_globeAnchors.insert(_globeAnchors.end(), std::make_unique<OmniGlobeAnchor>(_pContext, path))->get();
}
void AssetRegistry::removeGlobeAnchor(const pxr::SdfPath& path) {
CppUtil::eraseIf(_globeAnchors, [&path](const auto& pGlobeAnchor) { return pGlobeAnchor->getPath() == path; });
}
OmniGlobeAnchor* AssetRegistry::getGlobeAnchor(const pxr::SdfPath& path) const {
for (const auto& pGlobeAnchor : _globeAnchors) {
if (pGlobeAnchor->getPath() == path) {
return pGlobeAnchor.get();
}
}
return nullptr;
}
const std::vector<std::unique_ptr<OmniGlobeAnchor>>& AssetRegistry::getGlobeAnchors() const {
return _globeAnchors;
}
OmniIonServer& AssetRegistry::addIonServer(const pxr::SdfPath& path) {
return *_ionServers.insert(_ionServers.end(), std::make_unique<OmniIonServer>(_pContext, path))->get();
}
void AssetRegistry::removeIonServer(const pxr::SdfPath& path) {
CppUtil::eraseIf(_ionServers, [&path](const auto& pIonServer) { return pIonServer->getPath() == path; });
}
OmniIonServer* AssetRegistry::getIonServer(const pxr::SdfPath& path) const {
for (const auto& pIonServer : _ionServers) {
if (pIonServer->getPath() == path) {
return pIonServer.get();
}
}
return nullptr;
}
const std::vector<std::unique_ptr<OmniIonServer>>& AssetRegistry::getIonServers() const {
return _ionServers;
}
OmniIonServer* AssetRegistry::getFirstIonServer() const {
if (_ionServers.empty()) {
return nullptr;
}
return _ionServers.front().get();
}
OmniCartographicPolygon& AssetRegistry::addCartographicPolygon(const pxr::SdfPath& path) {
return *_cartographicPolygons
.insert(_cartographicPolygons.end(), std::make_unique<OmniCartographicPolygon>(_pContext, path))
->get();
}
void AssetRegistry::removeCartographicPolygon(const pxr::SdfPath& path) {
CppUtil::eraseIf(_cartographicPolygons, [&path](const auto& pCartographicPolygon) {
return pCartographicPolygon->getPath() == path;
});
}
OmniCartographicPolygon* AssetRegistry::getCartographicPolygon(const pxr::SdfPath& path) const {
for (const auto& pCartographicPolygon : _cartographicPolygons) {
if (pCartographicPolygon->getPath() == path) {
return pCartographicPolygon.get();
}
}
return nullptr;
}
const std::vector<std::unique_ptr<OmniCartographicPolygon>>& AssetRegistry::getCartographicPolygons() const {
return _cartographicPolygons;
}
AssetType AssetRegistry::getAssetType(const pxr::SdfPath& path) const {
if (getData(path)) {
return AssetType::DATA;
} else if (getTileset(path)) {
return AssetType::TILESET;
} else if (getIonRasterOverlay(path)) {
return AssetType::ION_RASTER_OVERLAY;
} else if (getPolygonRasterOverlay(path)) {
return AssetType::POLYGON_RASTER_OVERLAY;
} else if (getGeoreference(path)) {
return AssetType::GEOREFERENCE;
} else if (getIonServer(path)) {
return AssetType::ION_SERVER;
} else if (getCartographicPolygon(path)) {
return AssetType::CARTOGRAPHIC_POLYGON;
} else if (getGlobeAnchor(path)) {
// Globe anchor needs to be checked last since prim types take precedence over API schemas
return AssetType::GLOBE_ANCHOR;
} else {
return AssetType::OTHER;
}
}
bool AssetRegistry::hasAsset(const pxr::SdfPath& path) const {
return getAssetType(path) != AssetType::OTHER;
}
void AssetRegistry::clear() {
_datas.clear();
_tilesets.clear();
_ionRasterOverlays.clear();
_polygonRasterOverlays.clear();
_georeferences.clear();
_globeAnchors.clear();
_ionServers.clear();
_cartographicPolygons.clear();
}
} // namespace cesium::omniverse
| 13,357 | C++ | 33.427835 | 118 | 0.701954 |
CesiumGS/cesium-omniverse/src/core/src/OmniWebMapTileServiceRasterOverlay.cpp | #include "cesium/omniverse/OmniWebMapTileServiceRasterOverlay.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumRasterOverlays/WebMapTileServiceRasterOverlay.h>
#include <CesiumUsdSchemas/webMapTileServiceRasterOverlay.h>
#include <string>
namespace cesium::omniverse {
OmniWebMapTileServiceRasterOverlay::OmniWebMapTileServiceRasterOverlay(Context* pContext, const pxr::SdfPath& path)
: OmniRasterOverlay(pContext, path) {
reload();
}
CesiumRasterOverlays::RasterOverlay* OmniWebMapTileServiceRasterOverlay::getRasterOverlay() const {
return _pWebMapTileServiceRasterOverlay.get();
}
std::string OmniWebMapTileServiceRasterOverlay::getUrl() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return "";
}
std::string url;
cesiumWebMapTileServiceRasterOverlay.GetUrlAttr().Get(&url);
return url;
}
std::string OmniWebMapTileServiceRasterOverlay::getLayer() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return "";
}
std::string layer;
cesiumWebMapTileServiceRasterOverlay.GetLayerAttr().Get(&layer);
return layer;
}
std::string OmniWebMapTileServiceRasterOverlay::getTileMatrixSetId() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return "";
}
std::string val;
cesiumWebMapTileServiceRasterOverlay.GetTileMatrixSetIdAttr().Get(&val);
return val;
}
std::string OmniWebMapTileServiceRasterOverlay::getStyle() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return "";
}
std::string val;
cesiumWebMapTileServiceRasterOverlay.GetStyleAttr().Get(&val);
return val;
}
std::string OmniWebMapTileServiceRasterOverlay::getFormat() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return "";
}
std::string val;
cesiumWebMapTileServiceRasterOverlay.GetFormatAttr().Get(&val);
return val;
}
int OmniWebMapTileServiceRasterOverlay::getMinimumZoomLevel() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return 0;
}
int val;
cesiumWebMapTileServiceRasterOverlay.GetMinimumZoomLevelAttr().Get(&val);
return val;
}
int OmniWebMapTileServiceRasterOverlay::getMaximumZoomLevel() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return 0;
}
int val;
cesiumWebMapTileServiceRasterOverlay.GetMaximumZoomLevelAttr().Get(&val);
return val;
}
bool OmniWebMapTileServiceRasterOverlay::getSpecifyZoomLevels() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return false;
}
bool val;
cesiumWebMapTileServiceRasterOverlay.GetSpecifyZoomLevelsAttr().Get(&val);
return val;
}
bool OmniWebMapTileServiceRasterOverlay::getUseWebMercatorProjection() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return false;
}
bool val;
cesiumWebMapTileServiceRasterOverlay.GetUseWebMercatorProjectionAttr().Get(&val);
return val;
}
bool OmniWebMapTileServiceRasterOverlay::getSpecifyTilingScheme() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return false;
}
bool val;
cesiumWebMapTileServiceRasterOverlay.GetSpecifyTilingSchemeAttr().Get(&val);
return val;
}
double OmniWebMapTileServiceRasterOverlay::getNorth() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return 90;
}
double val;
cesiumWebMapTileServiceRasterOverlay.GetNorthAttr().Get(&val);
return val;
}
double OmniWebMapTileServiceRasterOverlay::getSouth() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return -90;
}
double val;
cesiumWebMapTileServiceRasterOverlay.GetSouthAttr().Get(&val);
return val;
}
double OmniWebMapTileServiceRasterOverlay::getEast() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return 180;
}
double val;
cesiumWebMapTileServiceRasterOverlay.GetEastAttr().Get(&val);
return val;
}
double OmniWebMapTileServiceRasterOverlay::getWest() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return -180;
}
double val;
cesiumWebMapTileServiceRasterOverlay.GetWestAttr().Get(&val);
return val;
}
bool OmniWebMapTileServiceRasterOverlay::getSpecifyTileMatrixSetLabels() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return false;
}
bool val;
cesiumWebMapTileServiceRasterOverlay.GetSpecifyTileMatrixSetLabelsAttr().Get(&val);
return val;
}
std::vector<std::string> OmniWebMapTileServiceRasterOverlay::getTileMatrixSetLabels() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return {};
}
std::string val;
cesiumWebMapTileServiceRasterOverlay.GetTileMatrixSetLabelsAttr().Get(&val);
std::vector<std::string> matrixSetLabels;
size_t pos = 0;
while ((pos = val.find(',')) != std::string::npos) {
matrixSetLabels.push_back(val.substr(0, pos));
val.erase(0, pos + 1);
}
matrixSetLabels.push_back(val);
return matrixSetLabels;
}
std::string OmniWebMapTileServiceRasterOverlay::getTileMatrixSetLabelPrefix() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return "";
}
std::string val;
cesiumWebMapTileServiceRasterOverlay.GetTileMatrixSetLabelPrefixAttr().Get(&val);
return val;
}
int OmniWebMapTileServiceRasterOverlay::getRootTilesX() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return 1;
}
int val;
cesiumWebMapTileServiceRasterOverlay.GetRootTilesXAttr().Get(&val);
return val;
}
int OmniWebMapTileServiceRasterOverlay::getRootTilesY() const {
const auto cesiumWebMapTileServiceRasterOverlay =
UsdUtil::getCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumWebMapTileServiceRasterOverlay)) {
return 1;
}
int val;
cesiumWebMapTileServiceRasterOverlay.GetRootTilesYAttr().Get(&val);
return val;
}
void OmniWebMapTileServiceRasterOverlay::reload() {
const auto rasterOverlayName = UsdUtil::getName(_pContext->getUsdStage(), _path);
auto options = createRasterOverlayOptions();
options.loadErrorCallback = [this](const CesiumRasterOverlays::RasterOverlayLoadFailureDetails& error) {
_pContext->getLogger()->error(error.message);
};
CesiumRasterOverlays::WebMapTileServiceRasterOverlayOptions wmtsOptions;
const auto tileMatrixSetId = getTileMatrixSetId();
if (!tileMatrixSetId.empty()) {
wmtsOptions.tileMatrixSetID = tileMatrixSetId;
}
const auto style = getStyle();
if (!style.empty()) {
wmtsOptions.style = style;
}
const auto layer = getLayer();
if (!layer.empty()) {
wmtsOptions.layer = layer;
}
const auto format = getFormat();
if (!format.empty()) {
wmtsOptions.format = format;
}
if (getSpecifyZoomLevels()) {
wmtsOptions.minimumLevel = getMinimumZoomLevel();
wmtsOptions.maximumLevel = getMaximumZoomLevel();
}
CesiumGeospatial::Projection projection;
const auto useWebMercatorProjection = getUseWebMercatorProjection();
if (useWebMercatorProjection) {
projection = CesiumGeospatial::WebMercatorProjection();
wmtsOptions.projection = projection;
} else {
projection = CesiumGeospatial::GeographicProjection();
wmtsOptions.projection = projection;
}
if (getSpecifyTilingScheme()) {
CesiumGeospatial::GlobeRectangle globeRectangle =
CesiumGeospatial::GlobeRectangle::fromDegrees(getWest(), getSouth(), getEast(), getNorth());
CesiumGeometry::Rectangle coverageRectangle =
CesiumGeospatial::projectRectangleSimple(projection, globeRectangle);
wmtsOptions.coverageRectangle = coverageRectangle;
const auto rootTilesX = getRootTilesX();
const auto rootTilesY = getRootTilesY();
wmtsOptions.tilingScheme = CesiumGeometry::QuadtreeTilingScheme(coverageRectangle, rootTilesX, rootTilesY);
}
if (getSpecifyTileMatrixSetLabels()) {
const auto tileMatrixSetLabels = getTileMatrixSetLabels();
if (!tileMatrixSetLabels.empty()) {
wmtsOptions.tileMatrixLabels = getTileMatrixSetLabels();
}
} else {
const auto tileMatrixSetLabelPrefix = getTileMatrixSetLabelPrefix();
if (!tileMatrixSetLabelPrefix.empty()) {
std::vector<std::string> labels;
for (size_t level = 0; level <= 25; ++level) {
std::string label{tileMatrixSetLabelPrefix};
label.append(std::to_string(level));
labels.emplace_back(label);
}
wmtsOptions.tileMatrixLabels = labels;
}
}
_pWebMapTileServiceRasterOverlay = new CesiumRasterOverlays::WebMapTileServiceRasterOverlay(
rasterOverlayName, getUrl(), std::vector<CesiumAsync::IAssetAccessor::THeader>(), wmtsOptions, options);
}
} // namespace cesium::omniverse
| 12,199 | C++ | 34.672515 | 115 | 0.734404 |
CesiumGS/cesium-omniverse/src/core/src/OmniData.cpp | #include "cesium/omniverse/OmniData.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumUsdSchemas/data.h>
namespace cesium::omniverse {
OmniData::OmniData(Context* pContext, const pxr::SdfPath& path)
: _pContext(pContext)
, _path(path) {}
const pxr::SdfPath& OmniData::getPath() const {
return _path;
}
pxr::SdfPath OmniData::getSelectedIonServerPath() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return {};
}
pxr::SdfPathVector targets;
cesiumData.GetSelectedIonServerRel().GetForwardedTargets(&targets);
if (targets.empty()) {
return {};
}
return targets.front();
}
bool OmniData::getDebugDisableMaterials() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return false;
}
bool disableMaterials;
cesiumData.GetDebugDisableMaterialsAttr().Get(&disableMaterials);
return disableMaterials;
}
bool OmniData::getDebugDisableTextures() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return false;
}
bool disableTextures;
cesiumData.GetDebugDisableTexturesAttr().Get(&disableTextures);
return disableTextures;
}
bool OmniData::getDebugDisableGeometryPool() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return false;
}
bool disableGeometryPool;
cesiumData.GetDebugDisableGeometryPoolAttr().Get(&disableGeometryPool);
return disableGeometryPool;
}
bool OmniData::getDebugDisableMaterialPool() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return false;
}
bool disableMaterialPool;
cesiumData.GetDebugDisableMaterialPoolAttr().Get(&disableMaterialPool);
return disableMaterialPool;
}
bool OmniData::getDebugDisableTexturePool() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return false;
}
bool disableTexturePool;
cesiumData.GetDebugDisableTexturePoolAttr().Get(&disableTexturePool);
return disableTexturePool;
}
uint64_t OmniData::getDebugGeometryPoolInitialCapacity() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return 2048;
}
uint64_t geometryPoolInitialCapacity;
cesiumData.GetDebugGeometryPoolInitialCapacityAttr().Get(&geometryPoolInitialCapacity);
return geometryPoolInitialCapacity;
}
uint64_t OmniData::getDebugMaterialPoolInitialCapacity() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return 2048;
}
uint64_t materialPoolInitialCapacity;
cesiumData.GetDebugMaterialPoolInitialCapacityAttr().Get(&materialPoolInitialCapacity);
return materialPoolInitialCapacity;
}
uint64_t OmniData::getDebugTexturePoolInitialCapacity() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return 2048;
}
uint64_t texturePoolInitialCapacity;
cesiumData.GetDebugTexturePoolInitialCapacityAttr().Get(&texturePoolInitialCapacity);
return texturePoolInitialCapacity;
}
bool OmniData::getDebugRandomColors() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return false;
}
bool debugRandomColors;
cesiumData.GetDebugRandomColorsAttr().Get(&debugRandomColors);
return debugRandomColors;
}
bool OmniData::getDebugDisableGeoreferencing() const {
const auto cesiumData = UsdUtil::getCesiumData(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumData)) {
return false;
}
bool debugDisableGeoreferencing;
cesiumData.GetDebugDisableGeoreferencingAttr().Get(&debugDisableGeoreferencing);
return debugDisableGeoreferencing;
}
} // namespace cesium::omniverse
| 4,464 | C++ | 27.806451 | 91 | 0.727599 |
CesiumGS/cesium-omniverse/src/core/src/OmniRasterOverlay.cpp | #include "cesium/omniverse/OmniRasterOverlay.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/FabricRasterOverlaysInfo.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/OmniIonServer.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumIonClient/Token.h>
#include <CesiumUsdSchemas/rasterOverlay.h>
namespace cesium::omniverse {
OmniRasterOverlay::OmniRasterOverlay(Context* pContext, const pxr::SdfPath& path)
: _pContext(pContext)
, _path(path) {}
const pxr::SdfPath& OmniRasterOverlay::getPath() const {
return _path;
}
bool OmniRasterOverlay::getShowCreditsOnScreen() const {
const auto cesiumRasterOverlay = UsdUtil::getCesiumRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumRasterOverlay)) {
return false;
}
bool showCreditsOnScreen;
cesiumRasterOverlay.GetShowCreditsOnScreenAttr().Get(&showCreditsOnScreen);
return showCreditsOnScreen;
}
double OmniRasterOverlay::getAlpha() const {
const auto cesiumRasterOverlay = UsdUtil::getCesiumRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumRasterOverlay)) {
return 1.0;
}
float alpha;
cesiumRasterOverlay.GetAlphaAttr().Get(&alpha);
return static_cast<double>(alpha);
}
float OmniRasterOverlay::getMaximumScreenSpaceError() const {
const auto cesiumRasterOverlay = UsdUtil::getCesiumRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumRasterOverlay)) {
return 2.0f;
}
float value;
cesiumRasterOverlay.GetMaximumScreenSpaceErrorAttr().Get(&value);
return static_cast<float>(value);
}
int OmniRasterOverlay::getMaximumTextureSize() const {
const auto cesiumRasterOverlay = UsdUtil::getCesiumRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumRasterOverlay)) {
return 2048;
}
int value;
cesiumRasterOverlay.GetMaximumTextureSizeAttr().Get(&value);
return static_cast<int>(value);
}
int OmniRasterOverlay::getMaximumSimultaneousTileLoads() const {
const auto cesiumRasterOverlay = UsdUtil::getCesiumRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumRasterOverlay)) {
return 20;
}
int value;
cesiumRasterOverlay.GetMaximumSimultaneousTileLoadsAttr().Get(&value);
return static_cast<int>(value);
}
int OmniRasterOverlay::getSubTileCacheBytes() const {
const auto cesiumRasterOverlay = UsdUtil::getCesiumRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumRasterOverlay)) {
return 16777216;
}
int value;
cesiumRasterOverlay.GetSubTileCacheBytesAttr().Get(&value);
return static_cast<int>(value);
}
FabricOverlayRenderMethod OmniRasterOverlay::getOverlayRenderMethod() const {
const auto cesiumRasterOverlay = UsdUtil::getCesiumRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumRasterOverlay)) {
return FabricOverlayRenderMethod::OVERLAY;
}
pxr::TfToken overlayRenderMethod;
cesiumRasterOverlay.GetOverlayRenderMethodAttr().Get(&overlayRenderMethod);
if (overlayRenderMethod == pxr::CesiumTokens->overlay) {
return FabricOverlayRenderMethod::OVERLAY;
} else if (overlayRenderMethod == pxr::CesiumTokens->clip) {
return FabricOverlayRenderMethod::CLIPPING;
}
_pContext->getLogger()->warn("Invalid overlay render method encountered {}.", overlayRenderMethod.GetText());
return FabricOverlayRenderMethod::OVERLAY;
}
CesiumRasterOverlays::RasterOverlayOptions OmniRasterOverlay::createRasterOverlayOptions() const {
CesiumRasterOverlays::RasterOverlayOptions options;
options.ktx2TranscodeTargets = GltfUtil::getKtx2TranscodeTargets();
setRasterOverlayOptionsFromUsd(options);
return options;
}
void OmniRasterOverlay::updateRasterOverlayOptions() const {
const auto pRasterOverlay = getRasterOverlay();
if (pRasterOverlay) {
setRasterOverlayOptionsFromUsd(pRasterOverlay->getOptions());
}
}
void OmniRasterOverlay::setRasterOverlayOptionsFromUsd(CesiumRasterOverlays::RasterOverlayOptions& options) const {
options.showCreditsOnScreen = getShowCreditsOnScreen();
options.maximumScreenSpaceError = getMaximumScreenSpaceError();
options.maximumTextureSize = getMaximumTextureSize();
options.maximumSimultaneousTileLoads = getMaximumSimultaneousTileLoads();
options.subTileCacheBytes = getSubTileCacheBytes();
}
} // namespace cesium::omniverse
| 4,681 | C++ | 32.927536 | 115 | 0.754112 |
CesiumGS/cesium-omniverse/src/core/src/OmniIonServer.cpp | #include "cesium/omniverse/OmniIonServer.h"
#include "cesium/omniverse/CesiumIonSession.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumUsdSchemas/ionServer.h>
namespace cesium::omniverse {
OmniIonServer::OmniIonServer(Context* pContext, const pxr::SdfPath& path)
: _pContext(pContext)
, _path(path)
, _session(std::make_shared<CesiumIonSession>(
pContext->getAsyncSystem(),
pContext->getAssetAccessor(),
getIonServerUrl(),
getIonServerApiUrl(),
getIonServerApplicationId())) {
_session->resume();
}
const pxr::SdfPath& OmniIonServer::getPath() const {
return _path;
}
std::shared_ptr<CesiumIonSession> OmniIonServer::getSession() const {
return _session;
}
std::string OmniIonServer::getIonServerUrl() const {
const auto cesiumIonServer = UsdUtil::getCesiumIonServer(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumIonServer)) {
return "";
}
std::string ionServerUrl;
cesiumIonServer.GetIonServerUrlAttr().Get(&ionServerUrl);
return ionServerUrl;
}
std::string OmniIonServer::getIonServerApiUrl() const {
const auto cesiumIonServer = UsdUtil::getCesiumIonServer(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumIonServer)) {
return "";
}
std::string ionServerApiUrl;
cesiumIonServer.GetIonServerApiUrlAttr().Get(&ionServerApiUrl);
return ionServerApiUrl;
}
int64_t OmniIonServer::getIonServerApplicationId() const {
const auto cesiumIonServer = UsdUtil::getCesiumIonServer(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumIonServer)) {
return 0;
}
int64_t ionServerApplicationId;
cesiumIonServer.GetIonServerApplicationIdAttr().Get(&ionServerApplicationId);
return ionServerApplicationId;
}
CesiumIonClient::Token OmniIonServer::getToken() const {
const auto cesiumIonServer = UsdUtil::getCesiumIonServer(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumIonServer)) {
return {};
}
std::string projectDefaultIonAccessToken;
std::string projectDefaultIonAccessTokenId;
cesiumIonServer.GetProjectDefaultIonAccessTokenAttr().Get(&projectDefaultIonAccessToken);
cesiumIonServer.GetProjectDefaultIonAccessTokenIdAttr().Get(&projectDefaultIonAccessTokenId);
CesiumIonClient::Token t;
t.id = projectDefaultIonAccessTokenId;
t.token = projectDefaultIonAccessToken;
return t;
}
void OmniIonServer::setToken(const CesiumIonClient::Token& token) {
const auto cesiumIonServer = UsdUtil::getCesiumIonServer(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumIonServer)) {
return;
}
cesiumIonServer.GetProjectDefaultIonAccessTokenAttr().Set(token.token);
cesiumIonServer.GetProjectDefaultIonAccessTokenIdAttr().Set(token.id);
}
} // namespace cesium::omniverse
| 2,961 | C++ | 29.536082 | 97 | 0.729483 |
CesiumGS/cesium-omniverse/src/core/src/FabricMaterial.cpp | #include "cesium/omniverse/FabricMaterial.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/CppUtil.h"
#include "cesium/omniverse/DataType.h"
#include "cesium/omniverse/FabricAttributesBuilder.h"
#include "cesium/omniverse/FabricFeaturesInfo.h"
#include "cesium/omniverse/FabricMaterialDescriptor.h"
#include "cesium/omniverse/FabricMaterialInfo.h"
#include "cesium/omniverse/FabricPropertyDescriptor.h"
#include "cesium/omniverse/FabricRasterOverlaysInfo.h"
#include "cesium/omniverse/FabricResourceManager.h"
#include "cesium/omniverse/FabricTexture.h"
#include "cesium/omniverse/FabricTextureInfo.h"
#include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/MetadataUtil.h"
#include "cesium/omniverse/UsdTokens.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumGltf/MeshPrimitive.h>
#include <glm/gtc/random.hpp>
#include <omni/fabric/FabricUSD.h>
#include <omni/fabric/SimStageWithHistory.h>
#include <spdlog/fmt/fmt.h>
namespace cesium::omniverse {
namespace {
// Should match raster_overlays length in cesium.mdl
const uint64_t MAX_RASTER_OVERLAY_COUNT = 16;
const auto DEFAULT_DEBUG_COLOR = glm::dvec3(1.0, 1.0, 1.0);
const auto DEFAULT_ALPHA = 1.0f;
const auto DEFAULT_DISPLAY_COLOR = glm::dvec3(1.0, 1.0, 1.0);
const auto DEFAULT_DISPLAY_OPACITY = 1.0;
const auto DEFAULT_TEXCOORD_INDEX = uint64_t(0);
const auto DEFAULT_FEATURE_ID_PRIMVAR_NAME = std::string("_FEATURE_ID_0");
const auto DEFAULT_NULL_FEATURE_ID = -1;
const auto DEFAULT_OFFSET = 0;
const auto DEFAULT_SCALE = 1;
const auto DEFAULT_NO_DATA = 0;
const auto DEFAULT_VALUE = 0;
struct FeatureIdCounts {
uint64_t indexCount;
uint64_t attributeCount;
uint64_t textureCount;
uint64_t totalCount;
};
FeatureIdCounts getFeatureIdCounts(const FabricMaterialDescriptor& materialDescriptor) {
const auto& featureIdTypes = materialDescriptor.getFeatureIdTypes();
auto featureIdCount = featureIdTypes.size();
uint64_t indexCount = 0;
uint64_t attributeCount = 0;
uint64_t textureCount = 0;
for (uint64_t i = 0; i < featureIdCount; ++i) {
const auto featureIdType = featureIdTypes[i];
switch (featureIdType) {
case FabricFeatureIdType::INDEX:
++indexCount;
break;
case FabricFeatureIdType::ATTRIBUTE:
++attributeCount;
break;
case FabricFeatureIdType::TEXTURE:
++textureCount;
break;
}
}
return FeatureIdCounts{indexCount, attributeCount, textureCount, featureIdCount};
}
struct RasterOverlayIndices {
std::vector<uint64_t> overlayRasterOverlayIndices;
std::vector<uint64_t> clippingRasterOverlayIndices;
};
RasterOverlayIndices
getRasterOverlayIndices(const Context& context, const FabricMaterialDescriptor& materialDescriptor) {
uint64_t overlayRasterOverlayCount = 0;
uint64_t clippingRasterOverlayCount = 0;
uint64_t totalRasterOverlayCount = 0;
std::vector<uint64_t> overlayRasterOverlayIndices;
std::vector<uint64_t> clippingRasterOverlayIndices;
for (const auto& method : materialDescriptor.getRasterOverlayRenderMethods()) {
switch (method) {
case FabricOverlayRenderMethod::OVERLAY:
if (overlayRasterOverlayCount < MAX_RASTER_OVERLAY_COUNT) {
overlayRasterOverlayIndices.push_back(totalRasterOverlayCount);
}
++overlayRasterOverlayCount;
break;
case FabricOverlayRenderMethod::CLIPPING:
if (clippingRasterOverlayCount < MAX_RASTER_OVERLAY_COUNT) {
clippingRasterOverlayIndices.push_back(totalRasterOverlayCount);
}
++clippingRasterOverlayCount;
break;
}
++totalRasterOverlayCount;
}
if (overlayRasterOverlayCount > MAX_RASTER_OVERLAY_COUNT) {
context.getLogger()->warn(
"Number of overlay raster overlays ({}) exceeds maximum raster overlay count ({}). Excess "
"raster overlays "
"will be ignored.",
overlayRasterOverlayCount,
MAX_RASTER_OVERLAY_COUNT);
}
if (clippingRasterOverlayCount > MAX_RASTER_OVERLAY_COUNT) {
context.getLogger()->warn(
"Number of clipping raster overlays ({}) exceeds maximum raster overlay count ({}). Excess "
"raster overlays "
"will be ignored.",
clippingRasterOverlayCount,
MAX_RASTER_OVERLAY_COUNT);
}
return RasterOverlayIndices{std::move(overlayRasterOverlayIndices), std::move(clippingRasterOverlayIndices)};
}
uint64_t getRasterOverlayCount(const FabricMaterialDescriptor& materialDescriptor) {
return materialDescriptor.getRasterOverlayRenderMethods().size();
}
bool isClippingEnabled(const FabricMaterialDescriptor& materialDescriptor) {
return CppUtil::contains(materialDescriptor.getRasterOverlayRenderMethods(), FabricOverlayRenderMethod::CLIPPING);
}
FabricAlphaMode
getInitialAlphaMode(const FabricMaterialDescriptor& materialDescriptor, const FabricMaterialInfo& materialInfo) {
if (materialInfo.alphaMode == FabricAlphaMode::BLEND) {
return materialInfo.alphaMode;
}
if (isClippingEnabled(materialDescriptor)) {
return FabricAlphaMode::MASK;
}
return materialInfo.alphaMode;
}
int getAlphaMode(FabricAlphaMode alphaMode, double displayOpacity) {
return static_cast<int>(displayOpacity < 1.0 ? FabricAlphaMode::BLEND : alphaMode);
}
glm::dvec4 getTileColor(const glm::dvec3& debugColor, const glm::dvec3& displayColor, double displayOpacity) {
return {debugColor * displayColor, displayOpacity};
}
void createConnection(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& outputPath,
const omni::fabric::Path& inputPath,
const omni::fabric::Token& inputName) {
fabricStage.createConnection(inputPath, inputName, omni::fabric::Connection{outputPath, FabricTokens::outputs_out});
}
void destroyConnection(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& inputPath,
const omni::fabric::Token& inputName) {
fabricStage.destroyConnection(inputPath, inputName);
}
template <DataType T>
constexpr DataTypeUtil::GetMdlInternalPropertyTransformedType<DataTypeUtil::getMdlInternalPropertyType<T>()>
getOffset(const FabricPropertyInfo<T>& info) {
constexpr auto mdlType = DataTypeUtil::getMdlInternalPropertyType<T>();
using TransformedType = DataTypeUtil::GetNativeType<DataTypeUtil::getTransformedType<T>()>;
using MdlTransformedType = DataTypeUtil::GetMdlInternalPropertyTransformedType<mdlType>;
return static_cast<MdlTransformedType>(info.offset.value_or(TransformedType{DEFAULT_OFFSET}));
}
template <DataType T>
constexpr DataTypeUtil::GetMdlInternalPropertyTransformedType<DataTypeUtil::getMdlInternalPropertyType<T>()>
getScale(const FabricPropertyInfo<T>& info) {
constexpr auto mdlType = DataTypeUtil::getMdlInternalPropertyType<T>();
using TransformedType = DataTypeUtil::GetNativeType<DataTypeUtil::getTransformedType<T>()>;
using MdlTransformedType = DataTypeUtil::GetMdlInternalPropertyTransformedType<mdlType>;
return static_cast<MdlTransformedType>(info.scale.value_or(TransformedType{DEFAULT_SCALE}));
}
template <DataType T>
constexpr DataTypeUtil::GetMdlInternalPropertyRawType<DataTypeUtil::getMdlInternalPropertyType<T>()>
getNoData(const FabricPropertyInfo<T>& info) {
constexpr auto mdlType = DataTypeUtil::getMdlInternalPropertyType<T>();
using RawType = DataTypeUtil::GetNativeType<T>;
using MdlRawType = DataTypeUtil::GetMdlInternalPropertyRawType<mdlType>;
return static_cast<MdlRawType>(info.noData.value_or(RawType{DEFAULT_NO_DATA}));
}
template <DataType T>
constexpr DataTypeUtil::GetMdlInternalPropertyTransformedType<DataTypeUtil::getMdlInternalPropertyType<T>()>
getDefaultValue(const FabricPropertyInfo<T>& info) {
constexpr auto mdlType = DataTypeUtil::getMdlInternalPropertyType<T>();
using TransformedType = DataTypeUtil::GetNativeType<DataTypeUtil::getTransformedType<T>()>;
using MdlTransformedType = DataTypeUtil::GetMdlInternalPropertyTransformedType<mdlType>;
return static_cast<MdlTransformedType>(info.defaultValue.value_or(TransformedType{DEFAULT_VALUE}));
}
template <DataType T>
constexpr DataTypeUtil::GetMdlInternalPropertyRawType<DataTypeUtil::getMdlInternalPropertyType<T>()> getMaximumValue() {
constexpr auto mdlType = DataTypeUtil::getMdlInternalPropertyType<T>();
using RawComponentType = DataTypeUtil::GetNativeType<DataTypeUtil::getComponentType<T>()>;
using MdlRawType = DataTypeUtil::GetMdlInternalPropertyRawType<mdlType>;
if constexpr (DataTypeUtil::isNormalized<T>()) {
return MdlRawType{std::numeric_limits<RawComponentType>::max()};
}
return MdlRawType{0};
}
void createAttributes(
const Context& context,
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
FabricAttributesBuilder& attributes,
const omni::fabric::Token& subidentifier) {
// clang-format off
attributes.addAttribute(FabricTypes::inputs_excludeFromWhiteMode, FabricTokens::inputs_excludeFromWhiteMode);
attributes.addAttribute(FabricTypes::outputs_out, FabricTokens::outputs_out);
attributes.addAttribute(FabricTypes::info_implementationSource, FabricTokens::info_implementationSource);
attributes.addAttribute(FabricTypes::info_mdl_sourceAsset, FabricTokens::info_mdl_sourceAsset);
attributes.addAttribute(FabricTypes::info_mdl_sourceAsset_subIdentifier, FabricTokens::info_mdl_sourceAsset_subIdentifier);
attributes.addAttribute(FabricTypes::_paramColorSpace, FabricTokens::_paramColorSpace);
attributes.addAttribute(FabricTypes::_sdrMetadata, FabricTokens::_sdrMetadata);
attributes.addAttribute(FabricTypes::Shader, FabricTokens::Shader);
attributes.addAttribute(FabricTypes::_cesium_tilesetId, FabricTokens::_cesium_tilesetId);
// clang-format on
attributes.createAttributes(path);
// clang-format off
const auto inputsExcludeFromWhiteModeFabric = fabricStage.getAttributeWr<bool>(path, FabricTokens::inputs_excludeFromWhiteMode);
const auto infoImplementationSourceFabric = fabricStage.getAttributeWr<omni::fabric::TokenC>(path, FabricTokens::info_implementationSource);
const auto infoMdlSourceAssetFabric = fabricStage.getAttributeWr<omni::fabric::AssetPath>(path, FabricTokens::info_mdl_sourceAsset);
const auto infoMdlSourceAssetSubIdentifierFabric = fabricStage.getAttributeWr<omni::fabric::TokenC>(path, FabricTokens::info_mdl_sourceAsset_subIdentifier);
// clang-format on
fabricStage.setArrayAttributeSize(path, FabricTokens::_paramColorSpace, 0);
fabricStage.setArrayAttributeSize(path, FabricTokens::_sdrMetadata, 0);
*inputsExcludeFromWhiteModeFabric = false;
*infoImplementationSourceFabric = FabricTokens::sourceAsset;
infoMdlSourceAssetFabric->assetPath = context.getCesiumMdlPathToken();
infoMdlSourceAssetFabric->resolvedPath = pxr::TfToken();
*infoMdlSourceAssetSubIdentifierFabric = subidentifier;
}
void setTextureValuesCommon(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex) {
auto offset = textureInfo.offset;
auto rotation = textureInfo.rotation;
auto scale = textureInfo.scale;
if (!textureInfo.flipVertical) {
// gltf/pbr.mdl does texture transform math in glTF coordinates (top-left origin), so we needed to convert
// the translation and scale parameters to work in that space. This doesn't handle rotation yet because we
// haven't needed it for raster overlays.
offset = {offset.x, 1.0 - offset.y - scale.y};
scale = {scale.x, scale.y};
}
const auto textureFabric = fabricStage.getAttributeWr<omni::fabric::AssetPath>(path, FabricTokens::inputs_texture);
const auto texCoordIndexFabric = fabricStage.getAttributeWr<int>(path, FabricTokens::inputs_tex_coord_index);
const auto wrapSFabric = fabricStage.getAttributeWr<int>(path, FabricTokens::inputs_wrap_s);
const auto wrapTFabric = fabricStage.getAttributeWr<int>(path, FabricTokens::inputs_wrap_t);
const auto offsetFabric = fabricStage.getAttributeWr<pxr::GfVec2f>(path, FabricTokens::inputs_tex_coord_offset);
const auto rotationFabric = fabricStage.getAttributeWr<float>(path, FabricTokens::inputs_tex_coord_rotation);
const auto scaleFabric = fabricStage.getAttributeWr<pxr::GfVec2f>(path, FabricTokens::inputs_tex_coord_scale);
textureFabric->assetPath = textureAssetPathToken;
textureFabric->resolvedPath = pxr::TfToken();
*texCoordIndexFabric = static_cast<int>(texcoordIndex);
*wrapSFabric = textureInfo.wrapS;
*wrapTFabric = textureInfo.wrapT;
*offsetFabric = UsdUtil::glmToUsdVector(glm::fvec2(offset));
*rotationFabric = static_cast<float>(rotation);
*scaleFabric = UsdUtil::glmToUsdVector(glm::fvec2(scale));
}
void setTextureValuesCommonChannels(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex) {
setTextureValuesCommon(fabricStage, path, textureAssetPathToken, textureInfo, texcoordIndex);
auto channelCount = glm::min(textureInfo.channels.size(), uint64_t(4));
auto channels = glm::u8vec4(0);
for (uint64_t i = 0; i < channelCount; ++i) {
channels[i] = textureInfo.channels[i];
}
channelCount = glm::max(channelCount, uint64_t(1));
const auto channelsFabric = fabricStage.getAttributeWr<glm::i32vec4>(path, FabricTokens::inputs_channels);
*channelsFabric = static_cast<glm::i32vec4>(channels);
if (fabricStage.attributeExists(path, FabricTokens::inputs_channel_count)) {
const auto channelCountFabric = fabricStage.getAttributeWr<int>(path, FabricTokens::inputs_channel_count);
*channelCountFabric = static_cast<int>(channelCount);
}
}
std::string getStringFabric(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
omni::fabric::TokenC attributeName) {
const auto valueFabric = fabricStage.getArrayAttributeRd<uint8_t>(path, attributeName);
return {reinterpret_cast<const char*>(valueFabric.data()), valueFabric.size()};
}
void setStringFabric(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
omni::fabric::TokenC attributeName,
const std::string& value) {
fabricStage.setArrayAttributeSize(path, attributeName, value.size());
const auto valueFabric = fabricStage.getArrayAttributeWr<uint8_t>(path, attributeName);
memcpy(valueFabric.data(), value.data(), value.size());
}
template <MdlInternalPropertyType T>
void setPropertyValues(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& offset,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& scale,
const DataTypeUtil::GetMdlInternalPropertyRawType<T>& maximumValue,
bool hasNoData,
const DataTypeUtil::GetMdlInternalPropertyRawType<T>& noData,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& defaultValue) {
using MdlRawType = DataTypeUtil::GetMdlInternalPropertyRawType<T>;
using MdlTransformedType = DataTypeUtil::GetMdlInternalPropertyTransformedType<T>;
const auto hasNoDataFabric = fabricStage.getAttributeWr<bool>(path, FabricTokens::inputs_has_no_data);
const auto noDataFabric = fabricStage.getAttributeWr<MdlRawType>(path, FabricTokens::inputs_no_data);
const auto defaultValueFabric =
fabricStage.getAttributeWr<MdlTransformedType>(path, FabricTokens::inputs_default_value);
*hasNoDataFabric = hasNoData;
*noDataFabric = static_cast<MdlRawType>(noData);
*defaultValueFabric = static_cast<MdlTransformedType>(defaultValue);
if (fabricStage.attributeExists(path, FabricTokens::inputs_offset)) {
const auto offsetFabric = fabricStage.getAttributeWr<MdlTransformedType>(path, FabricTokens::inputs_offset);
*offsetFabric = static_cast<MdlTransformedType>(offset);
}
if (fabricStage.attributeExists(path, FabricTokens::inputs_scale)) {
const auto scaleFabric = fabricStage.getAttributeWr<MdlTransformedType>(path, FabricTokens::inputs_scale);
*scaleFabric = static_cast<MdlTransformedType>(scale);
}
if (fabricStage.attributeExists(path, FabricTokens::inputs_maximum_value)) {
const auto maximumValueFabric =
fabricStage.getAttributeWr<MdlRawType>(path, FabricTokens::inputs_maximum_value);
*maximumValueFabric = static_cast<MdlRawType>(maximumValue);
}
}
template <MdlInternalPropertyType T>
void setPropertyAttributePropertyValues(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const std::string& primvarName,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& offset,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& scale,
const DataTypeUtil::GetMdlInternalPropertyRawType<T>& maximumValue,
bool hasNoData,
const DataTypeUtil::GetMdlInternalPropertyRawType<T>& noData,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& defaultValue) {
setStringFabric(fabricStage, path, FabricTokens::inputs_primvar_name, primvarName);
setPropertyValues<T>(fabricStage, path, offset, scale, maximumValue, hasNoData, noData, defaultValue);
}
template <MdlInternalPropertyType T>
void setPropertyTexturePropertyValues(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& offset,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& scale,
const DataTypeUtil::GetMdlInternalPropertyRawType<T>& maximumValue,
bool hasNoData,
const DataTypeUtil::GetMdlInternalPropertyRawType<T>& noData,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& defaultValue) {
setTextureValuesCommonChannels(fabricStage, path, textureAssetPathToken, textureInfo, texcoordIndex);
setPropertyValues<T>(fabricStage, path, offset, scale, maximumValue, hasNoData, noData, defaultValue);
}
template <MdlInternalPropertyType T>
void setPropertyTablePropertyValues(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const pxr::TfToken& propertyTableTextureAssetPathToken,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& offset,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& scale,
const DataTypeUtil::GetMdlInternalPropertyRawType<T>& maximumValue,
bool hasNoData,
const DataTypeUtil::GetMdlInternalPropertyRawType<T>& noData,
const DataTypeUtil::GetMdlInternalPropertyTransformedType<T>& defaultValue) {
const auto textureFabric =
fabricStage.getAttributeWr<omni::fabric::AssetPath>(path, FabricTokens::inputs_property_table_texture);
textureFabric->assetPath = propertyTableTextureAssetPathToken;
textureFabric->resolvedPath = pxr::TfToken();
setPropertyValues<T>(fabricStage, path, offset, scale, maximumValue, hasNoData, noData, defaultValue);
}
template <MdlInternalPropertyType T>
void clearPropertyAttributeProperty(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path) {
using MdlRawType = DataTypeUtil::GetMdlInternalPropertyRawType<T>;
using MdlTransformedType = DataTypeUtil::GetMdlInternalPropertyTransformedType<T>;
setPropertyAttributePropertyValues<T>(
fabricStage,
path,
"",
MdlTransformedType{0},
MdlTransformedType{0},
MdlRawType{0},
false,
MdlRawType{0},
MdlTransformedType{0});
}
template <MdlInternalPropertyType T>
void clearPropertyTextureProperty(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const pxr::TfToken& defaultTransparentTextureAssetPathToken) {
using MdlRawType = DataTypeUtil::GetMdlInternalPropertyRawType<T>;
using MdlTransformedType = DataTypeUtil::GetMdlInternalPropertyTransformedType<T>;
setPropertyTexturePropertyValues<T>(
fabricStage,
path,
defaultTransparentTextureAssetPathToken,
GltfUtil::getDefaultTextureInfo(),
DEFAULT_TEXCOORD_INDEX,
MdlTransformedType{0},
MdlTransformedType{0},
MdlRawType{0},
false,
MdlRawType{0},
MdlTransformedType{0});
}
template <MdlInternalPropertyType T>
void clearPropertyTableProperty(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const pxr::TfToken& defaultTransparentTextureAssetPathToken) {
using MdlRawType = DataTypeUtil::GetMdlInternalPropertyRawType<T>;
using MdlTransformedType = DataTypeUtil::GetMdlInternalPropertyTransformedType<T>;
setPropertyTablePropertyValues<T>(
fabricStage,
path,
defaultTransparentTextureAssetPathToken,
MdlTransformedType{0},
MdlTransformedType{0},
MdlRawType{0},
false,
MdlRawType{0},
MdlTransformedType{0});
}
} // namespace
FabricMaterial::FabricMaterial(
Context* pContext,
const omni::fabric::Path& path,
const FabricMaterialDescriptor& materialDescriptor,
const pxr::TfToken& defaultWhiteTextureAssetPathToken,
const pxr::TfToken& defaultTransparentTextureAssetPathToken,
bool debugRandomColors,
int64_t poolId)
: _pContext(pContext)
, _materialPath(path)
, _materialDescriptor(materialDescriptor)
, _defaultWhiteTextureAssetPathToken(defaultWhiteTextureAssetPathToken)
, _defaultTransparentTextureAssetPathToken(defaultTransparentTextureAssetPathToken)
, _debugRandomColors(debugRandomColors)
, _poolId(poolId)
, _stageId(pContext->getUsdStageId())
, _usesDefaultMaterial(!materialDescriptor.hasTilesetMaterial()) {
if (stageDestroyed()) {
return;
}
initializeNodes();
if (_usesDefaultMaterial) {
initializeDefaultMaterial();
} else {
initializeExistingMaterial(FabricUtil::toFabricPath(materialDescriptor.getTilesetMaterialPath()));
}
reset();
}
FabricMaterial::~FabricMaterial() {
// The code below is temporarily commented out to avoid a crash.
// It will cause a leak, but since this only happens when materials
// pools are destroyed (which doesn't happen during normal usage) it
// shouldn't be a huge concern.
//
// See https://github.com/CesiumGS/cesium-omniverse/issues/444 for details.
// if (stageDestroyed()) {
// return;
// }
// for (const auto& path : _allPaths) {
// FabricUtil::destroyPrim(_pContext->getFabricStage(), path);
// }
}
void FabricMaterial::setActive(bool active) {
if (stageDestroyed()) {
return;
}
if (!active) {
reset();
}
}
const omni::fabric::Path& FabricMaterial::getPath() const {
return _materialPath;
}
const FabricMaterialDescriptor& FabricMaterial::getMaterialDescriptor() const {
return _materialDescriptor;
}
int64_t FabricMaterial::getPoolId() const {
return _poolId;
}
void FabricMaterial::initializeNodes() {
auto& fabricStage = _pContext->getFabricStage();
// Create base color texture
const auto hasBaseColorTexture = _materialDescriptor.hasBaseColorTexture();
if (hasBaseColorTexture) {
const auto baseColorTexturePath = FabricUtil::joinPaths(_materialPath, FabricTokens::base_color_texture);
createTexture(baseColorTexturePath);
_baseColorTexturePath = baseColorTexturePath;
_allPaths.push_back(baseColorTexturePath);
}
// Create raster overlays
const auto rasterOverlayCount = getRasterOverlayCount(_materialDescriptor);
_rasterOverlayPaths.reserve(rasterOverlayCount);
for (uint64_t i = 0; i < rasterOverlayCount; ++i) {
const auto rasterOverlayPath = FabricUtil::joinPaths(_materialPath, FabricTokens::raster_overlay_n(i));
createRasterOverlay(rasterOverlayPath);
_rasterOverlayPaths.push_back(rasterOverlayPath);
_allPaths.push_back(rasterOverlayPath);
}
// Create feature ids
const auto& featureIdTypes = _materialDescriptor.getFeatureIdTypes();
const auto featureIdCounts = getFeatureIdCounts(_materialDescriptor);
_featureIdPaths.reserve(featureIdCounts.totalCount);
_featureIdIndexPaths.reserve(featureIdCounts.indexCount);
_featureIdAttributePaths.reserve(featureIdCounts.attributeCount);
_featureIdTexturePaths.reserve(featureIdCounts.textureCount);
for (uint64_t i = 0; i < featureIdCounts.totalCount; ++i) {
const auto featureIdType = featureIdTypes[i];
const auto featureIdPath = FabricUtil::joinPaths(_materialPath, FabricTokens::feature_id_n(i));
switch (featureIdType) {
case FabricFeatureIdType::INDEX:
createFeatureIdIndex(featureIdPath);
_featureIdIndexPaths.push_back(featureIdPath);
break;
case FabricFeatureIdType::ATTRIBUTE:
createFeatureIdAttribute(featureIdPath);
_featureIdAttributePaths.push_back(featureIdPath);
break;
case FabricFeatureIdType::TEXTURE:
createFeatureIdTexture(featureIdPath);
_featureIdTexturePaths.push_back(featureIdPath);
break;
}
_featureIdPaths.push_back(featureIdPath);
_allPaths.push_back(featureIdPath);
}
// Create properties
const auto& properties = _materialDescriptor.getStyleableProperties();
for (uint64_t i = 0; i < properties.size(); ++i) {
const auto& property = properties[i];
const auto storageType = property.storageType;
const auto type = property.type;
const auto& propertyPath = FabricUtil::joinPaths(_materialPath, FabricTokens::property_n(i));
switch (storageType) {
case FabricPropertyStorageType::ATTRIBUTE:
createPropertyAttributeProperty(propertyPath, type);
_propertyAttributePropertyPaths[type].push_back(propertyPath);
break;
case FabricPropertyStorageType::TEXTURE:
createPropertyTextureProperty(propertyPath, type);
_propertyTexturePropertyPaths[type].push_back(propertyPath);
break;
case FabricPropertyStorageType::TABLE:
createPropertyTableProperty(propertyPath, type);
_propertyTablePropertyPaths[type].push_back(propertyPath);
// Create connection from the feature id node to the property table property node
const auto featureIdSetIndex = property.featureIdSetIndex;
const auto& featureIdPath = _featureIdPaths[featureIdSetIndex];
createConnection(fabricStage, featureIdPath, propertyPath, FabricTokens::inputs_feature_id);
break;
}
_propertyPaths.push_back(propertyPath);
_allPaths.push_back(propertyPath);
}
}
void FabricMaterial::initializeDefaultMaterial() {
auto& fabricStage = _pContext->getFabricStage();
const auto rasterOverlayIndices = getRasterOverlayIndices(*_pContext, _materialDescriptor);
const auto hasBaseColorTexture = _materialDescriptor.hasBaseColorTexture();
// Create material
const auto& materialPath = _materialPath;
createMaterial(materialPath);
_allPaths.push_back(materialPath);
// Create shader
const auto shaderPath = FabricUtil::joinPaths(materialPath, FabricTokens::cesium_internal_material);
createShader(shaderPath);
_shaderPath = shaderPath;
_allPaths.push_back(shaderPath);
const auto& overlayRasterOverlayIndices = rasterOverlayIndices.overlayRasterOverlayIndices;
const auto& clippingRasterOverlayIndices = rasterOverlayIndices.clippingRasterOverlayIndices;
const auto overlayRasterOverlayCount = overlayRasterOverlayIndices.size();
const auto clippingRasterOverlayCount = clippingRasterOverlayIndices.size();
// Create overlay raster overlay resolver if there are multiple overlay raster overlays
if (overlayRasterOverlayCount > 1) {
const auto rasterOverlayResolverPath =
FabricUtil::joinPaths(materialPath, FabricTokens::raster_overlay_resolver);
createRasterOverlayResolver(rasterOverlayResolverPath, overlayRasterOverlayCount);
_overlayRasterOverlayResolverPath = rasterOverlayResolverPath;
_allPaths.push_back(rasterOverlayResolverPath);
}
// Create clipping raster overlay resolver if there are multiple clipping raster overlays
if (clippingRasterOverlayCount > 1) {
const auto clippingRasterOverlayResolverPath =
FabricUtil::joinPaths(materialPath, FabricTokens::clipping_raster_overlay_resolver);
createClippingRasterOverlayResolver(clippingRasterOverlayResolverPath, clippingRasterOverlayCount);
_clippingRasterOverlayResolverPath = clippingRasterOverlayResolverPath;
_allPaths.push_back(_clippingRasterOverlayResolverPath);
}
// Create connection from shader to material
createConnection(fabricStage, shaderPath, materialPath, FabricTokens::outputs_mdl_surface);
createConnection(fabricStage, shaderPath, materialPath, FabricTokens::outputs_mdl_displacement);
createConnection(fabricStage, shaderPath, materialPath, FabricTokens::outputs_mdl_volume);
// Create connection from base color texture to shader
if (hasBaseColorTexture) {
createConnection(fabricStage, _baseColorTexturePath, shaderPath, FabricTokens::inputs_base_color_texture);
}
if (overlayRasterOverlayCount == 1) {
// Create connection from raster overlay to shader
const auto& rasterOverlayPath = _rasterOverlayPaths[overlayRasterOverlayIndices.front()];
createConnection(fabricStage, rasterOverlayPath, shaderPath, FabricTokens::inputs_raster_overlay);
} else if (overlayRasterOverlayCount > 1) {
// Create connection from raster overlay resolver to shader
createConnection(
fabricStage, _overlayRasterOverlayResolverPath, shaderPath, FabricTokens::inputs_raster_overlay);
// Create connections from raster overlays to raster overlay resolver
for (uint64_t i = 0; i < overlayRasterOverlayCount; ++i) {
const auto& rasterOverlayPath = _rasterOverlayPaths[overlayRasterOverlayIndices[i]];
createConnection(
fabricStage,
rasterOverlayPath,
_overlayRasterOverlayResolverPath,
FabricTokens::inputs_raster_overlay_n(i));
}
}
if (clippingRasterOverlayCount == 1) {
// Create connection from raster overlay to shader
const auto& rasterOverlayPath = _rasterOverlayPaths[clippingRasterOverlayIndices.front()];
createConnection(fabricStage, rasterOverlayPath, shaderPath, FabricTokens::inputs_alpha_clip);
} else if (clippingRasterOverlayCount > 1) {
// Create connection from raster overlay resolver to shader
createConnection(fabricStage, _clippingRasterOverlayResolverPath, shaderPath, FabricTokens::inputs_alpha_clip);
// Create connections from raster overlays to raster overlay resolver
for (uint64_t i = 0; i < clippingRasterOverlayCount; ++i) {
const auto& rasterOverlayPath = _rasterOverlayPaths[clippingRasterOverlayIndices[i]];
createConnection(
fabricStage,
rasterOverlayPath,
_clippingRasterOverlayResolverPath,
FabricTokens::inputs_raster_overlay_n(i));
}
}
}
void FabricMaterial::initializeExistingMaterial(const omni::fabric::Path& path) {
auto& fabricStage = _pContext->getFabricStage();
const auto copiedPaths = FabricUtil::copyMaterial(fabricStage, path, _materialPath);
for (const auto& copiedPath : copiedPaths) {
fabricStage.createAttribute(copiedPath, FabricTokens::_cesium_tilesetId, FabricTypes::_cesium_tilesetId);
_allPaths.push_back(copiedPath);
const auto mdlIdentifier = FabricUtil::getMdlIdentifier(fabricStage, copiedPath);
if (mdlIdentifier == FabricTokens::cesium_base_color_texture_float4) {
_copiedBaseColorTexturePaths.push_back(copiedPath);
} else if (mdlIdentifier == FabricTokens::cesium_raster_overlay_float4) {
_copiedRasterOverlayPaths.push_back(copiedPath);
} else if (mdlIdentifier == FabricTokens::cesium_feature_id_int) {
_copiedFeatureIdPaths.push_back(copiedPath);
} else if (FabricUtil::isCesiumPropertyNode(mdlIdentifier)) {
_copiedPropertyPaths.push_back(copiedPath);
}
}
createConnectionsToCopiedPaths();
createConnectionsToProperties();
}
void FabricMaterial::createMaterial(const omni::fabric::Path& path) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::Material, FabricTokens::Material);
attributes.addAttribute(FabricTypes::_cesium_tilesetId, FabricTokens::_cesium_tilesetId);
attributes.createAttributes(path);
}
void FabricMaterial::createShader(const omni::fabric::Path& path) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_tile_color, FabricTokens::inputs_tile_color);
attributes.addAttribute(FabricTypes::inputs_alpha_cutoff, FabricTokens::inputs_alpha_cutoff);
attributes.addAttribute(FabricTypes::inputs_alpha_mode, FabricTokens::inputs_alpha_mode);
attributes.addAttribute(FabricTypes::inputs_base_alpha, FabricTokens::inputs_base_alpha);
attributes.addAttribute(FabricTypes::inputs_base_color_factor, FabricTokens::inputs_base_color_factor);
attributes.addAttribute(FabricTypes::inputs_emissive_factor, FabricTokens::inputs_emissive_factor);
attributes.addAttribute(FabricTypes::inputs_metallic_factor, FabricTokens::inputs_metallic_factor);
attributes.addAttribute(FabricTypes::inputs_roughness_factor, FabricTokens::inputs_roughness_factor);
createAttributes(*_pContext, fabricStage, path, attributes, FabricTokens::cesium_internal_material);
}
void FabricMaterial::createTextureCommon(
const omni::fabric::Path& path,
const omni::fabric::Token& subIdentifier,
const std::vector<std::pair<omni::fabric::Type, omni::fabric::Token>>& additionalAttributes) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_tex_coord_offset, FabricTokens::inputs_tex_coord_offset);
attributes.addAttribute(FabricTypes::inputs_tex_coord_rotation, FabricTokens::inputs_tex_coord_rotation);
attributes.addAttribute(FabricTypes::inputs_tex_coord_scale, FabricTokens::inputs_tex_coord_scale);
attributes.addAttribute(FabricTypes::inputs_tex_coord_index, FabricTokens::inputs_tex_coord_index);
attributes.addAttribute(FabricTypes::inputs_texture, FabricTokens::inputs_texture);
attributes.addAttribute(FabricTypes::inputs_wrap_s, FabricTokens::inputs_wrap_s);
attributes.addAttribute(FabricTypes::inputs_wrap_t, FabricTokens::inputs_wrap_t);
for (const auto& additionalAttribute : additionalAttributes) {
attributes.addAttribute(additionalAttribute.first, additionalAttribute.second);
}
createAttributes(*_pContext, fabricStage, path, attributes, subIdentifier);
// _paramColorSpace is an array of pairs: [texture_parameter_token, color_space_enum], [texture_parameter_token, color_space_enum], ...
fabricStage.setArrayAttributeSize(path, FabricTokens::_paramColorSpace, 2);
const auto paramColorSpaceFabric =
fabricStage.getArrayAttributeWr<omni::fabric::TokenC>(path, FabricTokens::_paramColorSpace);
paramColorSpaceFabric[0] = FabricTokens::inputs_texture;
paramColorSpaceFabric[1] = FabricTokens::_auto;
}
void FabricMaterial::createTexture(const omni::fabric::Path& path) {
return createTextureCommon(path, FabricTokens::cesium_internal_texture_lookup);
}
void FabricMaterial::createRasterOverlay(const omni::fabric::Path& path) {
static const auto additionalAttributes = std::vector<std::pair<omni::fabric::Type, omni::fabric::Token>>{{
std::make_pair(FabricTypes::inputs_alpha, FabricTokens::inputs_alpha),
}};
return createTextureCommon(path, FabricTokens::cesium_internal_raster_overlay_lookup, additionalAttributes);
}
void FabricMaterial::createRasterOverlayResolverCommon(
const omni::fabric::Path& path,
uint64_t rasterOverlayCount,
const omni::fabric::Token& subidentifier) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_raster_overlay_count, FabricTokens::inputs_raster_overlay_count);
createAttributes(*_pContext, fabricStage, path, attributes, subidentifier);
const auto rasterOverlayCountFabric =
fabricStage.getAttributeWr<int>(path, FabricTokens::inputs_raster_overlay_count);
*rasterOverlayCountFabric = static_cast<int>(rasterOverlayCount);
}
void FabricMaterial::createRasterOverlayResolver(const omni::fabric::Path& path, uint64_t rasterOverlayCount) {
createRasterOverlayResolverCommon(path, rasterOverlayCount, FabricTokens::cesium_internal_raster_overlay_resolver);
}
void FabricMaterial::createClippingRasterOverlayResolver(
const omni::fabric::Path& path,
uint64_t clippingRasterOverlayCount) {
createRasterOverlayResolverCommon(
path, clippingRasterOverlayCount, FabricTokens::cesium_internal_clipping_raster_overlay_resolver);
}
void FabricMaterial::createFeatureIdIndex(const omni::fabric::Path& path) {
createFeatureIdAttribute(path);
}
void FabricMaterial::createFeatureIdAttribute(const omni::fabric::Path& path) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_primvar_name, FabricTokens::inputs_primvar_name);
attributes.addAttribute(FabricTypes::inputs_null_feature_id, FabricTokens::inputs_null_feature_id);
createAttributes(
*_pContext, fabricStage, path, attributes, FabricTokens::cesium_internal_feature_id_attribute_lookup);
}
void FabricMaterial::createFeatureIdTexture(const omni::fabric::Path& path) {
static const auto additionalAttributes = std::vector<std::pair<omni::fabric::Type, omni::fabric::Token>>{{
std::make_pair(FabricTypes::inputs_channels, FabricTokens::inputs_channels),
std::make_pair(FabricTypes::inputs_channel_count, FabricTokens::inputs_channel_count),
std::make_pair(FabricTypes::inputs_null_feature_id, FabricTokens::inputs_null_feature_id),
}};
return createTextureCommon(path, FabricTokens::cesium_internal_feature_id_texture_lookup, additionalAttributes);
}
void FabricMaterial::createPropertyAttributePropertyInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_primvar_name, FabricTokens::inputs_primvar_name);
attributes.addAttribute(FabricTypes::inputs_has_no_data, FabricTokens::inputs_has_no_data);
attributes.addAttribute(noDataType, FabricTokens::inputs_no_data);
attributes.addAttribute(defaultValueType, FabricTokens::inputs_default_value);
createAttributes(*_pContext, fabricStage, path, attributes, subidentifier);
}
void FabricMaterial::createPropertyAttributePropertyNormalizedInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType,
const omni::fabric::Type& maximumValueType) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_primvar_name, FabricTokens::inputs_primvar_name);
attributes.addAttribute(FabricTypes::inputs_has_no_data, FabricTokens::inputs_has_no_data);
attributes.addAttribute(noDataType, FabricTokens::inputs_no_data);
attributes.addAttribute(defaultValueType, FabricTokens::inputs_default_value);
attributes.addAttribute(offsetType, FabricTokens::inputs_offset);
attributes.addAttribute(scaleType, FabricTokens::inputs_scale);
attributes.addAttribute(maximumValueType, FabricTokens::inputs_maximum_value);
createAttributes(*_pContext, fabricStage, path, attributes, subidentifier);
}
void FabricMaterial::createPropertyAttributePropertyFloat(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_primvar_name, FabricTokens::inputs_primvar_name);
attributes.addAttribute(FabricTypes::inputs_has_no_data, FabricTokens::inputs_has_no_data);
attributes.addAttribute(noDataType, FabricTokens::inputs_no_data);
attributes.addAttribute(defaultValueType, FabricTokens::inputs_default_value);
attributes.addAttribute(offsetType, FabricTokens::inputs_offset);
attributes.addAttribute(scaleType, FabricTokens::inputs_scale);
createAttributes(*_pContext, fabricStage, path, attributes, subidentifier);
}
void FabricMaterial::createPropertyAttributeProperty(const omni::fabric::Path& path, MdlInternalPropertyType type) {
switch (type) {
case MdlInternalPropertyType::INT32:
createPropertyAttributePropertyInt(
path,
FabricTokens::cesium_internal_property_attribute_int_lookup,
FabricTypes::inputs_no_data_int,
FabricTypes::inputs_default_value_int);
break;
case MdlInternalPropertyType::VEC2_INT32:
createPropertyAttributePropertyInt(
path,
FabricTokens::cesium_internal_property_attribute_int2_lookup,
FabricTypes::inputs_no_data_int2,
FabricTypes::inputs_default_value_int2);
break;
case MdlInternalPropertyType::VEC3_INT32:
createPropertyAttributePropertyInt(
path,
FabricTokens::cesium_internal_property_attribute_int3_lookup,
FabricTypes::inputs_no_data_int3,
FabricTypes::inputs_default_value_int3);
break;
case MdlInternalPropertyType::VEC4_INT32:
createPropertyAttributePropertyInt(
path,
FabricTokens::cesium_internal_property_attribute_int4_lookup,
FabricTypes::inputs_no_data_int4,
FabricTypes::inputs_default_value_int4);
break;
case MdlInternalPropertyType::INT32_NORM:
createPropertyAttributePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_attribute_normalized_int_lookup,
FabricTypes::inputs_no_data_int,
FabricTypes::inputs_default_value_float,
FabricTypes::inputs_offset_float,
FabricTypes::inputs_scale_float,
FabricTypes::inputs_maximum_value_int);
break;
case MdlInternalPropertyType::VEC2_INT32_NORM:
createPropertyAttributePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_attribute_normalized_int2_lookup,
FabricTypes::inputs_no_data_int2,
FabricTypes::inputs_default_value_float2,
FabricTypes::inputs_offset_float2,
FabricTypes::inputs_scale_float2,
FabricTypes::inputs_maximum_value_int2);
break;
case MdlInternalPropertyType::VEC3_INT32_NORM:
createPropertyAttributePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_attribute_normalized_int3_lookup,
FabricTypes::inputs_no_data_int3,
FabricTypes::inputs_default_value_float3,
FabricTypes::inputs_offset_float3,
FabricTypes::inputs_scale_float3,
FabricTypes::inputs_maximum_value_int3);
break;
case MdlInternalPropertyType::VEC4_INT32_NORM:
createPropertyAttributePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_attribute_normalized_int4_lookup,
FabricTypes::inputs_no_data_int4,
FabricTypes::inputs_default_value_float4,
FabricTypes::inputs_offset_float4,
FabricTypes::inputs_scale_float4,
FabricTypes::inputs_maximum_value_int4);
break;
case MdlInternalPropertyType::FLOAT32:
createPropertyAttributePropertyFloat(
path,
FabricTokens::cesium_internal_property_attribute_float_lookup,
FabricTypes::inputs_no_data_float,
FabricTypes::inputs_default_value_float,
FabricTypes::inputs_offset_float,
FabricTypes::inputs_scale_float);
break;
case MdlInternalPropertyType::VEC2_FLOAT32:
createPropertyAttributePropertyFloat(
path,
FabricTokens::cesium_internal_property_attribute_float2_lookup,
FabricTypes::inputs_no_data_float2,
FabricTypes::inputs_default_value_float2,
FabricTypes::inputs_offset_float2,
FabricTypes::inputs_scale_float2);
break;
case MdlInternalPropertyType::VEC3_FLOAT32:
createPropertyAttributePropertyFloat(
path,
FabricTokens::cesium_internal_property_attribute_float3_lookup,
FabricTypes::inputs_no_data_float3,
FabricTypes::inputs_default_value_float3,
FabricTypes::inputs_offset_float3,
FabricTypes::inputs_scale_float3);
break;
case MdlInternalPropertyType::VEC4_FLOAT32:
createPropertyAttributePropertyFloat(
path,
FabricTokens::cesium_internal_property_attribute_float4_lookup,
FabricTypes::inputs_no_data_float4,
FabricTypes::inputs_default_value_float4,
FabricTypes::inputs_offset_float4,
FabricTypes::inputs_scale_float4);
break;
case MdlInternalPropertyType::MAT2_INT32:
case MdlInternalPropertyType::MAT2_FLOAT32:
case MdlInternalPropertyType::MAT2_INT32_NORM:
case MdlInternalPropertyType::MAT3_INT32:
case MdlInternalPropertyType::MAT3_FLOAT32:
case MdlInternalPropertyType::MAT3_INT32_NORM:
case MdlInternalPropertyType::MAT4_INT32:
case MdlInternalPropertyType::MAT4_FLOAT32:
case MdlInternalPropertyType::MAT4_INT32_NORM:
break;
}
}
void FabricMaterial::createPropertyTexturePropertyInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType) {
static const auto additionalAttributes = std::vector<std::pair<omni::fabric::Type, omni::fabric::Token>>{{
std::make_pair(FabricTypes::inputs_channels, FabricTokens::inputs_channels),
std::make_pair(FabricTypes::inputs_has_no_data, FabricTokens::inputs_has_no_data),
std::make_pair(noDataType, FabricTokens::inputs_no_data),
std::make_pair(defaultValueType, FabricTokens::inputs_default_value),
}};
return createTextureCommon(path, subidentifier, additionalAttributes);
}
void FabricMaterial::createPropertyTexturePropertyNormalizedInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType,
const omni::fabric::Type& maximumValueType) {
static const auto additionalAttributes = std::vector<std::pair<omni::fabric::Type, omni::fabric::Token>>{{
std::make_pair(FabricTypes::inputs_channels, FabricTokens::inputs_channels),
std::make_pair(FabricTypes::inputs_has_no_data, FabricTokens::inputs_has_no_data),
std::make_pair(noDataType, FabricTokens::inputs_no_data),
std::make_pair(defaultValueType, FabricTokens::inputs_default_value),
std::make_pair(offsetType, FabricTokens::inputs_offset),
std::make_pair(scaleType, FabricTokens::inputs_scale),
std::make_pair(maximumValueType, FabricTokens::inputs_maximum_value),
}};
return createTextureCommon(path, subidentifier, additionalAttributes);
}
void FabricMaterial::createPropertyTextureProperty(const omni::fabric::Path& path, MdlInternalPropertyType type) {
switch (type) {
case MdlInternalPropertyType::INT32:
createPropertyTexturePropertyInt(
path,
FabricTokens::cesium_internal_property_texture_int_lookup,
FabricTypes::inputs_no_data_int,
FabricTypes::inputs_default_value_int);
break;
case MdlInternalPropertyType::VEC2_INT32:
createPropertyTexturePropertyInt(
path,
FabricTokens::cesium_internal_property_texture_int2_lookup,
FabricTypes::inputs_no_data_int2,
FabricTypes::inputs_default_value_int2);
break;
case MdlInternalPropertyType::VEC3_INT32:
createPropertyTexturePropertyInt(
path,
FabricTokens::cesium_internal_property_texture_int3_lookup,
FabricTypes::inputs_no_data_int3,
FabricTypes::inputs_default_value_int3);
break;
case MdlInternalPropertyType::VEC4_INT32:
createPropertyTexturePropertyInt(
path,
FabricTokens::cesium_internal_property_texture_int4_lookup,
FabricTypes::inputs_no_data_int4,
FabricTypes::inputs_default_value_int4);
break;
case MdlInternalPropertyType::INT32_NORM:
createPropertyTexturePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_texture_normalized_int_lookup,
FabricTypes::inputs_no_data_int,
FabricTypes::inputs_default_value_float,
FabricTypes::inputs_offset_float,
FabricTypes::inputs_scale_float,
FabricTypes::inputs_maximum_value_int);
break;
case MdlInternalPropertyType::VEC2_INT32_NORM:
createPropertyTexturePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_texture_normalized_int2_lookup,
FabricTypes::inputs_no_data_int2,
FabricTypes::inputs_default_value_float2,
FabricTypes::inputs_offset_float2,
FabricTypes::inputs_scale_float2,
FabricTypes::inputs_maximum_value_int2);
break;
case MdlInternalPropertyType::VEC3_INT32_NORM:
createPropertyTexturePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_texture_normalized_int3_lookup,
FabricTypes::inputs_no_data_int3,
FabricTypes::inputs_default_value_float3,
FabricTypes::inputs_offset_float3,
FabricTypes::inputs_scale_float3,
FabricTypes::inputs_maximum_value_int3);
break;
case MdlInternalPropertyType::VEC4_INT32_NORM:
createPropertyTexturePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_texture_normalized_int4_lookup,
FabricTypes::inputs_no_data_int4,
FabricTypes::inputs_default_value_float4,
FabricTypes::inputs_offset_float4,
FabricTypes::inputs_scale_float4,
FabricTypes::inputs_maximum_value_int4);
break;
case MdlInternalPropertyType::FLOAT32:
case MdlInternalPropertyType::VEC2_FLOAT32:
case MdlInternalPropertyType::VEC3_FLOAT32:
case MdlInternalPropertyType::VEC4_FLOAT32:
case MdlInternalPropertyType::MAT2_INT32:
case MdlInternalPropertyType::MAT2_FLOAT32:
case MdlInternalPropertyType::MAT2_INT32_NORM:
case MdlInternalPropertyType::MAT3_INT32:
case MdlInternalPropertyType::MAT3_FLOAT32:
case MdlInternalPropertyType::MAT3_INT32_NORM:
case MdlInternalPropertyType::MAT4_INT32:
case MdlInternalPropertyType::MAT4_FLOAT32:
case MdlInternalPropertyType::MAT4_INT32_NORM:
break;
}
}
void FabricMaterial::createPropertyTablePropertyInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_property_table_texture, FabricTokens::inputs_property_table_texture);
attributes.addAttribute(FabricTypes::inputs_has_no_data, FabricTokens::inputs_has_no_data);
attributes.addAttribute(noDataType, FabricTokens::inputs_no_data);
attributes.addAttribute(defaultValueType, FabricTokens::inputs_default_value);
createAttributes(*_pContext, fabricStage, path, attributes, subidentifier);
}
void FabricMaterial::createPropertyTablePropertyNormalizedInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType,
const omni::fabric::Type& maximumValueType) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_property_table_texture, FabricTokens::inputs_property_table_texture);
attributes.addAttribute(FabricTypes::inputs_has_no_data, FabricTokens::inputs_has_no_data);
attributes.addAttribute(noDataType, FabricTokens::inputs_no_data);
attributes.addAttribute(defaultValueType, FabricTokens::inputs_default_value);
attributes.addAttribute(offsetType, FabricTokens::inputs_offset);
attributes.addAttribute(scaleType, FabricTokens::inputs_scale);
attributes.addAttribute(maximumValueType, FabricTokens::inputs_maximum_value);
createAttributes(*_pContext, fabricStage, path, attributes, subidentifier);
}
void FabricMaterial::createPropertyTablePropertyFloat(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType) {
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(path);
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::inputs_property_table_texture, FabricTokens::inputs_property_table_texture);
attributes.addAttribute(FabricTypes::inputs_has_no_data, FabricTokens::inputs_has_no_data);
attributes.addAttribute(noDataType, FabricTokens::inputs_no_data);
attributes.addAttribute(defaultValueType, FabricTokens::inputs_default_value);
attributes.addAttribute(offsetType, FabricTokens::inputs_offset);
attributes.addAttribute(scaleType, FabricTokens::inputs_scale);
createAttributes(*_pContext, fabricStage, path, attributes, subidentifier);
}
void FabricMaterial::createPropertyTableProperty(const omni::fabric::Path& path, MdlInternalPropertyType type) {
switch (type) {
case MdlInternalPropertyType::INT32:
createPropertyTablePropertyInt(
path,
FabricTokens::cesium_internal_property_table_int_lookup,
FabricTypes::inputs_no_data_int,
FabricTypes::inputs_default_value_int);
break;
case MdlInternalPropertyType::VEC2_INT32:
createPropertyTablePropertyInt(
path,
FabricTokens::cesium_internal_property_table_int2_lookup,
FabricTypes::inputs_no_data_int2,
FabricTypes::inputs_default_value_int2);
break;
case MdlInternalPropertyType::VEC3_INT32:
createPropertyTablePropertyInt(
path,
FabricTokens::cesium_internal_property_table_int3_lookup,
FabricTypes::inputs_no_data_int3,
FabricTypes::inputs_default_value_int3);
break;
case MdlInternalPropertyType::VEC4_INT32:
createPropertyTablePropertyInt(
path,
FabricTokens::cesium_internal_property_table_int4_lookup,
FabricTypes::inputs_no_data_int4,
FabricTypes::inputs_default_value_int4);
break;
case MdlInternalPropertyType::INT32_NORM:
createPropertyTablePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_table_normalized_int_lookup,
FabricTypes::inputs_no_data_int,
FabricTypes::inputs_default_value_float,
FabricTypes::inputs_offset_float,
FabricTypes::inputs_scale_float,
FabricTypes::inputs_maximum_value_int);
break;
case MdlInternalPropertyType::VEC2_INT32_NORM:
createPropertyTablePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_table_normalized_int2_lookup,
FabricTypes::inputs_no_data_int2,
FabricTypes::inputs_default_value_float2,
FabricTypes::inputs_offset_float2,
FabricTypes::inputs_scale_float2,
FabricTypes::inputs_maximum_value_int2);
break;
case MdlInternalPropertyType::VEC3_INT32_NORM:
createPropertyTablePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_table_normalized_int3_lookup,
FabricTypes::inputs_no_data_int3,
FabricTypes::inputs_default_value_float3,
FabricTypes::inputs_offset_float3,
FabricTypes::inputs_scale_float3,
FabricTypes::inputs_maximum_value_int3);
break;
case MdlInternalPropertyType::VEC4_INT32_NORM:
createPropertyTablePropertyNormalizedInt(
path,
FabricTokens::cesium_internal_property_table_normalized_int4_lookup,
FabricTypes::inputs_no_data_int4,
FabricTypes::inputs_default_value_float4,
FabricTypes::inputs_offset_float4,
FabricTypes::inputs_scale_float4,
FabricTypes::inputs_maximum_value_int4);
break;
case MdlInternalPropertyType::FLOAT32:
createPropertyTablePropertyFloat(
path,
FabricTokens::cesium_internal_property_table_float_lookup,
FabricTypes::inputs_no_data_float,
FabricTypes::inputs_default_value_float,
FabricTypes::inputs_offset_float,
FabricTypes::inputs_scale_float);
break;
case MdlInternalPropertyType::VEC2_FLOAT32:
createPropertyTablePropertyFloat(
path,
FabricTokens::cesium_internal_property_table_float2_lookup,
FabricTypes::inputs_no_data_float2,
FabricTypes::inputs_default_value_float2,
FabricTypes::inputs_offset_float2,
FabricTypes::inputs_scale_float2);
break;
case MdlInternalPropertyType::VEC3_FLOAT32:
createPropertyTablePropertyFloat(
path,
FabricTokens::cesium_internal_property_table_float3_lookup,
FabricTypes::inputs_no_data_float3,
FabricTypes::inputs_default_value_float3,
FabricTypes::inputs_offset_float3,
FabricTypes::inputs_scale_float3);
break;
case MdlInternalPropertyType::VEC4_FLOAT32:
createPropertyTablePropertyFloat(
path,
FabricTokens::cesium_internal_property_table_float4_lookup,
FabricTypes::inputs_no_data_float4,
FabricTypes::inputs_default_value_float4,
FabricTypes::inputs_offset_float4,
FabricTypes::inputs_scale_float4);
break;
case MdlInternalPropertyType::MAT2_INT32:
case MdlInternalPropertyType::MAT2_FLOAT32:
case MdlInternalPropertyType::MAT2_INT32_NORM:
case MdlInternalPropertyType::MAT3_INT32:
case MdlInternalPropertyType::MAT3_FLOAT32:
case MdlInternalPropertyType::MAT3_INT32_NORM:
case MdlInternalPropertyType::MAT4_INT32:
case MdlInternalPropertyType::MAT4_FLOAT32:
case MdlInternalPropertyType::MAT4_INT32_NORM:
break;
}
}
void FabricMaterial::reset() {
if (_usesDefaultMaterial) {
setShaderValues(
_shaderPath, GltfUtil::getDefaultMaterialInfo(), DEFAULT_DISPLAY_COLOR, DEFAULT_DISPLAY_OPACITY);
}
if (_materialDescriptor.hasBaseColorTexture()) {
setTextureValues(
_baseColorTexturePath,
_defaultWhiteTextureAssetPathToken,
GltfUtil::getDefaultTextureInfo(),
DEFAULT_TEXCOORD_INDEX);
}
for (const auto& featureIdIndexPath : _featureIdIndexPaths) {
setFeatureIdIndexValues(featureIdIndexPath, DEFAULT_NULL_FEATURE_ID);
}
for (const auto& featureIdAttributePath : _featureIdAttributePaths) {
setFeatureIdAttributeValues(featureIdAttributePath, DEFAULT_FEATURE_ID_PRIMVAR_NAME, DEFAULT_NULL_FEATURE_ID);
}
for (const auto& featureIdTexturePath : _featureIdTexturePaths) {
setFeatureIdTextureValues(
featureIdTexturePath,
_defaultTransparentTextureAssetPathToken,
GltfUtil::getDefaultTextureInfo(),
DEFAULT_TEXCOORD_INDEX,
DEFAULT_NULL_FEATURE_ID);
}
for (const auto& [type, paths] : _propertyAttributePropertyPaths) {
for (const auto& path : paths) {
CALL_TEMPLATED_FUNCTION_WITH_RUNTIME_MDL_TYPE(
clearPropertyAttributeProperty, type, _pContext->getFabricStage(), path);
}
}
for (const auto& [type, paths] : _propertyTexturePropertyPaths) {
for (const auto& path : paths) {
CALL_TEMPLATED_FUNCTION_WITH_RUNTIME_MDL_TYPE(
clearPropertyTextureProperty,
type,
_pContext->getFabricStage(),
path,
_defaultTransparentTextureAssetPathToken);
}
}
for (const auto& [type, paths] : _propertyTablePropertyPaths) {
for (const auto& path : paths) {
CALL_TEMPLATED_FUNCTION_WITH_RUNTIME_MDL_TYPE(
clearPropertyTableProperty,
type,
_pContext->getFabricStage(),
path,
_defaultTransparentTextureAssetPathToken);
}
}
for (const auto& rasterOverlayPath : _rasterOverlayPaths) {
setRasterOverlayValues(
rasterOverlayPath,
_defaultTransparentTextureAssetPathToken,
GltfUtil::getDefaultTextureInfo(),
DEFAULT_TEXCOORD_INDEX,
DEFAULT_ALPHA);
}
for (const auto& path : _allPaths) {
auto& fabricStage = _pContext->getFabricStage();
const auto tilesetIdFabric = fabricStage.getAttributeWr<int64_t>(path, FabricTokens::_cesium_tilesetId);
*tilesetIdFabric = FabricUtil::NO_TILESET_ID;
}
}
void FabricMaterial::setMaterial(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
int64_t tilesetId,
const FabricMaterialInfo& materialInfo,
const FabricFeaturesInfo& featuresInfo,
FabricTexture* pBaseColorTexture,
const std::vector<std::shared_ptr<FabricTexture>>& featureIdTextures,
const std::vector<std::shared_ptr<FabricTexture>>& propertyTextures,
const std::vector<std::shared_ptr<FabricTexture>>& propertyTableTextures,
const glm::dvec3& displayColor,
double displayOpacity,
const std::unordered_map<uint64_t, uint64_t>& texcoordIndexMapping,
const std::vector<uint64_t>& featureIdIndexSetIndexMapping,
const std::vector<uint64_t>& featureIdAttributeSetIndexMapping,
const std::vector<uint64_t>& featureIdTextureSetIndexMapping,
const std::unordered_map<uint64_t, uint64_t>& propertyTextureIndexMapping) {
if (stageDestroyed()) {
return;
}
if (_usesDefaultMaterial) {
_alphaMode = getInitialAlphaMode(_materialDescriptor, materialInfo);
if (_debugRandomColors) {
const auto r = glm::linearRand(0.0, 1.0);
const auto g = glm::linearRand(0.0, 1.0);
const auto b = glm::linearRand(0.0, 1.0);
_debugColor = glm::dvec3(r, g, b);
} else {
_debugColor = DEFAULT_DEBUG_COLOR;
}
setShaderValues(_shaderPath, materialInfo, displayColor, displayOpacity);
}
if (_materialDescriptor.hasBaseColorTexture()) {
const auto& textureInfo = materialInfo.baseColorTexture.value();
const auto& textureAssetPath = pBaseColorTexture->getAssetPathToken();
const auto texcoordIndex = texcoordIndexMapping.at(textureInfo.setIndex);
setTextureValues(_baseColorTexturePath, textureAssetPath, textureInfo, texcoordIndex);
}
const auto featureIdCounts = getFeatureIdCounts(_materialDescriptor);
for (uint64_t i = 0; i < featureIdCounts.indexCount; ++i) {
const auto featureIdSetIndex = featureIdIndexSetIndexMapping[i];
const auto featureId = featuresInfo.featureIds[featureIdSetIndex];
const auto& featureIdPath = _featureIdPaths[featureIdSetIndex];
const auto nullFeatureId = CppUtil::defaultValue(featureId.nullFeatureId, DEFAULT_NULL_FEATURE_ID);
setFeatureIdIndexValues(featureIdPath, nullFeatureId);
}
for (uint64_t i = 0; i < featureIdCounts.attributeCount; ++i) {
const auto featureIdSetIndex = featureIdAttributeSetIndexMapping[i];
const auto featureId = featuresInfo.featureIds[featureIdSetIndex];
const auto attributeSetIndex = std::get<uint64_t>(featureId.featureIdStorage);
const auto attributeName = fmt::format("_FEATURE_ID_{}", attributeSetIndex);
const auto& featureIdPath = _featureIdPaths[featureIdSetIndex];
const auto nullFeatureId = CppUtil::defaultValue(featureId.nullFeatureId, DEFAULT_NULL_FEATURE_ID);
setFeatureIdAttributeValues(featureIdPath, attributeName, nullFeatureId);
}
for (uint64_t i = 0; i < featureIdCounts.textureCount; ++i) {
const auto featureIdSetIndex = featureIdTextureSetIndexMapping[i];
const auto& featureId = featuresInfo.featureIds[featureIdSetIndex];
const auto& textureInfo = std::get<FabricTextureInfo>(featureId.featureIdStorage);
const auto& textureAssetPath = featureIdTextures[i]->getAssetPathToken();
const auto texcoordIndex = texcoordIndexMapping.at(textureInfo.setIndex);
const auto& featureIdPath = _featureIdPaths[featureIdSetIndex];
const auto nullFeatureId = CppUtil::defaultValue(featureId.nullFeatureId, DEFAULT_NULL_FEATURE_ID);
setFeatureIdTextureValues(featureIdPath, textureAssetPath, textureInfo, texcoordIndex, nullFeatureId);
}
const auto& properties = _materialDescriptor.getStyleableProperties();
if (!properties.empty()) {
const auto getPropertyPath = [this, &properties](const std::string& propertyId) {
const auto index = CppUtil::indexOfByMember(properties, &FabricPropertyDescriptor::propertyId, propertyId);
assert(index != properties.size());
return _propertyPaths[index];
};
const auto unsupportedCallback = []([[maybe_unused]] const std::string& propertyId,
[[maybe_unused]] const std::string& warning) {};
MetadataUtil::forEachStyleablePropertyAttributeProperty(
*_pContext,
model,
primitive,
[this, &getPropertyPath](
const std::string& propertyId,
[[maybe_unused]] const auto& propertyAttributePropertyView,
const auto& property) {
constexpr auto type = std::decay_t<decltype(property)>::Type;
constexpr auto mdlType = DataTypeUtil::getMdlInternalPropertyType<type>();
const auto& primvarName = property.attribute;
const auto& propertyPath = getPropertyPath(propertyId);
const auto& propertyInfo = property.propertyInfo;
const auto hasNoData = propertyInfo.noData.has_value();
const auto offset = getOffset(propertyInfo);
const auto scale = getScale(propertyInfo);
const auto noData = getNoData(propertyInfo);
const auto defaultValue = getDefaultValue(propertyInfo);
constexpr auto maximumValue = getMaximumValue<type>();
setPropertyAttributePropertyValues<mdlType>(
_pContext->getFabricStage(),
propertyPath,
primvarName,
offset,
scale,
maximumValue,
hasNoData,
noData,
defaultValue);
},
unsupportedCallback);
MetadataUtil::forEachStyleablePropertyTextureProperty(
*_pContext,
model,
primitive,
[this, &propertyTextures, &texcoordIndexMapping, &propertyTextureIndexMapping, &getPropertyPath](
const std::string& propertyId,
[[maybe_unused]] const auto& propertyTexturePropertyView,
const auto& property) {
constexpr auto type = std::decay_t<decltype(property)>::Type;
constexpr auto mdlType = DataTypeUtil::getMdlInternalPropertyType<type>();
const auto& textureInfo = property.textureInfo;
const auto textureIndex = property.textureIndex;
const auto& propertyPath = getPropertyPath(propertyId);
const auto texcoordIndex = texcoordIndexMapping.at(textureInfo.setIndex);
const auto propertyTextureIndex = propertyTextureIndexMapping.at(textureIndex);
const auto& textureAssetPath = propertyTextures[propertyTextureIndex]->getAssetPathToken();
const auto& propertyInfo = property.propertyInfo;
const auto hasNoData = propertyInfo.noData.has_value();
const auto offset = getOffset(propertyInfo);
const auto scale = getScale(propertyInfo);
const auto noData = getNoData(propertyInfo);
const auto defaultValue = getDefaultValue(propertyInfo);
constexpr auto maximumValue = getMaximumValue<type>();
setPropertyTexturePropertyValues<mdlType>(
_pContext->getFabricStage(),
propertyPath,
textureAssetPath,
textureInfo,
texcoordIndex,
offset,
scale,
maximumValue,
hasNoData,
noData,
defaultValue);
},
unsupportedCallback);
uint64_t propertyTablePropertyCounter = 0;
MetadataUtil::forEachStyleablePropertyTableProperty(
*_pContext,
model,
primitive,
[this, &propertyTableTextures, &propertyTablePropertyCounter, &getPropertyPath](
const std::string& propertyId,
[[maybe_unused]] const auto& propertyTablePropertyView,
const auto& property) {
constexpr auto type = std::decay_t<decltype(property)>::Type;
constexpr auto mdlType = DataTypeUtil::getMdlInternalPropertyType<type>();
const auto& propertyPath = getPropertyPath(propertyId);
const auto textureIndex = propertyTablePropertyCounter++;
const auto& textureAssetPath = propertyTableTextures[textureIndex]->getAssetPathToken();
const auto& propertyInfo = property.propertyInfo;
const auto hasNoData = propertyInfo.noData.has_value();
const auto offset = getOffset(propertyInfo);
const auto scale = getScale(propertyInfo);
const auto noData = getNoData(propertyInfo);
const auto defaultValue = getDefaultValue(propertyInfo);
constexpr auto maximumValue = getMaximumValue<type>();
setPropertyTablePropertyValues<mdlType>(
_pContext->getFabricStage(),
propertyPath,
textureAssetPath,
offset,
scale,
maximumValue,
hasNoData,
noData,
defaultValue);
},
unsupportedCallback);
}
for (const auto& path : _allPaths) {
auto& fabricStage = _pContext->getFabricStage();
const auto tilesetIdFabric = fabricStage.getAttributeWr<int64_t>(path, FabricTokens::_cesium_tilesetId);
*tilesetIdFabric = tilesetId;
}
}
void FabricMaterial::createConnectionsToCopiedPaths() {
auto& fabricStage = _pContext->getFabricStage();
const auto hasBaseColorTexture = _materialDescriptor.hasBaseColorTexture();
const auto rasterOverlay = getRasterOverlayCount(_materialDescriptor);
const auto featureIdCount = getFeatureIdCounts(_materialDescriptor).totalCount;
for (const auto& copiedPath : _copiedBaseColorTexturePaths) {
if (hasBaseColorTexture) {
createConnection(fabricStage, _baseColorTexturePath, copiedPath, FabricTokens::inputs_base_color_texture);
}
}
for (const auto& copiedPath : _copiedRasterOverlayPaths) {
const auto indexFabric = fabricStage.getAttributeRd<int>(copiedPath, FabricTokens::inputs_raster_overlay_index);
const auto index = static_cast<uint64_t>(CppUtil::defaultValue(indexFabric, 0));
if (index < rasterOverlay) {
createConnection(fabricStage, _rasterOverlayPaths[index], copiedPath, FabricTokens::inputs_raster_overlay);
}
}
for (const auto& copiedPath : _copiedFeatureIdPaths) {
const auto indexFabric = fabricStage.getAttributeRd<int>(copiedPath, FabricTokens::inputs_feature_id_set_index);
const auto index = static_cast<uint64_t>(CppUtil::defaultValue(indexFabric, 0));
if (index < featureIdCount) {
createConnection(fabricStage, _featureIdPaths[index], copiedPath, FabricTokens::inputs_feature_id);
}
}
}
void FabricMaterial::destroyConnectionsToCopiedPaths() {
auto& fabricStage = _pContext->getFabricStage();
for (const auto& copiedPath : _copiedBaseColorTexturePaths) {
destroyConnection(fabricStage, copiedPath, FabricTokens::inputs_base_color_texture);
}
for (const auto& copiedPath : _copiedRasterOverlayPaths) {
destroyConnection(fabricStage, copiedPath, FabricTokens::inputs_raster_overlay);
}
for (const auto& copiedPath : _copiedFeatureIdPaths) {
destroyConnection(fabricStage, copiedPath, FabricTokens::inputs_feature_id);
}
}
void FabricMaterial::createConnectionsToProperties() {
auto& fabricStage = _pContext->getFabricStage();
const auto& properties = _materialDescriptor.getStyleableProperties();
const auto& unsupportedPropertyWarnings = _materialDescriptor.getUnsupportedPropertyWarnings();
for (const auto& propertyPathExternal : _copiedPropertyPaths) {
const auto propertyId = getStringFabric(fabricStage, propertyPathExternal, FabricTokens::inputs_property_id);
const auto mdlIdentifier = FabricUtil::getMdlIdentifier(fabricStage, propertyPathExternal);
const auto propertyTypeExternal = FabricUtil::getMdlExternalPropertyType(mdlIdentifier);
const auto index = CppUtil::indexOfByMember(properties, &FabricPropertyDescriptor::propertyId, propertyId);
if (index == properties.size()) {
if (CppUtil::contains(unsupportedPropertyWarnings, propertyId)) {
_pContext->getLogger()->oneTimeWarning(unsupportedPropertyWarnings.at(propertyId));
} else {
_pContext->getLogger()->oneTimeWarning(
"Could not find property \"{}\" referenced by {}. A default value will be returned instead.",
propertyId,
mdlIdentifier.getText());
}
continue;
}
const auto propertyTypeInternal = properties[index].type;
if (!FabricUtil::typesCompatible(propertyTypeExternal, propertyTypeInternal)) {
_pContext->getLogger()->oneTimeWarning(
"Property \"{}\" referenced by {} has incompatible type. A default value will be returned instead.",
propertyId,
mdlIdentifier.getText());
continue;
}
const auto& propertyPathInternal = _propertyPaths[index];
createConnection(fabricStage, propertyPathInternal, propertyPathExternal, FabricTokens::inputs_property_value);
}
}
void FabricMaterial::destroyConnectionsToProperties() {
auto& fabricStage = _pContext->getFabricStage();
for (const auto& copiedPath : _copiedPropertyPaths) {
destroyConnection(fabricStage, copiedPath, FabricTokens::inputs_property_value);
}
}
void FabricMaterial::setRasterOverlay(
FabricTexture* pTexture,
const FabricTextureInfo& textureInfo,
uint64_t rasterOverlayIndex,
double alpha,
const std::unordered_map<uint64_t, uint64_t>& rasterOverlayTexcoordIndexMapping) {
if (stageDestroyed()) {
return;
}
if (rasterOverlayIndex >= _rasterOverlayPaths.size()) {
return;
}
const auto& textureAssetPath = pTexture->getAssetPathToken();
const auto texcoordIndex = rasterOverlayTexcoordIndexMapping.at(textureInfo.setIndex);
const auto& rasterOverlay = _rasterOverlayPaths[rasterOverlayIndex];
setRasterOverlayValues(rasterOverlay, textureAssetPath, textureInfo, texcoordIndex, alpha);
}
void FabricMaterial::setRasterOverlayAlpha(uint64_t rasterOverlayIndex, double alpha) {
if (stageDestroyed()) {
return;
}
if (rasterOverlayIndex >= _rasterOverlayPaths.size()) {
return;
}
const auto& rasterOverlayPath = _rasterOverlayPaths[rasterOverlayIndex];
setRasterOverlayAlphaValue(rasterOverlayPath, alpha);
}
void FabricMaterial::setDisplayColorAndOpacity(const glm::dvec3& displayColor, double displayOpacity) {
if (stageDestroyed()) {
return;
}
if (!_usesDefaultMaterial) {
return;
}
auto& fabricStage = _pContext->getFabricStage();
const auto tileColorFabric = fabricStage.getAttributeWr<glm::fvec4>(_shaderPath, FabricTokens::inputs_tile_color);
const auto alphaModeFabric = fabricStage.getAttributeWr<int>(_shaderPath, FabricTokens::inputs_alpha_mode);
*tileColorFabric = glm::fvec4(getTileColor(_debugColor, displayColor, displayOpacity));
*alphaModeFabric = getAlphaMode(_alphaMode, displayOpacity);
}
void FabricMaterial::updateShaderInput(const omni::fabric::Path& path, const omni::fabric::Token& attributeName) {
if (stageDestroyed()) {
return;
}
auto& fabricStage = _pContext->getFabricStage();
const auto iFabricStage = carb::getCachedInterface<omni::fabric::IStageReaderWriter>();
const auto copiedShaderPath = FabricUtil::getCopiedShaderPath(_materialPath, path);
const auto attributesToCopy = std::vector<omni::fabric::TokenC>{attributeName.asTokenC()};
assert(fabricStage.primExists(copiedShaderPath));
iFabricStage->copySpecifiedAttributes(
fabricStage.getId(),
path,
attributesToCopy.data(),
copiedShaderPath,
attributesToCopy.data(),
attributesToCopy.size());
if (attributeName == FabricTokens::inputs_raster_overlay_index ||
attributeName == FabricTokens::inputs_feature_id_set_index) {
destroyConnectionsToCopiedPaths();
createConnectionsToCopiedPaths();
}
if (attributeName == FabricTokens::inputs_property_id) {
destroyConnectionsToProperties();
createConnectionsToProperties();
}
}
void FabricMaterial::clearRasterOverlay(uint64_t rasterOverlayIndex) {
if (stageDestroyed()) {
return;
}
if (rasterOverlayIndex >= _rasterOverlayPaths.size()) {
return;
}
const auto& rasterOverlayPath = _rasterOverlayPaths[rasterOverlayIndex];
setRasterOverlayValues(
rasterOverlayPath,
_defaultTransparentTextureAssetPathToken,
GltfUtil::getDefaultTextureInfo(),
DEFAULT_TEXCOORD_INDEX,
DEFAULT_ALPHA);
}
void FabricMaterial::setShaderValues(
const omni::fabric::Path& path,
const FabricMaterialInfo& materialInfo,
const glm::dvec3& displayColor,
double displayOpacity) {
auto& fabricStage = _pContext->getFabricStage();
const auto tileColorFabric = fabricStage.getAttributeWr<pxr::GfVec4f>(path, FabricTokens::inputs_tile_color);
const auto alphaCutoffFabric = fabricStage.getAttributeWr<float>(path, FabricTokens::inputs_alpha_cutoff);
const auto alphaModeFabric = fabricStage.getAttributeWr<int>(path, FabricTokens::inputs_alpha_mode);
const auto baseAlphaFabric = fabricStage.getAttributeWr<float>(path, FabricTokens::inputs_base_alpha);
const auto baseColorFactorFabric =
fabricStage.getAttributeWr<pxr::GfVec3f>(path, FabricTokens::inputs_base_color_factor);
const auto emissiveFactorFabric =
fabricStage.getAttributeWr<pxr::GfVec3f>(path, FabricTokens::inputs_emissive_factor);
const auto metallicFactorFabric = fabricStage.getAttributeWr<float>(path, FabricTokens::inputs_metallic_factor);
const auto roughnessFactorFabric = fabricStage.getAttributeWr<float>(path, FabricTokens::inputs_roughness_factor);
*tileColorFabric = UsdUtil::glmToUsdVector(glm::fvec4(getTileColor(_debugColor, displayColor, displayOpacity)));
*alphaCutoffFabric = static_cast<float>(materialInfo.alphaCutoff);
*alphaModeFabric = getAlphaMode(_alphaMode, displayOpacity);
*baseAlphaFabric = static_cast<float>(materialInfo.baseAlpha);
*baseColorFactorFabric = UsdUtil::glmToUsdVector(glm::fvec3(materialInfo.baseColorFactor));
*emissiveFactorFabric = UsdUtil::glmToUsdVector(glm::fvec3(materialInfo.emissiveFactor));
*metallicFactorFabric = static_cast<float>(materialInfo.metallicFactor);
*roughnessFactorFabric = static_cast<float>(materialInfo.roughnessFactor);
}
void FabricMaterial::setTextureValues(
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex) {
setTextureValuesCommon(_pContext->getFabricStage(), path, textureAssetPathToken, textureInfo, texcoordIndex);
}
void FabricMaterial::setRasterOverlayValues(
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex,
double alpha) {
setTextureValuesCommon(_pContext->getFabricStage(), path, textureAssetPathToken, textureInfo, texcoordIndex);
setRasterOverlayAlphaValue(path, alpha);
}
void FabricMaterial::setRasterOverlayAlphaValue(const omni::fabric::Path& path, double alpha) {
const auto alphaFabric = _pContext->getFabricStage().getAttributeWr<float>(path, FabricTokens::inputs_alpha);
*alphaFabric = static_cast<float>(alpha);
}
void FabricMaterial::setFeatureIdIndexValues(const omni::fabric::Path& path, int nullFeatureId) {
setFeatureIdAttributeValues(path, pxr::UsdTokens->vertexId.GetString(), nullFeatureId);
}
void FabricMaterial::setFeatureIdAttributeValues(
const omni::fabric::Path& path,
const std::string& primvarName,
int nullFeatureId) {
auto& fabricStage = _pContext->getFabricStage();
setStringFabric(fabricStage, path, FabricTokens::inputs_primvar_name, primvarName);
const auto nullFeatureIdFabric = fabricStage.getAttributeWr<int>(path, FabricTokens::inputs_null_feature_id);
*nullFeatureIdFabric = nullFeatureId;
}
void FabricMaterial::setFeatureIdTextureValues(
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex,
int nullFeatureId) {
auto& fabricStage = _pContext->getFabricStage();
setTextureValuesCommonChannels(fabricStage, path, textureAssetPathToken, textureInfo, texcoordIndex);
const auto nullFeatureIdFabric = fabricStage.getAttributeWr<int>(path, FabricTokens::inputs_null_feature_id);
*nullFeatureIdFabric = nullFeatureId;
}
bool FabricMaterial::stageDestroyed() {
// Tile render resources may be processed asynchronously even after the tileset and stage have been destroyed.
// Add this check to all public member functions, including constructors and destructors, to prevent them from
// modifying the stage.
return _stageId != _pContext->getUsdStageId();
}
} // namespace cesium::omniverse
| 87,750 | C++ | 44.139403 | 160 | 0.700536 |
CesiumGS/cesium-omniverse/src/core/src/UsdScopedEdit.cpp | #include "cesium/omniverse/UsdScopedEdit.h"
namespace cesium::omniverse {
UsdScopedEdit::UsdScopedEdit(const pxr::UsdStageWeakPtr& pStage)
: _pStage(pStage)
, _sessionLayer(_pStage->GetSessionLayer())
, _sessionLayerWasEditable(_sessionLayer->PermissionToEdit())
, _originalEditTarget(_pStage->GetEditTarget()) {
_sessionLayer->SetPermissionToEdit(true);
_pStage->SetEditTarget(pxr::UsdEditTarget(_sessionLayer));
}
UsdScopedEdit::~UsdScopedEdit() {
_sessionLayer->SetPermissionToEdit(_sessionLayerWasEditable);
_pStage->SetEditTarget(_originalEditTarget);
}
} // namespace cesium::omniverse
| 629 | C++ | 28.999999 | 65 | 0.748808 |
CesiumGS/cesium-omniverse/src/core/src/FabricTexture.cpp | #include "cesium/omniverse/FabricTexture.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/FabricTextureInfo.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumGltf/ImageCesium.h>
#include <carb/Types.h>
#include <omni/ui/ImageProvider/DynamicTextureProvider.h>
#include <array>
namespace cesium::omniverse {
namespace {
carb::Format
getCompressedImageFormat(CesiumGltf::GpuCompressedPixelFormat pixelFormat, TransferFunction transferFunction) {
switch (pixelFormat) {
case CesiumGltf::GpuCompressedPixelFormat::BC1_RGB:
switch (transferFunction) {
case TransferFunction::LINEAR:
return carb::Format::eBC1_RGBA_UNORM;
case TransferFunction::SRGB:
return carb::Format::eBC1_RGBA_SRGB;
}
return carb::Format::eUnknown;
case CesiumGltf::GpuCompressedPixelFormat::BC3_RGBA:
switch (transferFunction) {
case TransferFunction::LINEAR:
return carb::Format::eBC3_RGBA_UNORM;
case TransferFunction::SRGB:
return carb::Format::eBC3_RGBA_SRGB;
}
return carb::Format::eUnknown;
case CesiumGltf::GpuCompressedPixelFormat::BC4_R:
return carb::Format::eBC4_R_UNORM;
case CesiumGltf::GpuCompressedPixelFormat::BC5_RG:
return carb::Format::eBC5_RG_UNORM;
case CesiumGltf::GpuCompressedPixelFormat::BC7_RGBA:
switch (transferFunction) {
case TransferFunction::LINEAR:
return carb::Format::eBC7_RGBA_UNORM;
case TransferFunction::SRGB:
return carb::Format::eBC7_RGBA_SRGB;
}
return carb::Format::eUnknown;
default:
// Unsupported compressed texture format.
return carb::Format::eUnknown;
}
}
carb::Format
getUncompressedImageFormat(uint64_t channels, uint64_t bytesPerChannel, TransferFunction transferFunction) {
switch (channels) {
case 1:
switch (bytesPerChannel) {
case 1:
return carb::Format::eR8_UNORM;
case 2:
return carb::Format::eR16_UNORM;
}
break;
case 2:
switch (bytesPerChannel) {
case 1:
return carb::Format::eRG8_UNORM;
case 2:
return carb::Format::eRG16_UNORM;
}
break;
case 4:
switch (bytesPerChannel) {
case 1:
switch (transferFunction) {
case TransferFunction::LINEAR:
return carb::Format::eRGBA8_UNORM;
case TransferFunction::SRGB:
return carb::Format::eRGBA8_SRGB;
}
break;
case 2:
return carb::Format::eRGBA16_UNORM;
}
break;
}
return carb::Format::eUnknown;
}
} // namespace
FabricTexture::FabricTexture(Context* pContext, const std::string& name, int64_t poolId)
: _pContext(pContext)
, _pTexture(std::make_unique<omni::ui::DynamicTextureProvider>(name))
, _assetPathToken(UsdUtil::getDynamicTextureProviderAssetPathToken(name))
, _poolId(poolId) {
reset();
}
FabricTexture::~FabricTexture() = default;
void FabricTexture::setImage(const CesiumGltf::ImageCesium& image, TransferFunction transferFunction) {
carb::Format imageFormat;
const auto isCompressed = image.compressedPixelFormat != CesiumGltf::GpuCompressedPixelFormat::NONE;
if (isCompressed) {
imageFormat = getCompressedImageFormat(image.compressedPixelFormat, transferFunction);
} else {
imageFormat = getUncompressedImageFormat(
static_cast<uint64_t>(image.channels), static_cast<uint64_t>(image.bytesPerChannel), transferFunction);
}
if (imageFormat == carb::Format::eUnknown) {
_pContext->getLogger()->warn("Invalid image format");
} else {
// As of Kit 105.1, omni::ui::kAutoCalculateStride doesn't work for compressed textures. This value somehow works.
const auto stride = isCompressed ? 4ULL * static_cast<uint64_t>(image.width) : omni::ui::kAutoCalculateStride;
const auto data = reinterpret_cast<const uint8_t*>(image.pixelData.data());
const auto dimensions = carb::Uint2{static_cast<uint32_t>(image.width), static_cast<uint32_t>(image.height)};
_pTexture->setBytesData(data, dimensions, stride, imageFormat);
}
}
void FabricTexture::setBytes(
const std::vector<std::byte>& bytes,
uint64_t width,
uint64_t height,
carb::Format format) {
const auto data = reinterpret_cast<const uint8_t*>(bytes.data());
const auto dimensions = carb::Uint2{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
_pTexture->setBytesData(data, dimensions, omni::ui::kAutoCalculateStride, format);
}
void FabricTexture::setActive(bool active) {
if (!active) {
reset();
}
}
const pxr::TfToken& FabricTexture::getAssetPathToken() const {
return _assetPathToken;
}
int64_t FabricTexture::getPoolId() const {
return _poolId;
}
void FabricTexture::reset() {
const auto bytes = std::array<uint8_t, 4>{{255, 255, 255, 255}};
const auto size = carb::Uint2{1, 1};
_pTexture->setBytesData(bytes.data(), size, omni::ui::kAutoCalculateStride, carb::Format::eRGBA8_SRGB);
}
} // namespace cesium::omniverse
| 5,664 | C++ | 34.40625 | 122 | 0.617232 |
CesiumGS/cesium-omniverse/src/core/src/FabricTexturePool.cpp | #include "cesium/omniverse/FabricTexturePool.h"
#include "cesium/omniverse/Context.h"
#include <spdlog/fmt/fmt.h>
namespace cesium::omniverse {
FabricTexturePool::FabricTexturePool(Context* pContext, int64_t poolId, uint64_t initialCapacity)
: ObjectPool<FabricTexture>()
, _pContext(pContext)
, _poolId(poolId) {
setCapacity(initialCapacity);
}
int64_t FabricTexturePool::getPoolId() const {
return _poolId;
}
std::shared_ptr<FabricTexture> FabricTexturePool::createObject(uint64_t objectId) const {
const auto contextId = _pContext->getContextId();
const auto name = fmt::format("/cesium_texture_pool_{}_object_{}_context_{}", _poolId, objectId, contextId);
return std::make_shared<FabricTexture>(_pContext, name, _poolId);
}
void FabricTexturePool::setActive(FabricTexture* pTexture, bool active) const {
pTexture->setActive(active);
}
}; // namespace cesium::omniverse
| 917 | C++ | 28.612902 | 112 | 0.733915 |
CesiumGS/cesium-omniverse/src/core/src/UsdTokens.cpp | #include "cesium/omniverse/UsdTokens.h"
#include <spdlog/fmt/fmt.h>
// clang-format off
PXR_NAMESPACE_OPEN_SCOPE
#ifdef CESIUM_OMNI_MSVC
__pragma(warning(push))
__pragma(warning(disable: 4003))
#endif
#ifdef CESIUM_OMNI_CLANG
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
#endif
TF_DEFINE_PUBLIC_TOKENS(
UsdTokens,
USD_TOKENS);
#ifdef CESIUM_OMNI_CLANG
#pragma clang diagnostic pop
#endif
#ifdef CESIUM_OMNI_MSVC
__pragma(warning(pop))
#endif
PXR_NAMESPACE_CLOSE_SCOPE
// clang-format on
namespace cesium::omniverse::FabricTokens {
FABRIC_DEFINE_TOKENS(USD_TOKENS);
namespace {
std::mutex tokenMutex;
std::vector<omni::fabric::Token> feature_id_tokens;
std::vector<omni::fabric::Token> raster_overlay_tokens;
std::vector<omni::fabric::Token> inputs_raster_overlay_tokens;
std::vector<omni::fabric::Token> primvars_st_tokens;
std::vector<omni::fabric::Token> property_tokens;
const omni::fabric::TokenC
getToken(std::vector<omni::fabric::Token>& tokens, uint64_t index, const std::string_view& prefix) {
const auto lock = std::scoped_lock(tokenMutex);
const auto size = index + 1;
if (size > tokens.size()) {
tokens.resize(size);
}
auto& token = tokens[index];
if (token.asTokenC() == omni::fabric::kUninitializedToken) {
const auto tokenStr = fmt::format("{}_{}", prefix, index);
token = omni::fabric::Token(tokenStr.c_str());
}
return token.asTokenC();
}
} // namespace
const omni::fabric::TokenC feature_id_n(uint64_t index) {
return getToken(feature_id_tokens, index, "feature_id");
}
const omni::fabric::TokenC raster_overlay_n(uint64_t index) {
return getToken(raster_overlay_tokens, index, "raster_overlay");
}
const omni::fabric::TokenC inputs_raster_overlay_n(uint64_t index) {
return getToken(inputs_raster_overlay_tokens, index, "inputs:raster_overlay");
}
const omni::fabric::TokenC primvars_st_n(uint64_t index) {
return getToken(primvars_st_tokens, index, "primvars:st");
}
const omni::fabric::TokenC property_n(uint64_t index) {
return getToken(property_tokens, index, "property");
}
} // namespace cesium::omniverse::FabricTokens
| 2,365 | C++ | 26.835294 | 104 | 0.664693 |
CesiumGS/cesium-omniverse/src/core/src/OmniIonRasterOverlay.cpp | #include "cesium/omniverse/OmniIonRasterOverlay.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Broadcast.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/Logger.h"
#include "cesium/omniverse/OmniIonServer.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumAsync/IAssetResponse.h>
#include <CesiumIonClient/Token.h>
#include <CesiumRasterOverlays/IonRasterOverlay.h>
#include <CesiumUsdSchemas/ionRasterOverlay.h>
#include <CesiumUtility/IntrusivePointer.h>
namespace cesium::omniverse {
namespace {} // namespace
OmniIonRasterOverlay::OmniIonRasterOverlay(Context* pContext, const pxr::SdfPath& path)
: OmniRasterOverlay(pContext, path) {
reload();
}
int64_t OmniIonRasterOverlay::getIonAssetId() const {
const auto cesiumIonRasterOverlay = UsdUtil::getCesiumIonRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumIonRasterOverlay)) {
return 0;
}
int64_t ionAssetId;
cesiumIonRasterOverlay.GetIonAssetIdAttr().Get(&ionAssetId);
return ionAssetId;
}
CesiumIonClient::Token OmniIonRasterOverlay::getIonAccessToken() const {
const auto cesiumIonRasterOverlay = UsdUtil::getCesiumIonRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumIonRasterOverlay)) {
return {};
}
std::string ionAccessToken;
cesiumIonRasterOverlay.GetIonAccessTokenAttr().Get(&ionAccessToken);
if (!ionAccessToken.empty()) {
CesiumIonClient::Token t;
t.token = ionAccessToken;
return t;
}
const auto ionServerPath = getResolvedIonServerPath();
if (ionServerPath.IsEmpty()) {
return {};
}
const auto pIonServer = _pContext->getAssetRegistry().getIonServer(ionServerPath);
if (!pIonServer) {
return {};
}
return pIonServer->getToken();
}
std::string OmniIonRasterOverlay::getIonApiUrl() const {
const auto ionServerPath = getResolvedIonServerPath();
if (ionServerPath.IsEmpty()) {
return {};
}
const auto pIonServer = _pContext->getAssetRegistry().getIonServer(ionServerPath);
if (!pIonServer) {
return {};
}
return pIonServer->getIonServerApiUrl();
}
pxr::SdfPath OmniIonRasterOverlay::getResolvedIonServerPath() const {
const auto cesiumIonRasterOverlay = UsdUtil::getCesiumIonRasterOverlay(_pContext->getUsdStage(), _path);
if (!UsdUtil::isSchemaValid(cesiumIonRasterOverlay)) {
return {};
}
pxr::SdfPathVector targets;
cesiumIonRasterOverlay.GetIonServerBindingRel().GetForwardedTargets(&targets);
if (!targets.empty()) {
return targets.front();
}
// Fall back to using the first ion server if there's no explicit binding
const auto pIonServer = _pContext->getAssetRegistry().getFirstIonServer();
if (pIonServer) {
return pIonServer->getPath();
}
return {};
}
CesiumRasterOverlays::RasterOverlay* OmniIonRasterOverlay::getRasterOverlay() const {
return _pIonRasterOverlay.get();
}
void OmniIonRasterOverlay::reload() {
const auto rasterOverlayIonAssetId = getIonAssetId();
const auto rasterOverlayIonAccessToken = getIonAccessToken();
const auto rasterOverlayIonApiUrl = getIonApiUrl();
if (rasterOverlayIonAssetId <= 0 || rasterOverlayIonAccessToken.token.empty() || rasterOverlayIonApiUrl.empty()) {
return;
}
const auto rasterOverlayName = UsdUtil::getName(_pContext->getUsdStage(), _path);
auto options = createRasterOverlayOptions();
options.loadErrorCallback = [this, rasterOverlayIonAssetId, rasterOverlayName](
const CesiumRasterOverlays::RasterOverlayLoadFailureDetails& error) {
// Check for a 401 connecting to Cesium ion, which means the token is invalid
// (or perhaps the asset ID is). Also check for a 404, because ion returns 404
// when the token is valid but not authorized for the asset.
const auto statusCode =
error.pRequest && error.pRequest->response() ? error.pRequest->response()->statusCode() : 0;
if (error.type == CesiumRasterOverlays::RasterOverlayLoadType::CesiumIon &&
(statusCode == 401 || statusCode == 404)) {
Broadcast::showTroubleshooter({}, 0, "", rasterOverlayIonAssetId, rasterOverlayName, error.message);
}
_pContext->getLogger()->error(error.message);
};
_pIonRasterOverlay = new CesiumRasterOverlays::IonRasterOverlay(
rasterOverlayName, rasterOverlayIonAssetId, rasterOverlayIonAccessToken.token, options, rasterOverlayIonApiUrl);
}
} // namespace cesium::omniverse
| 4,675 | C++ | 31.6993 | 120 | 0.708449 |
CesiumGS/cesium-omniverse/src/core/src/SettingsWrapper.cpp | #include "cesium/omniverse/SettingsWrapper.h"
#include <carb/InterfaceUtils.h>
#include <carb/settings/ISettings.h>
#include <spdlog/fmt/bundled/format.h>
namespace cesium::omniverse::Settings {
namespace {
const uint64_t MAX_SESSIONS = 10;
const std::string_view SESSION_ION_SERVER_URL_BASE =
"/persistent/exts/cesium.omniverse/sessions/session{}/ionServerUrl";
const std::string_view SESSION_USER_ACCESS_TOKEN_BASE =
"/persistent/exts/cesium.omniverse/sessions/session{}/userAccessToken";
const char* MAX_CACHE_ITEMS_PATH = "/persistent/exts/cesium.omniverse/maxCacheItems";
std::string getIonApiUrlSettingPath(const uint64_t index) {
return fmt::format(SESSION_ION_SERVER_URL_BASE, index);
}
std::string getAccessTokenSettingPath(const uint64_t index) {
return fmt::format(SESSION_USER_ACCESS_TOKEN_BASE, index);
}
} // namespace
std::vector<AccessToken> getAccessTokens() {
const auto iSettings = carb::getCachedInterface<carb::settings::ISettings>();
std::vector<AccessToken> accessTokens;
accessTokens.reserve(MAX_SESSIONS);
for (uint64_t i = 0; i < MAX_SESSIONS; ++i) {
const auto ionApiUrlKey = getIonApiUrlSettingPath(i);
const auto accessTokenKey = getAccessTokenSettingPath(i);
const auto ionApiUrlValue = iSettings->getStringBuffer(ionApiUrlKey.c_str());
const auto accessTokenValue = iSettings->getStringBuffer(accessTokenKey.c_str());
if (ionApiUrlValue && accessTokenValue) {
// In C++ 20 this can be emplace_back without the {}
accessTokens.push_back({ionApiUrlValue, accessTokenValue});
}
}
return accessTokens;
}
void setAccessToken(const AccessToken& accessToken) {
const auto iSettings = carb::getCachedInterface<carb::settings::ISettings>();
const auto oldAccessTokens = getAccessTokens();
std::vector<AccessToken> newAccessTokens;
newAccessTokens.reserve(oldAccessTokens.size() + 1); // Worst case we'll be growing by 1, so preempt that.
for (const auto& oldAccessToken : oldAccessTokens) {
if (oldAccessToken.ionApiUrl == accessToken.ionApiUrl) {
continue;
}
newAccessTokens.push_back(oldAccessToken);
}
newAccessTokens.push_back(accessToken);
clearTokens();
for (uint64_t i = 0; i < newAccessTokens.size(); ++i) {
const auto ionApiUrlKey = getIonApiUrlSettingPath(i);
const auto accessTokenKey = getAccessTokenSettingPath(i);
iSettings->set(ionApiUrlKey.c_str(), newAccessTokens[i].ionApiUrl.c_str());
iSettings->set(accessTokenKey.c_str(), newAccessTokens[i].accessToken.c_str());
}
}
void removeAccessToken(const std::string& ionApiUrl) {
const auto iSettings = carb::getCachedInterface<carb::settings::ISettings>();
const auto oldAccessTokens = getAccessTokens();
std::vector<AccessToken> newAccessTokens;
newAccessTokens.reserve(oldAccessTokens.size());
for (auto& oldAccessToken : oldAccessTokens) {
if (oldAccessToken.ionApiUrl == ionApiUrl) {
continue;
}
newAccessTokens.push_back(oldAccessToken);
}
clearTokens();
for (uint64_t i = 0; i < newAccessTokens.size(); ++i) {
const auto ionApiUrlKey = getIonApiUrlSettingPath(i);
const auto accessTokenKey = getAccessTokenSettingPath(i);
iSettings->set(ionApiUrlKey.c_str(), newAccessTokens[i].ionApiUrl.c_str());
iSettings->set(accessTokenKey.c_str(), newAccessTokens[i].accessToken.c_str());
}
}
void clearTokens() {
const auto iSettings = carb::getCachedInterface<carb::settings::ISettings>();
for (uint64_t i = 0; i < MAX_SESSIONS; ++i) {
const auto serverKey = getIonApiUrlSettingPath(i);
const auto tokenKey = getAccessTokenSettingPath(i);
iSettings->destroyItem(serverKey.c_str());
iSettings->destroyItem(tokenKey.c_str());
}
}
uint64_t getMaxCacheItems() {
const int64_t defaultMaxCacheItems = 4096;
const auto iSettings = carb::getCachedInterface<carb::settings::ISettings>();
iSettings->setDefaultInt64(MAX_CACHE_ITEMS_PATH, defaultMaxCacheItems);
auto maxCacheItems = iSettings->getAsInt64(MAX_CACHE_ITEMS_PATH);
return static_cast<uint64_t>(maxCacheItems);
}
} // namespace cesium::omniverse::Settings
| 4,311 | C++ | 33.496 | 110 | 0.700765 |
CesiumGS/cesium-omniverse/src/core/src/LoggerSink.cpp | #include "cesium/omniverse/LoggerSink.h"
namespace cesium::omniverse {
LoggerSink::LoggerSink(omni::log::Level logLevel)
: _logLevel(logLevel) {
switch (logLevel) {
case omni::log::Level::eVerbose:
set_level(spdlog::level::trace);
break;
case omni::log::Level::eInfo:
set_level(spdlog::level::info);
break;
case omni::log::Level::eWarn:
set_level(spdlog::level::warn);
break;
case omni::log::Level::eError:
set_level(spdlog::level::err);
break;
case omni::log::Level::eFatal:
set_level(spdlog::level::critical);
break;
default:
break;
}
}
void LoggerSink::sink_it_([[maybe_unused]] const spdlog::details::log_msg& msg) {
// The reason we don't need to provide a log channel as the first argument to each of these OMNI_LOG_ functions is
// because CARB_PLUGIN_IMPL calls CARB_GLOBALS_EX which calls OMNI_GLOBALS_ADD_DEFAULT_CHANNEL and sets the channel
// name to our plugin name: cesium.omniverse.plugin
switch (_logLevel) {
case omni::log::Level::eVerbose:
OMNI_LOG_VERBOSE("%s", formatMessage(msg).c_str());
break;
case omni::log::Level::eInfo:
OMNI_LOG_INFO("%s", formatMessage(msg).c_str());
break;
case omni::log::Level::eWarn:
OMNI_LOG_WARN("%s", formatMessage(msg).c_str());
break;
case omni::log::Level::eError:
OMNI_LOG_ERROR("%s", formatMessage(msg).c_str());
break;
case omni::log::Level::eFatal:
OMNI_LOG_FATAL("%s", formatMessage(msg).c_str());
break;
default:
break;
}
}
void LoggerSink::flush_() {}
std::string LoggerSink::formatMessage(const spdlog::details::log_msg& msg) {
// Frustratingly, spdlog::formatter isn't thread safe. So even though our sink
// itself doesn't need to be protected by a mutex, the formatter does.
// See https://github.com/gabime/spdlog/issues/897
std::scoped_lock<std::mutex> lock(_formatMutex);
spdlog::memory_buf_t formatted;
formatter_->format(msg, formatted);
return fmt::to_string(formatted);
}
} // namespace cesium::omniverse
| 2,305 | C++ | 33.41791 | 119 | 0.593059 |
CesiumGS/cesium-omniverse/src/core/src/UsdNotificationHandler.cpp | #include "cesium/omniverse/UsdNotificationHandler.h"
#include "cesium/omniverse/AssetRegistry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/CppUtil.h"
#include "cesium/omniverse/FabricResourceManager.h"
#include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/OmniCartographicPolygon.h"
#include "cesium/omniverse/OmniGeoreference.h"
#include "cesium/omniverse/OmniGlobeAnchor.h"
#include "cesium/omniverse/OmniIonRasterOverlay.h"
#include "cesium/omniverse/OmniIonServer.h"
#include "cesium/omniverse/OmniPolygonRasterOverlay.h"
#include "cesium/omniverse/OmniRasterOverlay.h"
#include "cesium/omniverse/OmniTileMapServiceRasterOverlay.h"
#include "cesium/omniverse/OmniTileset.h"
#include "cesium/omniverse/OmniWebMapServiceRasterOverlay.h"
#include "cesium/omniverse/OmniWebMapTileServiceRasterOverlay.h"
#include "cesium/omniverse/UsdTokens.h"
#include "cesium/omniverse/UsdUtil.h"
#include <CesiumUsdSchemas/tokens.h>
#include <pxr/usd/usd/primRange.h>
#include <pxr/usd/usdShade/shader.h>
namespace cesium::omniverse {
namespace {
bool isPrimOrDescendant(const pxr::SdfPath& descendantPath, const pxr::SdfPath& path) {
if (descendantPath == path) {
return true;
}
for (const auto& ancestorPath : descendantPath.GetAncestorsRange()) {
if (ancestorPath == path) {
return true;
}
}
return false;
}
void updateRasterOverlayBindings(const Context& context, const pxr::SdfPath& rasterOverlayPath) {
const auto& tilesets = context.getAssetRegistry().getTilesets();
// Update tilesets that reference this raster overlay
for (const auto& pTileset : tilesets) {
if (CppUtil::contains(pTileset->getRasterOverlayPaths(), rasterOverlayPath)) {
pTileset->reload();
}
}
}
void updateRasterOverlayBindingsAlpha(const Context& context, const pxr::SdfPath& rasterOverlayPath) {
const auto& tilesets = context.getAssetRegistry().getTilesets();
// Update tilesets that reference this raster overlay
for (const auto& pTileset : tilesets) {
if (CppUtil::contains(pTileset->getRasterOverlayPaths(), rasterOverlayPath)) {
pTileset->updateRasterOverlayAlpha(rasterOverlayPath);
}
}
}
void updateIonServerBindings(const Context& context) {
// Update all tilesets. Some tilesets may have referenced this ion server implicitly.
const auto& tilesets = context.getAssetRegistry().getTilesets();
for (const auto& pTileset : tilesets) {
pTileset->reload();
}
// Update all raster overlays. Some raster overlays may have referenced this ion server implicitly.
const auto& ionRasterOverlays = context.getAssetRegistry().getIonRasterOverlays();
for (const auto& pIonRasterOverlay : ionRasterOverlays) {
pIonRasterOverlay->reload();
updateRasterOverlayBindings(context, pIonRasterOverlay->getPath());
}
}
void updateCartographicPolygonBindings(const Context& context, const pxr::SdfPath& cartographicPolygonPath) {
// Update polygon raster overlays that reference this cartographic polygon
const auto& polygonRasterOverlays = context.getAssetRegistry().getPolygonRasterOverlays();
for (const auto& pPolygonRasterOverlay : polygonRasterOverlays) {
const auto paths = pPolygonRasterOverlay->getCartographicPolygonPaths();
if (CppUtil::contains(paths, cartographicPolygonPath)) {
pPolygonRasterOverlay->reload();
updateRasterOverlayBindings(context, pPolygonRasterOverlay->getPath());
}
}
}
void updateGlobeAnchorBindings(const Context& context, const pxr::SdfPath& globeAnchorPath) {
// Don't need to update tilesets. Globe anchor changes are handled automatically in the update loop.
if (context.getAssetRegistry().getCartographicPolygon(globeAnchorPath)) {
// Update cartographic polygon that this globe anchor is attached to
updateCartographicPolygonBindings(context, globeAnchorPath);
}
}
void updateGeoreferenceBindings(const Context& context) {
// Don't need to update tilesets. Georeference changes are handled automatically in the update loop.
// Update all globe anchors. Some globe anchors may have referenced this georeference implicitly.
const auto& globeAnchors = context.getAssetRegistry().getGlobeAnchors();
for (const auto& pGlobeAnchor : globeAnchors) {
pGlobeAnchor->updateByGeoreference();
updateGlobeAnchorBindings(context, pGlobeAnchor->getPath());
}
}
bool isFirstData(const Context& context, const pxr::SdfPath& dataPath) {
const auto pData = context.getAssetRegistry().getData(dataPath);
const auto pFirstData = context.getAssetRegistry().getFirstData();
return pData && pData == pFirstData;
}
[[nodiscard]] bool processCesiumDataChanged(
const Context& context,
const pxr::SdfPath& dataPath,
const std::vector<pxr::TfToken>& properties) {
if (!isFirstData(context, dataPath)) {
return false;
}
auto reloadStage = false;
auto updateGeoreference = false;
// No change tracking needed for
// * selectedIonServer
// * projectDefaultIonAccessToken (deprecated)
// * projectDefaultIonAccessTokenId (deprecated)
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumDebugDisableMaterials ||
property == pxr::CesiumTokens->cesiumDebugDisableTextures ||
property == pxr::CesiumTokens->cesiumDebugDisableGeometryPool ||
property == pxr::CesiumTokens->cesiumDebugDisableMaterialPool ||
property == pxr::CesiumTokens->cesiumDebugDisableTexturePool ||
property == pxr::CesiumTokens->cesiumDebugGeometryPoolInitialCapacity ||
property == pxr::CesiumTokens->cesiumDebugMaterialPoolInitialCapacity ||
property == pxr::CesiumTokens->cesiumDebugTexturePoolInitialCapacity ||
property == pxr::CesiumTokens->cesiumDebugRandomColors) {
reloadStage = true;
} else if (property == pxr::CesiumTokens->cesiumDebugDisableGeoreferencing) {
updateGeoreference = true;
}
}
if (updateGeoreference) {
updateGeoreferenceBindings(context);
}
return reloadStage;
}
void processCesiumGlobeAnchorChanged(
const Context& context,
const pxr::SdfPath& globeAnchorPath,
const std::vector<pxr::TfToken>& properties) {
const auto pGlobeAnchor = context.getAssetRegistry().getGlobeAnchor(globeAnchorPath);
if (!pGlobeAnchor) {
return;
}
// No change tracking needed for
// * adjustOrientation
auto updateByGeoreference = false;
auto updateByPrimLocalTransform = false;
auto updateByGeographicCoordinates = false;
auto updateByEcefPosition = false;
auto updateBindings = false;
auto resetOrientation = false;
const auto detectTransformChanges = pGlobeAnchor->getDetectTransformChanges();
// clang-format off
for (const auto& property : properties) {
if (detectTransformChanges &&
(property == pxr::UsdTokens->xformOp_translate ||
property == pxr::UsdTokens->xformOp_rotateXYZ ||
property == pxr::UsdTokens->xformOp_rotateXZY ||
property == pxr::UsdTokens->xformOp_rotateYXZ ||
property == pxr::UsdTokens->xformOp_rotateYZX ||
property == pxr::UsdTokens->xformOp_rotateZXY ||
property == pxr::UsdTokens->xformOp_rotateZYX ||
property == pxr::UsdTokens->xformOp_orient ||
property == pxr::UsdTokens->xformOp_scale)) {
updateByPrimLocalTransform = true;
updateBindings = true;
} else if (property == pxr::CesiumTokens->cesiumAnchorLongitude ||
property == pxr::CesiumTokens->cesiumAnchorLatitude ||
property == pxr::CesiumTokens->cesiumAnchorHeight) {
updateByGeographicCoordinates = true;
updateBindings = true;
} else if (property == pxr::CesiumTokens->cesiumAnchorPosition) {
updateByEcefPosition = true;
updateBindings = true;
} else if (property == pxr::CesiumTokens->cesiumAnchorGeoreferenceBinding) {
updateByGeoreference = true;
updateBindings = true;
} else if (detectTransformChanges && property == pxr::CesiumTokens->cesiumAnchorDetectTransformChanges) {
updateByPrimLocalTransform = true;
updateBindings = true;
resetOrientation = true;
}
}
// clang-format on
if (updateByGeoreference) {
pGlobeAnchor->updateByGeoreference();
}
if (updateByEcefPosition) {
pGlobeAnchor->updateByEcefPosition();
}
if (updateByGeographicCoordinates) {
pGlobeAnchor->updateByGeographicCoordinates();
}
if (updateByPrimLocalTransform) {
pGlobeAnchor->updateByPrimLocalTransform(resetOrientation);
}
if (updateBindings) {
updateGlobeAnchorBindings(context, globeAnchorPath);
}
}
void processCesiumTilesetChanged(
const Context& context,
const pxr::SdfPath& tilesetPath,
const std::vector<pxr::TfToken>& properties) {
const auto pTileset = context.getAssetRegistry().getTileset(tilesetPath);
if (!pTileset) {
return;
}
// Process globe anchor API schema first
processCesiumGlobeAnchorChanged(context, tilesetPath, properties);
auto reload = false;
auto updateTilesetOptions = false;
auto updateDisplayColorAndOpacity = false;
// No change tracking needed for
// * suspendUpdate
// * georeferenceBinding
// * Transform changes (handled automatically in update loop)
// clang-format off
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumSourceType ||
property == pxr::CesiumTokens->cesiumUrl ||
property == pxr::CesiumTokens->cesiumIonAssetId ||
property == pxr::CesiumTokens->cesiumIonAccessToken ||
property == pxr::CesiumTokens->cesiumIonServerBinding ||
property == pxr::CesiumTokens->cesiumSmoothNormals ||
property == pxr::CesiumTokens->cesiumShowCreditsOnScreen ||
property == pxr::CesiumTokens->cesiumRasterOverlayBinding ||
property == pxr::UsdTokens->material_binding) {
reload = true;
} else if (
property == pxr::CesiumTokens->cesiumMaximumScreenSpaceError ||
property == pxr::CesiumTokens->cesiumPreloadAncestors ||
property == pxr::CesiumTokens->cesiumPreloadSiblings ||
property == pxr::CesiumTokens->cesiumForbidHoles ||
property == pxr::CesiumTokens->cesiumMaximumSimultaneousTileLoads ||
property == pxr::CesiumTokens->cesiumMaximumCachedBytes ||
property == pxr::CesiumTokens->cesiumLoadingDescendantLimit ||
property == pxr::CesiumTokens->cesiumEnableFrustumCulling ||
property == pxr::CesiumTokens->cesiumEnableFogCulling ||
property == pxr::CesiumTokens->cesiumEnforceCulledScreenSpaceError ||
property == pxr::CesiumTokens->cesiumCulledScreenSpaceError ||
property == pxr::CesiumTokens->cesiumMainThreadLoadingTimeLimit) {
updateTilesetOptions = true;
} else if (
property == pxr::UsdTokens->primvars_displayColor ||
property == pxr::UsdTokens->primvars_displayOpacity) {
updateDisplayColorAndOpacity = true;
}
}
// clang-format on
if (reload) {
pTileset->reload();
}
if (updateTilesetOptions) {
pTileset->updateTilesetOptions();
}
if (updateDisplayColorAndOpacity) {
pTileset->updateDisplayColorAndOpacity();
}
}
void processCesiumRasterOverlayChanged(
const Context& context,
const pxr::SdfPath& rasterOverlayPath,
const std::vector<pxr::TfToken>& properties) {
const auto pRasterOverlay = context.getAssetRegistry().getRasterOverlay(rasterOverlayPath);
if (!pRasterOverlay) {
return;
}
auto reload = false;
auto updateBindings = false;
auto updateRasterOverlayAlpha = false;
auto updateRasterOverlayOptions = false;
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumShowCreditsOnScreen) {
reload = true;
updateBindings = true;
} else if (property == pxr::CesiumTokens->cesiumOverlayRenderMethod) {
updateBindings = true;
} else if (property == pxr::CesiumTokens->cesiumAlpha) {
updateRasterOverlayAlpha = true;
} else if (
property == pxr::CesiumTokens->cesiumMaximumScreenSpaceError ||
property == pxr::CesiumTokens->cesiumMaximumTextureSize ||
property == pxr::CesiumTokens->cesiumMaximumSimultaneousTileLoads ||
property == pxr::CesiumTokens->cesiumSubTileCacheBytes) {
updateRasterOverlayOptions = true;
}
}
if (reload) {
pRasterOverlay->reload();
}
if (updateBindings) {
updateRasterOverlayBindings(context, rasterOverlayPath);
}
if (updateRasterOverlayAlpha) {
updateRasterOverlayBindingsAlpha(context, rasterOverlayPath);
}
if (updateRasterOverlayOptions) {
pRasterOverlay->updateRasterOverlayOptions();
}
}
void processCesiumIonRasterOverlayChanged(
const Context& context,
const pxr::SdfPath& ionRasterOverlayPath,
const std::vector<pxr::TfToken>& properties) {
const auto pIonRasterOverlay = context.getAssetRegistry().getIonRasterOverlay(ionRasterOverlayPath);
if (!pIonRasterOverlay) {
return;
}
// Process base class first
processCesiumRasterOverlayChanged(context, ionRasterOverlayPath, properties);
auto reload = false;
auto updateBindings = false;
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumIonAssetId || property == pxr::CesiumTokens->cesiumIonAccessToken ||
property == pxr::CesiumTokens->cesiumIonServerBinding) {
reload = true;
updateBindings = true;
}
}
if (reload) {
pIonRasterOverlay->reload();
}
if (updateBindings) {
updateRasterOverlayBindings(context, ionRasterOverlayPath);
}
}
void processCesiumPolygonRasterOverlayChanged(
const Context& context,
const pxr::SdfPath& polygonRasterOverlayPath,
const std::vector<pxr::TfToken>& properties) {
const auto pPolygonRasterOverlay = context.getAssetRegistry().getPolygonRasterOverlay(polygonRasterOverlayPath);
if (!pPolygonRasterOverlay) {
return;
}
// Process base class first
processCesiumRasterOverlayChanged(context, polygonRasterOverlayPath, properties);
auto reload = false;
auto updateBindings = false;
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumCartographicPolygonBinding ||
property == pxr::CesiumTokens->cesiumInvertSelection ||
property == pxr::CesiumTokens->cesiumExcludeSelectedTiles) {
reload = true;
updateBindings = true;
}
}
if (reload) {
pPolygonRasterOverlay->reload();
}
if (updateBindings) {
updateRasterOverlayBindings(context, polygonRasterOverlayPath);
}
}
void processCesiumWebMapServiceRasterOverlayChanged(
const Context& context,
const pxr::SdfPath& webMapServiceRasterOverlayPath,
const std::vector<pxr::TfToken>& properties) {
const auto pWebMapServiceRasterOverlay =
context.getAssetRegistry().getWebMapServiceRasterOverlay(webMapServiceRasterOverlayPath);
if (!pWebMapServiceRasterOverlay) {
return;
}
// Process base class first
processCesiumRasterOverlayChanged(context, webMapServiceRasterOverlayPath, properties);
auto reload = false;
auto updateBindings = false;
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumBaseUrl || property == pxr::CesiumTokens->cesiumLayers ||
property == pxr::CesiumTokens->cesiumTileWidth || property == pxr::CesiumTokens->cesiumTileHeight ||
property == pxr::CesiumTokens->cesiumMinimumLevel || property == pxr::CesiumTokens->cesiumMaximumLevel) {
reload = true;
updateBindings = true;
}
}
if (reload) {
pWebMapServiceRasterOverlay->reload();
}
if (updateBindings) {
updateRasterOverlayBindings(context, webMapServiceRasterOverlayPath);
}
}
void processCesiumTileMapServiceRasterOverlayChanged(
const Context& context,
const pxr::SdfPath& tileMapServiceRasterOverlayPath,
const std::vector<pxr::TfToken>& properties) {
const auto pTileMapServiceRasterOverlay =
context.getAssetRegistry().getTileMapServiceRasterOverlay(tileMapServiceRasterOverlayPath);
if (!pTileMapServiceRasterOverlay) {
return;
}
// Process base class first
processCesiumRasterOverlayChanged(context, tileMapServiceRasterOverlayPath, properties);
auto reload = false;
auto updateBindings = false;
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumUrl || property == pxr::CesiumTokens->cesiumMinimumZoomLevel ||
property == pxr::CesiumTokens->cesiumMaximumZoomLevel) {
reload = true;
updateBindings = true;
}
}
if (reload) {
pTileMapServiceRasterOverlay->reload();
}
if (updateBindings) {
updateRasterOverlayBindings(context, tileMapServiceRasterOverlayPath);
}
}
void processCesiumWebMapTileServiceRasterOverlayChanged(
const Context& context,
const pxr::SdfPath& webMapTileServiceRasterOverlayPath,
const std::vector<pxr::TfToken>& properties) {
const auto pWebMapTileServiceRasterOverlay =
context.getAssetRegistry().getWebMapTileServiceRasterOverlay(webMapTileServiceRasterOverlayPath);
if (!pWebMapTileServiceRasterOverlay) {
return;
}
// Process base class first
processCesiumRasterOverlayChanged(context, webMapTileServiceRasterOverlayPath, properties);
auto reload = false;
auto updateBindings = false;
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumUrl || property == pxr::CesiumTokens->cesiumLayer ||
property == pxr::CesiumTokens->cesiumStyle || property == pxr::CesiumTokens->cesiumFormat ||
property == pxr::CesiumTokens->cesiumTileMatrixSetId ||
property == pxr::CesiumTokens->cesiumSpecifyTileMatrixSetLabels ||
property == pxr::CesiumTokens->cesiumTileMatrixSetLabelPrefix ||
property == pxr::CesiumTokens->cesiumTileMatrixSetLabels ||
property == pxr::CesiumTokens->cesiumUseWebMercatorProjection ||
property == pxr::CesiumTokens->cesiumSpecifyTilingScheme ||
property == pxr::CesiumTokens->cesiumRootTilesX || property == pxr::CesiumTokens->cesiumRootTilesY ||
property == pxr::CesiumTokens->cesiumWest || property == pxr::CesiumTokens->cesiumEast ||
property == pxr::CesiumTokens->cesiumSouth || property == pxr::CesiumTokens->cesiumNorth ||
property == pxr::CesiumTokens->cesiumSpecifyZoomLevels ||
property == pxr::CesiumTokens->cesiumMinimumZoomLevel ||
property == pxr::CesiumTokens->cesiumMaximumZoomLevel) {
reload = true;
updateBindings = true;
}
}
if (reload) {
pWebMapTileServiceRasterOverlay->reload();
}
if (updateBindings) {
updateRasterOverlayBindings(context, webMapTileServiceRasterOverlayPath);
}
}
void processCesiumGeoreferenceChanged(const Context& context, const std::vector<pxr::TfToken>& properties) {
auto updateBindings = false;
// clang-format off
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumGeoreferenceOriginLongitude ||
property == pxr::CesiumTokens->cesiumGeoreferenceOriginLatitude ||
property == pxr::CesiumTokens->cesiumGeoreferenceOriginHeight) {
updateBindings = true;
}
}
// clang-format on
if (updateBindings) {
updateGeoreferenceBindings(context);
}
}
void processCesiumIonServerChanged(
Context& context,
const pxr::SdfPath& ionServerPath,
const std::vector<pxr::TfToken>& properties) {
auto reloadSession = false;
auto updateBindings = false;
// No change tracking needed for
// * displayName
// clang-format off
for (const auto& property : properties) {
if (property == pxr::CesiumTokens->cesiumIonServerUrl ||
property == pxr::CesiumTokens->cesiumIonServerApiUrl ||
property == pxr::CesiumTokens->cesiumIonServerApplicationId) {
reloadSession = true;
updateBindings = true;
} else if (
property == pxr::CesiumTokens->cesiumProjectDefaultIonAccessToken ||
property == pxr::CesiumTokens->cesiumProjectDefaultIonAccessTokenId) {
updateBindings = true;
}
}
// clang-format on
if (reloadSession) {
context.getAssetRegistry().removeIonServer(ionServerPath);
context.getAssetRegistry().addIonServer(ionServerPath);
}
if (updateBindings) {
updateIonServerBindings(context);
}
}
void processCesiumCartographicPolygonChanged(
const Context& context,
const pxr::SdfPath& cartographicPolygonPath,
const std::vector<pxr::TfToken>& properties) {
// Process globe anchor API schema first
processCesiumGlobeAnchorChanged(context, cartographicPolygonPath, properties);
auto updateBindings = false;
for (const auto& property : properties) {
if (property == pxr::UsdTokens->points) {
updateBindings = true;
}
}
if (updateBindings) {
updateCartographicPolygonBindings(context, cartographicPolygonPath);
}
}
void processUsdShaderChanged(
const Context& context,
const pxr::SdfPath& shaderPath,
const std::vector<pxr::TfToken>& properties) {
const auto usdShader = UsdUtil::getUsdShader(context.getUsdStage(), shaderPath);
const auto shaderPathFabric = FabricUtil::toFabricPath(shaderPath);
const auto materialPath = shaderPath.GetParentPath();
const auto materialPathFabric = FabricUtil::toFabricPath(materialPath);
if (!UsdUtil::isUsdMaterial(context.getUsdStage(), materialPath)) {
// Skip if parent path is not a material
return;
}
for (const auto& property : properties) {
const auto inputNamespace = std::string_view("inputs:");
const auto& attributeName = property.GetString();
if (attributeName.rfind(inputNamespace) != 0) {
// Skip if changed attribute is not a shader input
return;
}
const auto inputName = pxr::TfToken(attributeName.substr(inputNamespace.size()));
const auto shaderInput = usdShader.GetInput(inputName);
if (!shaderInput.IsDefined()) {
// Skip if changed attribute is not a shader input
return;
}
if (shaderInput.HasConnectedSource()) {
// Skip if shader input is connected to something else
return;
}
if (!FabricUtil::materialHasCesiumNodes(context.getFabricStage(), materialPathFabric)) {
// Simple materials can be skipped. We only need to handle materials that have been copied to each tile.
return;
}
if (!FabricUtil::isShaderConnectedToMaterial(context.getFabricStage(), materialPathFabric, shaderPathFabric)) {
// Skip if shader is not connected to the material
return;
}
const auto& tilesets = context.getAssetRegistry().getTilesets();
for (const auto& pTileset : tilesets) {
if (pTileset->getMaterialPath() == materialPath) {
pTileset->updateShaderInput(shaderPath, property);
}
}
context.getFabricResourceManager().updateShaderInput(materialPath, shaderPath, property);
}
}
[[nodiscard]] bool processCesiumDataRemoved(Context& context, const pxr::SdfPath& dataPath) {
const auto reloadStage = isFirstData(context, dataPath);
context.getAssetRegistry().removeData(dataPath);
return reloadStage;
}
void processCesiumTilesetRemoved(Context& context, const pxr::SdfPath& tilesetPath) {
context.getAssetRegistry().removeTileset(tilesetPath);
}
void processCesiumIonRasterOverlayRemoved(Context& context, const pxr::SdfPath& ionRasterOverlayPath) {
context.getAssetRegistry().removeIonRasterOverlay(ionRasterOverlayPath);
updateRasterOverlayBindings(context, ionRasterOverlayPath);
}
void processCesiumPolygonRasterOverlayRemoved(Context& context, const pxr::SdfPath& polygonRasterOverlayPath) {
context.getAssetRegistry().removePolygonRasterOverlay(polygonRasterOverlayPath);
updateRasterOverlayBindings(context, polygonRasterOverlayPath);
}
void processCesiumWebMapServiceRasterOverlayRemoved(
Context& context,
const pxr::SdfPath& webMapServiceRasterOverlayPath) {
context.getAssetRegistry().removeWebMapServiceRasterOverlay(webMapServiceRasterOverlayPath);
updateRasterOverlayBindings(context, webMapServiceRasterOverlayPath);
}
void processCesiumTileMapServiceRasterOverlayRemoved(
Context& context,
const pxr::SdfPath& tileMapServiceRasterOverlayPath) {
context.getAssetRegistry().removeTileMapServiceRasterOverlay(tileMapServiceRasterOverlayPath);
updateRasterOverlayBindings(context, tileMapServiceRasterOverlayPath);
}
void processCesiumWebMapTileServiceRasterOverlayRemoved(
Context& context,
const pxr::SdfPath& webMapTileServiceRasterOverlayPath) {
context.getAssetRegistry().removeWebMapServiceRasterOverlay(webMapTileServiceRasterOverlayPath);
updateRasterOverlayBindings(context, webMapTileServiceRasterOverlayPath);
}
void processCesiumGeoreferenceRemoved(Context& context, const pxr::SdfPath& georeferencePath) {
context.getAssetRegistry().removeGeoreference(georeferencePath);
updateGeoreferenceBindings(context);
}
void processCesiumGlobeAnchorRemoved(Context& context, const pxr::SdfPath& globeAnchorPath) {
context.getAssetRegistry().removeGlobeAnchor(globeAnchorPath);
updateGlobeAnchorBindings(context, globeAnchorPath);
}
void processCesiumIonServerRemoved(Context& context, const pxr::SdfPath& ionServerPath) {
context.getAssetRegistry().removeIonServer(ionServerPath);
updateIonServerBindings(context);
}
void processCesiumCartographicPolygonRemoved(Context& context, const pxr::SdfPath& cartographicPolygonPath) {
context.getAssetRegistry().removeCartographicPolygon(cartographicPolygonPath);
processCesiumGlobeAnchorRemoved(context, cartographicPolygonPath);
updateCartographicPolygonBindings(context, cartographicPolygonPath);
}
[[nodiscard]] bool processCesiumDataAdded(Context& context, const pxr::SdfPath& dataPath) {
if (context.getAssetRegistry().getData(dataPath)) {
return false;
}
context.getAssetRegistry().addData(dataPath);
return isFirstData(context, dataPath);
}
void processCesiumGlobeAnchorAdded(Context& context, const pxr::SdfPath& globeAnchorPath) {
if (context.getAssetRegistry().getGlobeAnchor(globeAnchorPath)) {
return;
}
context.getAssetRegistry().addGlobeAnchor(globeAnchorPath);
updateGlobeAnchorBindings(context, globeAnchorPath);
}
void processCesiumTilesetAdded(Context& context, const pxr::SdfPath& tilesetPath) {
if (UsdUtil::hasCesiumGlobeAnchor(context.getUsdStage(), tilesetPath)) {
processCesiumGlobeAnchorAdded(context, tilesetPath);
}
if (context.getAssetRegistry().getTileset(tilesetPath)) {
return;
}
context.getAssetRegistry().addTileset(tilesetPath);
}
void processCesiumIonRasterOverlayAdded(Context& context, const pxr::SdfPath& ionRasterOverlayPath) {
if (context.getAssetRegistry().getIonRasterOverlay(ionRasterOverlayPath)) {
return;
}
context.getAssetRegistry().addIonRasterOverlay(ionRasterOverlayPath);
updateRasterOverlayBindings(context, ionRasterOverlayPath);
}
void processCesiumPolygonRasterOverlayAdded(Context& context, const pxr::SdfPath& polygonRasterOverlayPath) {
if (context.getAssetRegistry().getPolygonRasterOverlay(polygonRasterOverlayPath)) {
return;
}
context.getAssetRegistry().addPolygonRasterOverlay(polygonRasterOverlayPath);
updateRasterOverlayBindings(context, polygonRasterOverlayPath);
}
void processCesiumWebMapServiceRasterOverlayAdded(
Context& context,
const pxr::SdfPath& webMapServiceRasterOverlayPath) {
if (context.getAssetRegistry().getWebMapServiceRasterOverlay(webMapServiceRasterOverlayPath)) {
return;
}
context.getAssetRegistry().addWebMapServiceRasterOverlay(webMapServiceRasterOverlayPath);
updateRasterOverlayBindings(context, webMapServiceRasterOverlayPath);
}
void processCesiumTileMapServiceRasterOverlayAdded(
Context& context,
const pxr::SdfPath& tileMapServiceRasterOverlayPath) {
if (context.getAssetRegistry().getTileMapServiceRasterOverlay(tileMapServiceRasterOverlayPath)) {
return;
}
context.getAssetRegistry().addTileMapServiceRasterOverlay(tileMapServiceRasterOverlayPath);
updateRasterOverlayBindings(context, tileMapServiceRasterOverlayPath);
}
void processCesiumWebMapTileServiceRasterOverlayAdded(
Context& context,
const pxr::SdfPath& webMapTileServiceRasterOverlayPath) {
if (context.getAssetRegistry().getWebMapTileServiceRasterOverlay(webMapTileServiceRasterOverlayPath)) {
return;
}
context.getAssetRegistry().addWebMapTileServiceRasterOverlay(webMapTileServiceRasterOverlayPath);
updateRasterOverlayBindings(context, webMapTileServiceRasterOverlayPath);
}
void processCesiumGeoreferenceAdded(Context& context, const pxr::SdfPath& georeferencePath) {
if (context.getAssetRegistry().getGeoreference(georeferencePath)) {
return;
}
context.getAssetRegistry().addGeoreference(georeferencePath);
updateGeoreferenceBindings(context);
}
void processCesiumIonServerAdded(Context& context, const pxr::SdfPath& ionServerPath) {
if (context.getAssetRegistry().getIonServer(ionServerPath)) {
return;
}
context.getAssetRegistry().addIonServer(ionServerPath);
updateIonServerBindings(context);
}
void processCesiumCartographicPolygonAdded(Context& context, const pxr::SdfPath& cartographicPolygonPath) {
if (UsdUtil::hasCesiumGlobeAnchor(context.getUsdStage(), cartographicPolygonPath)) {
processCesiumGlobeAnchorAdded(context, cartographicPolygonPath);
}
if (context.getAssetRegistry().getCartographicPolygon(cartographicPolygonPath)) {
return;
}
context.getAssetRegistry().addCartographicPolygon(cartographicPolygonPath);
updateCartographicPolygonBindings(context, cartographicPolygonPath);
}
} // namespace
UsdNotificationHandler::UsdNotificationHandler(Context* pContext)
: _pContext(pContext)
, _noticeListenerKey(
pxr::TfNotice::Register(pxr::TfCreateWeakPtr(this), &UsdNotificationHandler::onObjectsChanged)) {}
UsdNotificationHandler::~UsdNotificationHandler() {
pxr::TfNotice::Revoke(_noticeListenerKey);
}
void UsdNotificationHandler::onStageLoaded() {
// Insert prims manually since USD doesn't notify us about changes when the stage is first loaded
for (const auto& prim : _pContext->getUsdStage()->Traverse()) {
const auto type = getTypeFromStage(prim.GetPath());
if (type != ChangedPrimType::OTHER) {
insertAddedPrim(prim.GetPath(), type);
}
}
// Process changes immediately
processChangedPrims();
}
void UsdNotificationHandler::onUpdateFrame() {
const auto reloadStage = processChangedPrims();
if (reloadStage) {
_pContext->reloadStage();
}
}
void UsdNotificationHandler::clear() {
_changedPrims.clear();
}
bool UsdNotificationHandler::processChangedPrims() {
std::vector<ChangedPrim> consolidatedChangedPrims;
ChangedPrim* pPrevious = nullptr;
for (const auto& changedPrim : _changedPrims) {
if (pPrevious && changedPrim.primPath == pPrevious->primPath) {
if (pPrevious->changedType == ChangedType::PRIM_ADDED &&
changedPrim.changedType == ChangedType::PROPERTY_CHANGED) {
// Ignore property changes that occur immediately after the prim is added. This avoids unecessary churn.
continue;
}
if (pPrevious->changedType == ChangedType::PROPERTY_CHANGED &&
changedPrim.changedType == ChangedType::PROPERTY_CHANGED) {
// Consolidate property changes so that they can be processed together
CppUtil::append(pPrevious->properties, changedPrim.properties);
continue;
}
}
consolidatedChangedPrims.push_back(changedPrim);
pPrevious = &consolidatedChangedPrims.back();
}
_changedPrims.clear();
auto reloadStage = false;
for (const auto& changedPrim : consolidatedChangedPrims) {
reloadStage = processChangedPrim(changedPrim) || reloadStage;
}
// Process newly added changes
if (!_changedPrims.empty()) {
reloadStage = processChangedPrims() || reloadStage;
}
return reloadStage;
}
bool UsdNotificationHandler::processChangedPrim(const ChangedPrim& changedPrim) const {
auto reloadStage = false;
switch (changedPrim.changedType) {
case ChangedType::PROPERTY_CHANGED:
switch (changedPrim.primType) {
case ChangedPrimType::CESIUM_DATA:
reloadStage = processCesiumDataChanged(*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_TILESET:
processCesiumTilesetChanged(*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_ION_RASTER_OVERLAY:
processCesiumIonRasterOverlayChanged(*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_POLYGON_RASTER_OVERLAY:
processCesiumPolygonRasterOverlayChanged(*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_WEB_MAP_SERVICE_RASTER_OVERLAY:
processCesiumWebMapServiceRasterOverlayChanged(
*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_TILE_MAP_SERVICE_RASTER_OVERLAY:
processCesiumTileMapServiceRasterOverlayChanged(
*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_WEB_MAP_TILE_SERVICE_RASTER_OVERLAY:
processCesiumWebMapTileServiceRasterOverlayChanged(
*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_GEOREFERENCE:
processCesiumGeoreferenceChanged(*_pContext, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_GLOBE_ANCHOR:
processCesiumGlobeAnchorChanged(*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_ION_SERVER:
processCesiumIonServerChanged(*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::CESIUM_CARTOGRAPHIC_POLYGON:
processCesiumCartographicPolygonChanged(*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::USD_SHADER:
processUsdShaderChanged(*_pContext, changedPrim.primPath, changedPrim.properties);
break;
case ChangedPrimType::OTHER:
break;
}
break;
case ChangedType::PRIM_ADDED:
switch (changedPrim.primType) {
case ChangedPrimType::CESIUM_DATA:
reloadStage = processCesiumDataAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_TILESET:
processCesiumTilesetAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_ION_RASTER_OVERLAY:
processCesiumIonRasterOverlayAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_POLYGON_RASTER_OVERLAY:
processCesiumPolygonRasterOverlayAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_WEB_MAP_SERVICE_RASTER_OVERLAY:
processCesiumWebMapServiceRasterOverlayAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_TILE_MAP_SERVICE_RASTER_OVERLAY:
processCesiumTileMapServiceRasterOverlayAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_WEB_MAP_TILE_SERVICE_RASTER_OVERLAY:
processCesiumWebMapTileServiceRasterOverlayAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_GEOREFERENCE:
processCesiumGeoreferenceAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_GLOBE_ANCHOR:
processCesiumGlobeAnchorAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_ION_SERVER:
processCesiumIonServerAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_CARTOGRAPHIC_POLYGON:
processCesiumCartographicPolygonAdded(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::USD_SHADER:
case ChangedPrimType::OTHER:
break;
}
break;
case ChangedType::PRIM_REMOVED:
switch (changedPrim.primType) {
case ChangedPrimType::CESIUM_DATA:
reloadStage = processCesiumDataRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_TILESET:
processCesiumTilesetRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_ION_RASTER_OVERLAY:
processCesiumIonRasterOverlayRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_POLYGON_RASTER_OVERLAY:
processCesiumPolygonRasterOverlayRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_WEB_MAP_SERVICE_RASTER_OVERLAY:
processCesiumWebMapServiceRasterOverlayRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_TILE_MAP_SERVICE_RASTER_OVERLAY:
processCesiumTileMapServiceRasterOverlayRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_WEB_MAP_TILE_SERVICE_RASTER_OVERLAY:
processCesiumWebMapTileServiceRasterOverlayRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_GEOREFERENCE:
processCesiumGeoreferenceRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_GLOBE_ANCHOR:
processCesiumGlobeAnchorRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_ION_SERVER:
processCesiumIonServerRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::CESIUM_CARTOGRAPHIC_POLYGON:
processCesiumCartographicPolygonRemoved(*_pContext, changedPrim.primPath);
break;
case ChangedPrimType::USD_SHADER:
case ChangedPrimType::OTHER:
break;
}
break;
}
return reloadStage;
}
void UsdNotificationHandler::onObjectsChanged(const pxr::UsdNotice::ObjectsChanged& objectsChanged) {
if (!_pContext->hasUsdStage()) {
return;
}
const auto resyncedPaths = objectsChanged.GetResyncedPaths();
for (const auto& path : resyncedPaths) {
if (path.IsPrimPath()) {
if (UsdUtil::primExists(_pContext->getUsdStage(), path)) {
// A prim is resynced when it is added to the stage or when an API schema is applied to it, e.g. when
// a material or globe anchor is assigned to a tileset for the first time. We let onPrimAdded get
// called potentially multiple times so that API schemas can be registered. There are checks later
// that prevent the prim from being added to the asset registry twice.
onPrimAdded(path);
} else {
onPrimRemoved(path);
}
} else if (path.IsPropertyPath()) {
onPropertyChanged(path);
}
}
const auto changedPaths = objectsChanged.GetChangedInfoOnlyPaths();
for (const auto& path : changedPaths) {
if (path.IsPropertyPath()) {
onPropertyChanged(path);
}
}
}
void UsdNotificationHandler::onPrimAdded(const pxr::SdfPath& primPath) {
const auto type = getTypeFromStage(primPath);
if (type != ChangedPrimType::OTHER) {
insertAddedPrim(primPath, type);
}
// USD only notifies us about the top-most prim being added. Find all descendant prims
// and add those as well (recursively)
const auto prim = _pContext->getUsdStage()->GetPrimAtPath(primPath);
for (const auto& child : prim.GetAllChildren()) {
onPrimAdded(child.GetPath());
}
}
void UsdNotificationHandler::onPrimRemoved(const pxr::SdfPath& primPath) {
// USD only notifies us about the top-most prim being removed. Find all descendant prims
// and remove those as well. Since the prims no longer exist on the stage we need
// to look the paths in _changedPrims and the asset registry.
// Remove prims that haven't been added to asset registry yet
// This needs to be an index-based for loop since _changedPrims can grow in size
const auto changedPrimsCount = _changedPrims.size();
for (uint64_t i = 0; i < changedPrimsCount; ++i) {
if (_changedPrims[i].changedType == ChangedType::PRIM_ADDED) {
if (isPrimOrDescendant(_changedPrims[i].primPath, primPath)) {
insertRemovedPrim(_changedPrims[i].primPath, _changedPrims[i].primType);
}
}
}
// Remove prims in the asset registry
const auto& tilesets = _pContext->getAssetRegistry().getTilesets();
for (const auto& pTileset : tilesets) {
const auto tilesetPath = pTileset->getPath();
if (isPrimOrDescendant(tilesetPath, primPath)) {
insertRemovedPrim(tilesetPath, ChangedPrimType::CESIUM_TILESET);
}
}
const auto& ionRasterOverlays = _pContext->getAssetRegistry().getIonRasterOverlays();
for (const auto& pIonRasterOverlay : ionRasterOverlays) {
const auto ionRasterOverlayPath = pIonRasterOverlay->getPath();
if (isPrimOrDescendant(ionRasterOverlayPath, primPath)) {
insertRemovedPrim(ionRasterOverlayPath, ChangedPrimType::CESIUM_ION_RASTER_OVERLAY);
}
}
const auto& polygonRasterOverlays = _pContext->getAssetRegistry().getPolygonRasterOverlays();
for (const auto& pPolygonRasterOverlay : polygonRasterOverlays) {
const auto polygonRasterOverlayPath = pPolygonRasterOverlay->getPath();
if (isPrimOrDescendant(polygonRasterOverlayPath, primPath)) {
insertRemovedPrim(polygonRasterOverlayPath, ChangedPrimType::CESIUM_POLYGON_RASTER_OVERLAY);
}
}
const auto& georeferences = _pContext->getAssetRegistry().getGeoreferences();
for (const auto& pGeoreference : georeferences) {
const auto georeferencePath = pGeoreference->getPath();
if (isPrimOrDescendant(georeferencePath, primPath)) {
insertRemovedPrim(georeferencePath, ChangedPrimType::CESIUM_GEOREFERENCE);
}
}
const auto& ionServers = _pContext->getAssetRegistry().getIonServers();
for (const auto& pIonServer : ionServers) {
const auto ionServerPath = pIonServer->getPath();
if (isPrimOrDescendant(ionServerPath, primPath)) {
insertRemovedPrim(ionServerPath, ChangedPrimType::CESIUM_ION_SERVER);
}
}
const auto& cartographicPolygons = _pContext->getAssetRegistry().getCartographicPolygons();
for (const auto& pCartographicPolygon : cartographicPolygons) {
const auto cartographicPolygonPath = pCartographicPolygon->getPath();
if (isPrimOrDescendant(cartographicPolygonPath, primPath)) {
insertRemovedPrim(cartographicPolygonPath, ChangedPrimType::CESIUM_CARTOGRAPHIC_POLYGON);
}
}
const auto& globeAnchors = _pContext->getAssetRegistry().getGlobeAnchors();
for (const auto& pGlobeAnchor : globeAnchors) {
const auto globeAnchorPath = pGlobeAnchor->getPath();
const auto type = getTypeFromAssetRegistry(globeAnchorPath);
if (type == ChangedPrimType::CESIUM_GLOBE_ANCHOR) {
// Make sure it's not one of the types previously handled (e.g. cartographic polygon or tileset)
if (isPrimOrDescendant(globeAnchorPath, primPath)) {
insertRemovedPrim(globeAnchorPath, ChangedPrimType::CESIUM_GLOBE_ANCHOR);
}
}
}
}
void UsdNotificationHandler::onPropertyChanged(const pxr::SdfPath& propertyPath) {
const auto& propertyName = propertyPath.GetNameToken();
const auto primPath = propertyPath.GetPrimPath();
const auto type = getTypeFromStage(primPath);
if (type != ChangedPrimType::OTHER) {
insertPropertyChanged(primPath, type, propertyName);
}
}
void UsdNotificationHandler::insertAddedPrim(const pxr::SdfPath& primPath, ChangedPrimType primType) {
// In C++ 20 this can be emplace_back without the {}
_changedPrims.push_back({primPath, {}, primType, ChangedType::PRIM_ADDED});
}
void UsdNotificationHandler::insertRemovedPrim(const pxr::SdfPath& primPath, ChangedPrimType primType) {
// In C++ 20 this can be emplace_back without the {}
_changedPrims.push_back({primPath, {}, primType, ChangedType::PRIM_REMOVED});
}
void UsdNotificationHandler::insertPropertyChanged(
const pxr::SdfPath& primPath,
ChangedPrimType primType,
const pxr::TfToken& propertyName) {
// In C++ 20 this can be emplace_back without the {}
_changedPrims.push_back({primPath, {propertyName}, primType, ChangedType::PROPERTY_CHANGED});
}
UsdNotificationHandler::ChangedPrimType UsdNotificationHandler::getTypeFromStage(const pxr::SdfPath& path) const {
if (UsdUtil::isCesiumData(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_DATA;
} else if (UsdUtil::isCesiumTileset(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_TILESET;
} else if (UsdUtil::isCesiumIonRasterOverlay(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_ION_RASTER_OVERLAY;
} else if (UsdUtil::isCesiumPolygonRasterOverlay(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_POLYGON_RASTER_OVERLAY;
} else if (UsdUtil::isCesiumWebMapServiceRasterOverlay(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_WEB_MAP_SERVICE_RASTER_OVERLAY;
} else if (UsdUtil::isCesiumTileMapServiceRasterOverlay(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_TILE_MAP_SERVICE_RASTER_OVERLAY;
} else if (UsdUtil::isCesiumWebMapTileServiceRasterOverlay(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_WEB_MAP_TILE_SERVICE_RASTER_OVERLAY;
} else if (UsdUtil::isCesiumGeoreference(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_GEOREFERENCE;
} else if (UsdUtil::isCesiumIonServer(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_ION_SERVER;
} else if (UsdUtil::isCesiumCartographicPolygon(_pContext->getUsdStage(), path)) {
return ChangedPrimType::CESIUM_CARTOGRAPHIC_POLYGON;
} else if (UsdUtil::isUsdShader(_pContext->getUsdStage(), path)) {
return ChangedPrimType::USD_SHADER;
} else if (UsdUtil::hasCesiumGlobeAnchor(_pContext->getUsdStage(), path)) {
// Globe anchor needs to be checked last since prim types take precedence over API schemas
return ChangedPrimType::CESIUM_GLOBE_ANCHOR;
}
return ChangedPrimType::OTHER;
}
UsdNotificationHandler::ChangedPrimType
UsdNotificationHandler::getTypeFromAssetRegistry(const pxr::SdfPath& path) const {
const auto assetType = _pContext->getAssetRegistry().getAssetType(path);
switch (assetType) {
case AssetType::DATA:
return ChangedPrimType::CESIUM_DATA;
case AssetType::TILESET:
return ChangedPrimType::CESIUM_TILESET;
case AssetType::ION_RASTER_OVERLAY:
return ChangedPrimType::CESIUM_ION_RASTER_OVERLAY;
case AssetType::POLYGON_RASTER_OVERLAY:
return ChangedPrimType::CESIUM_POLYGON_RASTER_OVERLAY;
case AssetType::WEB_MAP_SERVICE_RASTER_OVERLAY:
return ChangedPrimType::CESIUM_WEB_MAP_SERVICE_RASTER_OVERLAY;
case AssetType::TILE_MAP_SERVICE_RASTER_OVERLAY:
return ChangedPrimType::CESIUM_TILE_MAP_SERVICE_RASTER_OVERLAY;
case AssetType::WEB_MAP_TILE_SERVICE_RASTER_OVERLAY:
return ChangedPrimType::CESIUM_WEB_MAP_TILE_SERVICE_RASTER_OVERLAY;
case AssetType::GEOREFERENCE:
return ChangedPrimType::CESIUM_GEOREFERENCE;
case AssetType::GLOBE_ANCHOR:
return ChangedPrimType::CESIUM_GLOBE_ANCHOR;
case AssetType::ION_SERVER:
return ChangedPrimType::CESIUM_ION_SERVER;
case AssetType::CARTOGRAPHIC_POLYGON:
return ChangedPrimType::CESIUM_CARTOGRAPHIC_POLYGON;
case AssetType::OTHER:
return ChangedPrimType::OTHER;
}
return ChangedPrimType::OTHER;
}
} // namespace cesium::omniverse
| 51,453 | C++ | 39.64297 | 120 | 0.684625 |
CesiumGS/cesium-omniverse/src/core/src/FabricGeometry.cpp | #include "cesium/omniverse/FabricGeometry.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/DataType.h"
#include "cesium/omniverse/FabricAttributesBuilder.h"
#include "cesium/omniverse/FabricMaterial.h"
#include "cesium/omniverse/FabricResourceManager.h"
#include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/FabricVertexAttributeDescriptor.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/MathUtil.h"
#include "cesium/omniverse/UsdTokens.h"
#include "cesium/omniverse/UsdUtil.h"
#include <glm/fwd.hpp>
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <CesiumGltf/Model.h>
#include <omni/fabric/FabricUSD.h>
#include <omni/fabric/SimStageWithHistory.h>
#include <pxr/base/gf/range3d.h>
namespace cesium::omniverse {
namespace {
const auto DEFAULT_DOUBLE_SIDED = false;
const auto DEFAULT_EXTENT = std::array<glm::dvec3, 2>{{glm::dvec3(0.0, 0.0, 0.0), glm::dvec3(0.0, 0.0, 0.0)}};
const auto DEFAULT_POSITION = glm::dvec3(0.0, 0.0, 0.0);
const auto DEFAULT_ORIENTATION = glm::dquat(1.0, 0.0, 0.0, 0.0);
const auto DEFAULT_SCALE = glm::dvec3(1.0, 1.0, 1.0);
const auto DEFAULT_MATRIX = glm::dmat4(1.0);
const auto DEFAULT_VISIBILITY = false;
template <DataType T>
void setVertexAttributeValues(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const FabricVertexAttributeDescriptor& attribute,
uint64_t repeat) {
const auto accessor = GltfUtil::getVertexAttributeValues<T>(model, primitive, attribute.gltfAttributeName);
fabricStage.setArrayAttributeSize(path, attribute.fabricAttributeName, accessor.size() * repeat);
const auto fabricValues =
fabricStage.getArrayAttributeWr<DataTypeUtil::GetNativeType<DataTypeUtil::getPrimvarType<T>()>>(
path, attribute.fabricAttributeName);
accessor.fill(fabricValues, repeat);
}
} // namespace
FabricGeometry::FabricGeometry(
Context* pContext,
const omni::fabric::Path& path,
const FabricGeometryDescriptor& geometryDescriptor,
int64_t poolId)
: _pContext(pContext)
, _path(path)
, _geometryDescriptor(geometryDescriptor)
, _poolId(poolId)
, _stageId(pContext->getUsdStageId()) {
if (stageDestroyed()) {
return;
}
initialize();
reset();
}
FabricGeometry::~FabricGeometry() {
if (stageDestroyed()) {
return;
}
FabricUtil::destroyPrim(_pContext->getFabricStage(), _path);
}
void FabricGeometry::setActive(bool active) {
if (stageDestroyed()) {
return;
}
if (!active) {
reset();
}
}
void FabricGeometry::setVisibility(bool visible) {
if (stageDestroyed()) {
return;
}
auto& fabricStage = _pContext->getFabricStage();
const auto worldVisibilityFabric = fabricStage.getAttributeWr<bool>(_path, FabricTokens::_worldVisibility);
*worldVisibilityFabric = visible;
}
const omni::fabric::Path& FabricGeometry::getPath() const {
return _path;
}
const FabricGeometryDescriptor& FabricGeometry::getGeometryDescriptor() const {
return _geometryDescriptor;
}
int64_t FabricGeometry::getPoolId() const {
return _poolId;
}
void FabricGeometry::setMaterial(const omni::fabric::Path& materialPath) {
if (stageDestroyed()) {
return;
}
auto& fabricStage = _pContext->getFabricStage();
fabricStage.setArrayAttributeSize(_path, FabricTokens::material_binding, 1);
const auto materialBindingFabric =
fabricStage.getArrayAttributeWr<omni::fabric::PathC>(_path, FabricTokens::material_binding);
materialBindingFabric[0] = materialPath;
}
void FabricGeometry::initialize() {
const auto hasNormals = _geometryDescriptor.hasNormals();
const auto hasVertexColors = _geometryDescriptor.hasVertexColors();
const auto texcoordSetCount = _geometryDescriptor.getTexcoordSetCount();
const auto& customVertexAttributes = _geometryDescriptor.getCustomVertexAttributes();
const auto customVertexAttributesCount = customVertexAttributes.size();
const auto hasVertexIds = _geometryDescriptor.hasVertexIds();
auto& fabricStage = _pContext->getFabricStage();
fabricStage.createPrim(_path);
// clang-format off
FabricAttributesBuilder attributes(_pContext);
attributes.addAttribute(FabricTypes::faceVertexCounts, FabricTokens::faceVertexCounts);
attributes.addAttribute(FabricTypes::faceVertexIndices, FabricTokens::faceVertexIndices);
attributes.addAttribute(FabricTypes::points, FabricTokens::points);
attributes.addAttribute(FabricTypes::extent, FabricTokens::extent);
attributes.addAttribute(FabricTypes::_worldExtent, FabricTokens::_worldExtent);
attributes.addAttribute(FabricTypes::_worldVisibility, FabricTokens::_worldVisibility);
attributes.addAttribute(FabricTypes::primvars, FabricTokens::primvars);
attributes.addAttribute(FabricTypes::primvarInterpolations, FabricTokens::primvarInterpolations);
attributes.addAttribute(FabricTypes::Mesh, FabricTokens::Mesh);
attributes.addAttribute(FabricTypes::_cesium_tilesetId, FabricTokens::_cesium_tilesetId);
attributes.addAttribute(FabricTypes::_cesium_gltfLocalToEcefTransform, FabricTokens::_cesium_gltfLocalToEcefTransform);
attributes.addAttribute(FabricTypes::_worldPosition, FabricTokens::_worldPosition);
attributes.addAttribute(FabricTypes::_worldOrientation, FabricTokens::_worldOrientation);
attributes.addAttribute(FabricTypes::_worldScale, FabricTokens::_worldScale);
attributes.addAttribute(FabricTypes::doubleSided, FabricTokens::doubleSided);
attributes.addAttribute(FabricTypes::subdivisionScheme, FabricTokens::subdivisionScheme);
attributes.addAttribute(FabricTypes::material_binding, FabricTokens::material_binding);
// clang-format on
for (uint64_t i = 0; i < texcoordSetCount; ++i) {
attributes.addAttribute(FabricTypes::primvars_st, FabricTokens::primvars_st_n(i));
}
if (hasNormals) {
attributes.addAttribute(FabricTypes::primvars_normals, FabricTokens::primvars_normals);
}
if (hasVertexColors) {
attributes.addAttribute(FabricTypes::primvars_COLOR_0, FabricTokens::primvars_COLOR_0);
}
if (hasVertexIds) {
attributes.addAttribute(FabricTypes::primvars_vertexId, FabricTokens::primvars_vertexId);
}
for (const auto& customVertexAttribute : customVertexAttributes) {
attributes.addAttribute(
FabricUtil::getPrimvarType(customVertexAttribute.type), customVertexAttribute.fabricAttributeName);
}
attributes.createAttributes(_path);
const auto subdivisionSchemeFabric =
fabricStage.getAttributeWr<omni::fabric::TokenC>(_path, FabricTokens::subdivisionScheme);
*subdivisionSchemeFabric = FabricTokens::none;
// Initialize primvars
uint64_t primvarsCount = 0;
uint64_t primvarIndexNormal = 0;
uint64_t primvarIndexVertexColor = 0;
uint64_t primvarIndexVertexId = 0;
std::vector<uint64_t> primvarIndexStArray;
primvarIndexStArray.reserve(texcoordSetCount);
for (uint64_t i = 0; i < texcoordSetCount; ++i) {
primvarIndexStArray.push_back(primvarsCount++);
}
std::vector<uint64_t> primvarIndexCustomVertexAttributesArray;
primvarIndexCustomVertexAttributesArray.reserve(customVertexAttributesCount);
for (uint64_t i = 0; i < customVertexAttributesCount; ++i) {
primvarIndexCustomVertexAttributesArray.push_back(primvarsCount++);
}
if (hasNormals) {
primvarIndexNormal = primvarsCount++;
}
if (hasVertexColors) {
primvarIndexVertexColor = primvarsCount++;
}
if (hasVertexIds) {
primvarIndexVertexId = primvarsCount++;
}
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars, primvarsCount);
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvarInterpolations, primvarsCount);
// clang-format off
const auto primvarsFabric = fabricStage.getArrayAttributeWr<omni::fabric::TokenC>(_path, FabricTokens::primvars);
const auto primvarInterpolationsFabric = fabricStage.getArrayAttributeWr<omni::fabric::TokenC>(_path, FabricTokens::primvarInterpolations);
// clang-format on
for (uint64_t i = 0; i < texcoordSetCount; ++i) {
primvarsFabric[primvarIndexStArray[i]] = FabricTokens::primvars_st_n(i);
primvarInterpolationsFabric[primvarIndexStArray[i]] = FabricTokens::vertex;
}
for (uint64_t i = 0; i < customVertexAttributesCount; ++i) {
const auto& customVertexAttribute = CppUtil::getElementByIndex(customVertexAttributes, i);
primvarsFabric[primvarIndexCustomVertexAttributesArray[i]] = customVertexAttribute.fabricAttributeName;
primvarInterpolationsFabric[primvarIndexCustomVertexAttributesArray[i]] = FabricTokens::vertex;
}
if (hasNormals) {
primvarsFabric[primvarIndexNormal] = FabricTokens::primvars_normals;
primvarInterpolationsFabric[primvarIndexNormal] = FabricTokens::vertex;
}
if (hasVertexColors) {
primvarsFabric[primvarIndexVertexColor] = FabricTokens::primvars_COLOR_0;
primvarInterpolationsFabric[primvarIndexVertexColor] = FabricTokens::vertex;
}
if (hasVertexIds) {
primvarsFabric[primvarIndexVertexId] = FabricTokens::primvars_vertexId;
primvarInterpolationsFabric[primvarIndexVertexId] = FabricTokens::vertex;
}
}
void FabricGeometry::reset() {
const auto hasNormals = _geometryDescriptor.hasNormals();
const auto hasVertexColors = _geometryDescriptor.hasVertexColors();
const auto texcoordSetCount = _geometryDescriptor.getTexcoordSetCount();
const auto& customVertexAttributes = _geometryDescriptor.getCustomVertexAttributes();
const auto hasVertexIds = _geometryDescriptor.hasVertexIds();
auto& fabricStage = _pContext->getFabricStage();
// clang-format off
const auto doubleSidedFabric = fabricStage.getAttributeWr<bool>(_path, FabricTokens::doubleSided);
const auto extentFabric = fabricStage.getAttributeWr<pxr::GfRange3d>(_path, FabricTokens::extent);
const auto worldExtentFabric = fabricStage.getAttributeWr<pxr::GfRange3d>(_path, FabricTokens::_worldExtent);
const auto worldVisibilityFabric = fabricStage.getAttributeWr<bool>(_path, FabricTokens::_worldVisibility);
const auto gltfLocalToEcefTransformFabric = fabricStage.getAttributeWr<pxr::GfMatrix4d>(_path, FabricTokens::_cesium_gltfLocalToEcefTransform);
const auto worldPositionFabric = fabricStage.getAttributeWr<pxr::GfVec3d>(_path, FabricTokens::_worldPosition);
const auto worldOrientationFabric = fabricStage.getAttributeWr<pxr::GfQuatf>(_path, FabricTokens::_worldOrientation);
const auto worldScaleFabric = fabricStage.getAttributeWr<pxr::GfVec3f>(_path, FabricTokens::_worldScale);
const auto tilesetIdFabric = fabricStage.getAttributeWr<int64_t>(_path, FabricTokens::_cesium_tilesetId);
// clang-format on
*doubleSidedFabric = DEFAULT_DOUBLE_SIDED;
*extentFabric = UsdUtil::glmToUsdExtent(DEFAULT_EXTENT);
*worldExtentFabric = UsdUtil::glmToUsdExtent(DEFAULT_EXTENT);
*worldVisibilityFabric = DEFAULT_VISIBILITY;
*gltfLocalToEcefTransformFabric = UsdUtil::glmToUsdMatrix(DEFAULT_MATRIX);
*worldPositionFabric = UsdUtil::glmToUsdVector(DEFAULT_POSITION);
*worldOrientationFabric = UsdUtil::glmToUsdQuat(glm::fquat(DEFAULT_ORIENTATION));
*worldScaleFabric = UsdUtil::glmToUsdVector(glm::fvec3(DEFAULT_SCALE));
*tilesetIdFabric = FabricUtil::NO_TILESET_ID;
fabricStage.setArrayAttributeSize(_path, FabricTokens::material_binding, 0);
fabricStage.setArrayAttributeSize(_path, FabricTokens::faceVertexCounts, 0);
fabricStage.setArrayAttributeSize(_path, FabricTokens::faceVertexIndices, 0);
fabricStage.setArrayAttributeSize(_path, FabricTokens::points, 0);
for (uint64_t i = 0; i < texcoordSetCount; ++i) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_st_n(i), 0);
}
for (const auto& customVertexAttribute : customVertexAttributes) {
fabricStage.setArrayAttributeSize(_path, customVertexAttribute.fabricAttributeName, 0);
}
if (hasNormals) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_normals, 0);
}
if (hasVertexColors) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_COLOR_0, 0);
}
if (hasVertexIds) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_vertexId, 0);
}
}
void FabricGeometry::setGeometry(
int64_t tilesetId,
const glm::dmat4& ecefToPrimWorldTransform,
const glm::dmat4& gltfLocalToEcefTransform,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const FabricMaterialInfo& materialInfo,
bool smoothNormals,
const std::unordered_map<uint64_t, uint64_t>& texcoordIndexMapping,
const std::unordered_map<uint64_t, uint64_t>& rasterOverlayTexcoordIndexMapping) {
if (stageDestroyed()) {
return;
}
const auto hasNormals = _geometryDescriptor.hasNormals();
const auto hasVertexColors = _geometryDescriptor.hasVertexColors();
const auto& customVertexAttributes = _geometryDescriptor.getCustomVertexAttributes();
const auto hasVertexIds = _geometryDescriptor.hasVertexIds();
auto& fabricStage = _pContext->getFabricStage();
const auto positions = GltfUtil::getPositions(model, primitive);
const auto indices = GltfUtil::getIndices(model, primitive, positions);
const auto normals = GltfUtil::getNormals(model, primitive, positions, indices, smoothNormals);
const auto vertexColors = GltfUtil::getVertexColors(model, primitive, 0);
const auto vertexIds = GltfUtil::getVertexIds(positions);
const auto gltfLocalExtent = GltfUtil::getExtent(model, primitive);
const auto faceVertexCounts = GltfUtil::getFaceVertexCounts(indices);
if (positions.size() == 0 || indices.size() == 0 || !gltfLocalExtent.has_value()) {
return;
}
const auto doubleSided = materialInfo.doubleSided;
const auto gltfLocalToPrimWorldTransform = ecefToPrimWorldTransform * gltfLocalToEcefTransform;
const auto [primWorldPosition, primWorldOrientation, primWorldScale] =
MathUtil::decompose(gltfLocalToPrimWorldTransform);
const auto primWorldExtent = MathUtil::transformExtent(gltfLocalExtent.value(), gltfLocalToPrimWorldTransform);
if (primitive.mode == CesiumGltf::MeshPrimitive::Mode::POINTS) {
const auto numVoxels = positions.size();
const auto shapeHalfSize = 1.5f;
fabricStage.setArrayAttributeSize(_path, FabricTokens::points, numVoxels * 8);
fabricStage.setArrayAttributeSize(_path, FabricTokens::faceVertexCounts, numVoxels * 2 * 6);
fabricStage.setArrayAttributeSize(_path, FabricTokens::faceVertexIndices, numVoxels * 6 * 2 * 3);
const auto pointsFabric = fabricStage.getArrayAttributeWr<glm::fvec3>(_path, FabricTokens::points);
const auto faceVertexCountsFabric = fabricStage.getArrayAttributeWr<int>(_path, FabricTokens::faceVertexCounts);
const auto faceVertexIndicesFabric =
fabricStage.getArrayAttributeWr<int>(_path, FabricTokens::faceVertexIndices);
if (hasVertexColors) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_COLOR_0, numVoxels * 8);
const auto vertexColorsFabric =
fabricStage.getArrayAttributeWr<glm::fvec4>(_path, FabricTokens::primvars_COLOR_0);
vertexColors.fill(vertexColorsFabric, 8);
}
if (hasVertexIds) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_vertexId, numVoxels * 8);
const auto vertexIdsFabric = fabricStage.getArrayAttributeWr<float>(_path, FabricTokens::primvars_vertexId);
vertexIds.fill(vertexIdsFabric, 8);
}
for (const auto& customVertexAttribute : customVertexAttributes) {
CALL_TEMPLATED_FUNCTION_WITH_RUNTIME_DATA_TYPE(
setVertexAttributeValues,
customVertexAttribute.type,
fabricStage,
_path,
model,
primitive,
customVertexAttribute,
uint64_t(8));
}
uint64_t vertIndex = 0;
uint64_t vertexCountsIndex = 0;
uint64_t faceVertexIndex = 0;
for (uint64_t voxelIndex = 0; voxelIndex < numVoxels; ++voxelIndex) {
const auto& center = positions.get(voxelIndex);
pointsFabric[vertIndex++] = glm::fvec3{-shapeHalfSize, -shapeHalfSize, -shapeHalfSize} + center;
pointsFabric[vertIndex++] = glm::fvec3{-shapeHalfSize, shapeHalfSize, -shapeHalfSize} + center;
pointsFabric[vertIndex++] = glm::fvec3{shapeHalfSize, shapeHalfSize, -shapeHalfSize} + center;
pointsFabric[vertIndex++] = glm::fvec3{shapeHalfSize, -shapeHalfSize, -shapeHalfSize} + center;
pointsFabric[vertIndex++] = glm::fvec3{-shapeHalfSize, -shapeHalfSize, shapeHalfSize} + center;
pointsFabric[vertIndex++] = glm::fvec3{-shapeHalfSize, shapeHalfSize, shapeHalfSize} + center;
pointsFabric[vertIndex++] = glm::fvec3{shapeHalfSize, shapeHalfSize, shapeHalfSize} + center;
pointsFabric[vertIndex++] = glm::fvec3{shapeHalfSize, -shapeHalfSize, shapeHalfSize} + center;
for (int i = 0; i < 6; ++i) {
faceVertexCountsFabric[vertexCountsIndex++] = 3;
faceVertexCountsFabric[vertexCountsIndex++] = 3;
}
// front
faceVertexIndicesFabric[faceVertexIndex++] = 0 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 1 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 2 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 0 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 2 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 3 + static_cast<int>(voxelIndex * 8);
// left
faceVertexIndicesFabric[faceVertexIndex++] = 4 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 5 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 1 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 4 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 1 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 0 + static_cast<int>(voxelIndex * 8);
// right
faceVertexIndicesFabric[faceVertexIndex++] = 3 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 2 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 6 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 3 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 6 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 7 + static_cast<int>(voxelIndex * 8);
// top
faceVertexIndicesFabric[faceVertexIndex++] = 1 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 5 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 6 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 1 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 5 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 2 + static_cast<int>(voxelIndex * 8);
// bottom
faceVertexIndicesFabric[faceVertexIndex++] = 3 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 7 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 4 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 3 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 4 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 0 + static_cast<int>(voxelIndex * 8);
// back
faceVertexIndicesFabric[faceVertexIndex++] = 7 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 6 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 5 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 7 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 5 + static_cast<int>(voxelIndex * 8);
faceVertexIndicesFabric[faceVertexIndex++] = 4 + static_cast<int>(voxelIndex * 8);
}
} else {
fabricStage.setArrayAttributeSize(_path, FabricTokens::faceVertexCounts, faceVertexCounts.size());
fabricStage.setArrayAttributeSize(_path, FabricTokens::faceVertexIndices, indices.size());
fabricStage.setArrayAttributeSize(_path, FabricTokens::points, positions.size());
const auto faceVertexCountsFabric = fabricStage.getArrayAttributeWr<int>(_path, FabricTokens::faceVertexCounts);
const auto faceVertexIndicesFabric =
fabricStage.getArrayAttributeWr<int>(_path, FabricTokens::faceVertexIndices);
const auto pointsFabric = fabricStage.getArrayAttributeWr<glm::fvec3>(_path, FabricTokens::points);
faceVertexCounts.fill(faceVertexCountsFabric);
indices.fill(faceVertexIndicesFabric);
positions.fill(pointsFabric);
const auto fillTexcoords = [this, &fabricStage](uint64_t texcoordIndex, const TexcoordsAccessor& texcoords) {
assert(texcoordIndex < _geometryDescriptor.getTexcoordSetCount());
const auto& primvarStToken = FabricTokens::primvars_st_n(texcoordIndex);
fabricStage.setArrayAttributeSize(_path, primvarStToken, texcoords.size());
const auto stFabric = fabricStage.getArrayAttributeWr<glm::fvec2>(_path, primvarStToken);
texcoords.fill(stFabric);
};
for (const auto& [gltfSetIndex, primvarStIndex] : texcoordIndexMapping) {
const auto texcoords = GltfUtil::getTexcoords(model, primitive, gltfSetIndex);
fillTexcoords(primvarStIndex, texcoords);
}
for (const auto& [gltfSetIndex, primvarStIndex] : rasterOverlayTexcoordIndexMapping) {
const auto texcoords = GltfUtil::getRasterOverlayTexcoords(model, primitive, gltfSetIndex);
fillTexcoords(primvarStIndex, texcoords);
}
if (hasNormals) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_normals, normals.size());
const auto normalsFabric =
fabricStage.getArrayAttributeWr<glm::fvec3>(_path, FabricTokens::primvars_normals);
normals.fill(normalsFabric);
}
if (hasVertexColors) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_COLOR_0, vertexColors.size());
const auto vertexColorsFabric =
fabricStage.getArrayAttributeWr<glm::fvec4>(_path, FabricTokens::primvars_COLOR_0);
vertexColors.fill(vertexColorsFabric);
}
if (hasVertexIds) {
fabricStage.setArrayAttributeSize(_path, FabricTokens::primvars_vertexId, vertexIds.size());
const auto vertexIdsFabric = fabricStage.getArrayAttributeWr<float>(_path, FabricTokens::primvars_vertexId);
vertexIds.fill(vertexIdsFabric);
}
for (const auto& customVertexAttribute : customVertexAttributes) {
CALL_TEMPLATED_FUNCTION_WITH_RUNTIME_DATA_TYPE(
setVertexAttributeValues,
customVertexAttribute.type,
fabricStage,
_path,
model,
primitive,
customVertexAttribute,
uint64_t(1));
}
}
// clang-format off
const auto doubleSidedFabric = fabricStage.getAttributeWr<bool>(_path, FabricTokens::doubleSided);
const auto extentFabric = fabricStage.getAttributeWr<pxr::GfRange3d>(_path, FabricTokens::extent);
const auto worldExtentFabric = fabricStage.getAttributeWr<pxr::GfRange3d>(_path, FabricTokens::_worldExtent);
const auto gltfLocalToEcefTransformFabric = fabricStage.getAttributeWr<pxr::GfMatrix4d>(_path, FabricTokens::_cesium_gltfLocalToEcefTransform);
const auto worldPositionFabric = fabricStage.getAttributeWr<pxr::GfVec3d>(_path, FabricTokens::_worldPosition);
const auto worldOrientationFabric = fabricStage.getAttributeWr<pxr::GfQuatf>(_path, FabricTokens::_worldOrientation);
const auto worldScaleFabric = fabricStage.getAttributeWr<pxr::GfVec3f>(_path, FabricTokens::_worldScale);
const auto tilesetIdFabric = fabricStage.getAttributeWr<int64_t>(_path, FabricTokens::_cesium_tilesetId);
// clang-format on
*doubleSidedFabric = doubleSided;
*extentFabric = UsdUtil::glmToUsdExtent(gltfLocalExtent.value());
*worldExtentFabric = UsdUtil::glmToUsdExtent(primWorldExtent);
*gltfLocalToEcefTransformFabric = UsdUtil::glmToUsdMatrix(gltfLocalToEcefTransform);
*worldPositionFabric = UsdUtil::glmToUsdVector(primWorldPosition);
*worldOrientationFabric = UsdUtil::glmToUsdQuat(glm::fquat(primWorldOrientation));
*worldScaleFabric = UsdUtil::glmToUsdVector(glm::fvec3(primWorldScale));
*tilesetIdFabric = tilesetId;
}
bool FabricGeometry::stageDestroyed() {
// Tile render resources may be processed asynchronously even after the tileset and stage have been destroyed.
// Add this check to all public member functions, including constructors and destructors, to prevent them from
// modifying the stage.
return _stageId != _pContext->getUsdStageId();
}
}; // namespace cesium::omniverse
| 26,371 | C++ | 46.688969 | 147 | 0.712373 |
CesiumGS/cesium-omniverse/src/core/src/FabricUtil.cpp | #include "cesium/omniverse/FabricUtil.h"
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/DataType.h"
#include "cesium/omniverse/DataTypeUtil.h"
#include "cesium/omniverse/FabricStatistics.h"
#include "cesium/omniverse/MathUtil.h"
#include "cesium/omniverse/UsdTokens.h"
#include "cesium/omniverse/UsdUtil.h"
#include <omni/fabric/FabricUSD.h>
#include <omni/fabric/SimStageWithHistory.h>
#include <pxr/base/gf/matrix4d.h>
#include <pxr/base/gf/quatf.h>
#include <pxr/base/gf/range3d.h>
#include <pxr/base/gf/vec2f.h>
#include <pxr/base/gf/vec3f.h>
#include <spdlog/fmt/fmt.h>
#include <sstream>
namespace cesium::omniverse::FabricUtil {
namespace {
const std::string_view NO_DATA_STRING = "[No Data]";
const std::string_view TYPE_NOT_SUPPORTED_STRING = "[Type Not Supported]";
// Wraps the token type so that we can define a custom stream insertion operator
class TokenWrapper {
private:
omni::fabric::TokenC token;
public:
friend std::ostream& operator<<(std::ostream& os, const TokenWrapper& tokenWrapper);
};
std::ostream& operator<<(std::ostream& os, const TokenWrapper& tokenWrapper) {
os << omni::fabric::Token(tokenWrapper.token).getString();
return os;
}
// Wraps a boolean so that we print "true" and "false" instead of 0 and 1
class BoolWrapper {
private:
bool value;
public:
friend std::ostream& operator<<(std::ostream& os, const BoolWrapper& boolWrapper);
};
std::ostream& operator<<(std::ostream& os, const BoolWrapper& boolWrapper) {
os << (boolWrapper.value ? "true" : "false");
return os;
}
class AssetWrapper {
private:
omni::fabric::AssetPath asset;
public:
friend std::ostream& operator<<(std::ostream& os, const AssetWrapper& assetWrapper);
};
std::ostream& operator<<(std::ostream& os, const AssetWrapper& assetWrapper) {
if (assetWrapper.asset.assetPath.IsEmpty()) {
os << NO_DATA_STRING;
return os;
}
os << "Asset Path: " << assetWrapper.asset.assetPath.GetText()
<< ", Resolved Path: " << assetWrapper.asset.resolvedPath.GetText();
return os;
}
template <typename T>
std::string printAttributeValue(const T* values, uint64_t elementCount, uint64_t componentCount, bool isArray) {
std::stringstream stream;
if (isArray) {
stream << "[";
}
for (uint64_t i = 0; i < elementCount; ++i) {
if (componentCount > 1) {
stream << "[";
}
for (uint64_t j = 0; j < componentCount; ++j) {
stream << values[i * componentCount + j];
if (j < componentCount - 1) {
stream << ",";
}
}
if (componentCount > 1) {
stream << "]";
}
if (elementCount > 1 && i < elementCount - 1) {
stream << ",";
}
}
if (isArray) {
stream << "]";
}
return stream.str();
}
template <bool IsArray, typename BaseType, uint64_t ComponentCount>
std::string printAttributeValue(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& primPath,
const omni::fabric::Token& attributeName,
const omni::fabric::AttributeRole& role) {
using ElementType = std::array<BaseType, ComponentCount>;
if constexpr (IsArray) {
const auto values = fabricStage.getArrayAttributeRd<ElementType>(primPath, attributeName);
const auto elementCount = values.size();
if (elementCount == 0) {
return std::string(NO_DATA_STRING);
}
const auto valuesPtr = values.front().data();
if (role == omni::fabric::AttributeRole::eText) {
return std::string(reinterpret_cast<const char*>(valuesPtr), elementCount);
}
return printAttributeValue<BaseType>(valuesPtr, elementCount, ComponentCount, true);
} else {
const auto pValue = fabricStage.getAttributeRd<ElementType>(primPath, attributeName);
if (!pValue) {
return std::string(NO_DATA_STRING);
}
return printAttributeValue<BaseType>(pValue->data(), 1, ComponentCount, false);
}
}
std::string printConnection(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& primPath,
const omni::fabric::Token& attributeName) {
const auto pConnection = fabricStage.getConnection(primPath, attributeName);
if (!pConnection) {
return std::string(NO_DATA_STRING);
}
const auto path = omni::fabric::Path(pConnection->path).getText();
const auto attrName = omni::fabric::Token(pConnection->attrName).getText();
return fmt::format("Path: {}, Attribute Name: {}", path, attrName);
}
std::string printAttributeValue(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& primPath,
const omni::fabric::AttrNameAndType& attribute) {
const auto attributeType = attribute.type;
const auto baseType = attributeType.baseType;
const auto componentCount = attributeType.componentCount;
const auto name = attribute.name;
const auto arrayDepth = attributeType.arrayDepth;
const auto role = attributeType.role;
// This switch statement should cover most of the attribute types we expect to see on the stage.
// This includes the USD types in SdfValueTypeNames and Fabric types like assets and tokens.
// We can add more as needed.
if (arrayDepth == 0) {
switch (baseType) {
case omni::fabric::BaseDataType::eAsset:
switch (componentCount) {
case 1:
return printAttributeValue<false, AssetWrapper, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eConnection:
switch (componentCount) {
case 1:
return printConnection(fabricStage, primPath, name);
default:
break;
}
break;
case omni::fabric::BaseDataType::eToken:
switch (componentCount) {
case 1:
return printAttributeValue<false, TokenWrapper, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eBool:
switch (componentCount) {
case 1:
return printAttributeValue<false, BoolWrapper, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eUChar:
switch (componentCount) {
case 1:
return printAttributeValue<false, uint8_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eInt:
switch (componentCount) {
case 1:
return printAttributeValue<false, int32_t, 1>(fabricStage, primPath, name, role);
case 2:
return printAttributeValue<false, int32_t, 2>(fabricStage, primPath, name, role);
case 3:
return printAttributeValue<false, int32_t, 3>(fabricStage, primPath, name, role);
case 4:
return printAttributeValue<false, int32_t, 4>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eUInt:
switch (componentCount) {
case 1:
return printAttributeValue<false, uint32_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eInt64:
switch (componentCount) {
case 1:
return printAttributeValue<false, int64_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eUInt64:
switch (componentCount) {
case 1:
return printAttributeValue<false, uint64_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eFloat:
switch (componentCount) {
case 1:
return printAttributeValue<false, float, 1>(fabricStage, primPath, name, role);
case 2:
return printAttributeValue<false, float, 2>(fabricStage, primPath, name, role);
case 3:
return printAttributeValue<false, float, 3>(fabricStage, primPath, name, role);
case 4:
return printAttributeValue<false, float, 4>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eDouble:
switch (componentCount) {
case 1:
return printAttributeValue<false, double, 1>(fabricStage, primPath, name, role);
case 2:
return printAttributeValue<false, double, 2>(fabricStage, primPath, name, role);
case 3:
return printAttributeValue<false, double, 3>(fabricStage, primPath, name, role);
case 4:
return printAttributeValue<false, double, 4>(fabricStage, primPath, name, role);
case 6:
return printAttributeValue<false, double, 6>(fabricStage, primPath, name, role);
case 9:
return printAttributeValue<false, double, 9>(fabricStage, primPath, name, role);
case 16:
return printAttributeValue<false, double, 16>(fabricStage, primPath, name, role);
default:
break;
}
break;
// Due to legacy support the eRelationship type is defined as a scalar value but is secretly an array
case omni::fabric::BaseDataType::eRelationship:
switch (componentCount) {
case 1:
return printAttributeValue<true, uint64_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
default:
break;
}
} else if (arrayDepth == 1) {
switch (baseType) {
case omni::fabric::BaseDataType::eAsset:
switch (componentCount) {
case 1:
return printAttributeValue<true, AssetWrapper, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eToken:
switch (componentCount) {
case 1:
return printAttributeValue<true, TokenWrapper, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eBool:
switch (componentCount) {
case 1:
return printAttributeValue<true, BoolWrapper, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eUChar:
switch (componentCount) {
case 1:
return printAttributeValue<true, uint8_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eInt:
switch (componentCount) {
case 1:
return printAttributeValue<true, int32_t, 1>(fabricStage, primPath, name, role);
case 2:
return printAttributeValue<true, int32_t, 2>(fabricStage, primPath, name, role);
case 3:
return printAttributeValue<true, int32_t, 3>(fabricStage, primPath, name, role);
case 4:
return printAttributeValue<true, int32_t, 4>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eUInt:
switch (componentCount) {
case 1:
return printAttributeValue<true, uint32_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eInt64:
switch (componentCount) {
case 1:
return printAttributeValue<true, int64_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eUInt64:
switch (componentCount) {
case 1:
return printAttributeValue<true, uint64_t, 1>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eFloat:
switch (componentCount) {
case 1:
return printAttributeValue<true, float, 1>(fabricStage, primPath, name, role);
case 2:
return printAttributeValue<true, float, 2>(fabricStage, primPath, name, role);
case 3:
return printAttributeValue<true, float, 3>(fabricStage, primPath, name, role);
case 4:
return printAttributeValue<true, float, 4>(fabricStage, primPath, name, role);
default:
break;
}
break;
case omni::fabric::BaseDataType::eDouble:
switch (componentCount) {
case 1:
return printAttributeValue<true, double, 1>(fabricStage, primPath, name, role);
case 2:
return printAttributeValue<true, double, 2>(fabricStage, primPath, name, role);
case 3:
return printAttributeValue<true, double, 3>(fabricStage, primPath, name, role);
case 4:
return printAttributeValue<true, double, 4>(fabricStage, primPath, name, role);
case 6:
return printAttributeValue<true, double, 6>(fabricStage, primPath, name, role);
case 9:
return printAttributeValue<true, double, 9>(fabricStage, primPath, name, role);
case 16:
return printAttributeValue<true, double, 16>(fabricStage, primPath, name, role);
default:
break;
}
break;
default:
break;
}
}
return std::string(TYPE_NOT_SUPPORTED_STRING);
}
} // namespace
std::string printFabricStage(omni::fabric::StageReaderWriter& fabricStage) {
std::stringstream stream;
// For extra debugging. This gets printed to the console.
fabricStage.printBucketNames();
// This returns ALL the buckets
const auto& buckets = fabricStage.findPrims({});
for (uint64_t bucketId = 0; bucketId < buckets.bucketCount(); ++bucketId) {
const auto& attributes = fabricStage.getAttributeNamesAndTypes(buckets, bucketId);
const auto& primPaths = fabricStage.getPathArray(buckets, bucketId);
for (const auto& primPath : primPaths) {
const auto primPathString = primPath.getText();
const auto primPathUint64 = primPath.asPathC().path;
stream << fmt::format("Prim: {} ({})\n", primPathString, primPathUint64);
stream << fmt::format(" Attributes:\n");
for (const auto& attribute : attributes) {
const auto attributeName = attribute.name.getText();
const auto attributeType = attribute.type.getTypeName();
const auto attributeBaseType = attribute.type.baseType;
const auto attributeValue = printAttributeValue(fabricStage, primPath, attribute);
stream << fmt::format(" Attribute: {}\n", attributeName);
stream << fmt::format(" Type: {}\n", attributeType);
if (attributeBaseType != omni::fabric::BaseDataType::eTag) {
stream << fmt::format(" Value: {}\n", attributeValue);
}
}
}
}
return stream.str();
}
FabricStatistics getStatistics(omni::fabric::StageReaderWriter& fabricStage) {
FabricStatistics statistics;
const auto geometryBuckets = fabricStage.findPrims(
{omni::fabric::AttrNameAndType(FabricTypes::_cesium_tilesetId, FabricTokens::_cesium_tilesetId)},
{omni::fabric::AttrNameAndType(FabricTypes::Mesh, FabricTokens::Mesh)});
const auto materialBuckets = fabricStage.findPrims(
{omni::fabric::AttrNameAndType(FabricTypes::_cesium_tilesetId, FabricTokens::_cesium_tilesetId)},
{omni::fabric::AttrNameAndType(FabricTypes::Material, FabricTokens::Material)});
for (uint64_t bucketId = 0; bucketId < geometryBuckets.bucketCount(); ++bucketId) {
const auto paths = fabricStage.getPathArray(geometryBuckets, bucketId);
statistics.geometriesCapacity += paths.size();
for (const auto& path : paths) {
const auto worldVisibilityFabric = fabricStage.getAttributeRd<bool>(path, FabricTokens::_worldVisibility);
const auto faceVertexCountsFabric =
fabricStage.getArrayAttributeRd<int>(path, FabricTokens::faceVertexCounts);
const auto tilesetIdFabric = fabricStage.getAttributeRd<int64_t>(path, FabricTokens::_cesium_tilesetId);
assert(worldVisibilityFabric);
assert(tilesetIdFabric);
if (*tilesetIdFabric == NO_TILESET_ID) {
continue;
}
++statistics.geometriesLoaded;
const auto triangleCount = faceVertexCountsFabric.size();
statistics.trianglesLoaded += triangleCount;
if (*worldVisibilityFabric) {
++statistics.geometriesRendered;
statistics.trianglesRendered += triangleCount;
}
}
}
for (uint64_t bucketId = 0; bucketId < materialBuckets.bucketCount(); ++bucketId) {
auto paths = fabricStage.getPathArray(materialBuckets, bucketId);
const auto tilesetIdFabric =
fabricStage.getAttributeArrayRd<int64_t>(materialBuckets, bucketId, FabricTokens::_cesium_tilesetId);
statistics.materialsCapacity += paths.size();
for (uint64_t i = 0; i < paths.size(); ++i) {
if (tilesetIdFabric[i] == NO_TILESET_ID) {
continue;
}
++statistics.materialsLoaded;
}
}
return statistics;
}
void destroyPrim(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path) {
fabricStage.destroyPrim(path);
// Prims removed from Fabric need special handling for their removal to be reflected in the Hydra render index
// This workaround may not be needed in future Kit versions, but is needed as of Kit 105.0
const omni::fabric::Path changeTrackingPath("/TempChangeTracking");
if (!fabricStage.getAttributeRd<omni::fabric::PathC>(changeTrackingPath, FabricTokens::_deletedPrims)) {
return;
}
const auto deletedPrimsSize = fabricStage.getArrayAttributeSize(changeTrackingPath, FabricTokens::_deletedPrims);
fabricStage.setArrayAttributeSize(changeTrackingPath, FabricTokens::_deletedPrims, deletedPrimsSize + 1);
const auto deletedPrimsFabric =
fabricStage.getArrayAttributeWr<omni::fabric::PathC>(changeTrackingPath, FabricTokens::_deletedPrims);
deletedPrimsFabric[deletedPrimsSize] = path;
}
void setTilesetTransform(
omni::fabric::StageReaderWriter& fabricStage,
int64_t tilesetId,
const glm::dmat4& ecefToPrimWorldTransform) {
const auto buckets = fabricStage.findPrims(
{omni::fabric::AttrNameAndType(FabricTypes::_cesium_tilesetId, FabricTokens::_cesium_tilesetId)},
{omni::fabric::AttrNameAndType(
FabricTypes::_cesium_gltfLocalToEcefTransform, FabricTokens::_cesium_gltfLocalToEcefTransform)});
for (uint64_t bucketId = 0; bucketId < buckets.bucketCount(); ++bucketId) {
// clang-format off
const auto tilesetIdFabric = fabricStage.getAttributeArrayRd<int64_t>(buckets, bucketId, FabricTokens::_cesium_tilesetId);
const auto gltfLocalToEcefTransformFabric = fabricStage.getAttributeArrayRd<pxr::GfMatrix4d>(buckets, bucketId, FabricTokens::_cesium_gltfLocalToEcefTransform);
const auto extentFabric = fabricStage.getAttributeArrayRd<pxr::GfRange3d>(buckets, bucketId, FabricTokens::extent);
const auto worldPositionFabric = fabricStage.getAttributeArrayWr<pxr::GfVec3d>(buckets, bucketId, FabricTokens::_worldPosition);
const auto worldOrientationFabric = fabricStage.getAttributeArrayWr<pxr::GfQuatf>(buckets, bucketId, FabricTokens::_worldOrientation);
const auto worldScaleFabric = fabricStage.getAttributeArrayWr<pxr::GfVec3f>(buckets, bucketId, FabricTokens::_worldScale);
const auto worldExtentFabric = fabricStage.getAttributeArrayWr<pxr::GfRange3d>(buckets, bucketId, FabricTokens::_worldExtent);
// clang-format on
for (uint64_t i = 0; i < tilesetIdFabric.size(); ++i) {
if (tilesetIdFabric[i] == tilesetId) {
const auto gltfLocalToEcefTransform = UsdUtil::usdToGlmMatrix(gltfLocalToEcefTransformFabric[i]);
const auto gltfLocalToPrimWorldTransform = ecefToPrimWorldTransform * gltfLocalToEcefTransform;
const auto gltfLocalExtent = UsdUtil::usdToGlmExtent(extentFabric[i]);
const auto [primWorldPosition, primWorldOrientation, primWorldScale] =
MathUtil::decompose(gltfLocalToPrimWorldTransform);
const auto primWorldExtent = MathUtil::transformExtent(gltfLocalExtent, gltfLocalToPrimWorldTransform);
worldPositionFabric[i] = UsdUtil::glmToUsdVector(primWorldPosition);
worldOrientationFabric[i] = UsdUtil::glmToUsdQuat(glm::fquat(primWorldOrientation));
worldScaleFabric[i] = UsdUtil::glmToUsdVector(glm::fvec3(primWorldScale));
worldExtentFabric[i] = UsdUtil::glmToUsdExtent(primWorldExtent);
}
}
}
}
omni::fabric::Path toFabricPath(const pxr::SdfPath& path) {
return {omni::fabric::asInt(path)};
}
omni::fabric::Token toFabricToken(const pxr::TfToken& token) {
return {omni::fabric::asInt(token)};
}
omni::fabric::Path joinPaths(const omni::fabric::Path& absolutePath, const omni::fabric::Token& relativePath) {
return {fmt::format("{}/{}", absolutePath.getText(), relativePath.getText()).c_str()};
}
omni::fabric::Path getCopiedShaderPath(const omni::fabric::Path& materialPath, const omni::fabric::Path& shaderPath) {
// materialPath is the FabricMaterial path
// shaderPath is the USD shader path
return FabricUtil::joinPaths(materialPath, omni::fabric::Token(UsdUtil::getSafeName(shaderPath.getText()).c_str()));
}
namespace {
struct FabricConnection {
omni::fabric::Connection* pConnection;
omni::fabric::Token attributeName;
};
std::vector<FabricConnection>
getConnections(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path) {
std::vector<FabricConnection> connections;
const auto attributes = fabricStage.getAttributeNamesAndTypes(path);
const auto& names = attributes.first;
const auto& types = attributes.second;
for (uint64_t i = 0; i < names.size(); ++i) {
const auto& name = names[i];
const auto& type = types[i];
if (type.baseType == omni::fabric::BaseDataType::eConnection) {
const auto pConnection = fabricStage.getConnection(path, name);
if (pConnection) {
// In C++ 20 this can be emplace_back without the {}
connections.push_back({pConnection, name});
}
}
}
return connections;
}
bool isOutput(const omni::fabric::Token& attributeName) {
return attributeName == FabricTokens::outputs_out;
}
bool isConnection(const omni::fabric::Type& attributeType) {
return attributeType.baseType == omni::fabric::BaseDataType::eConnection;
}
bool isEmptyToken(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
const omni::fabric::Token& attributeName,
const omni::fabric::Type& attributeType) {
if (attributeType.baseType == omni::fabric::BaseDataType::eToken) {
const auto pAttributeValue = fabricStage.getAttributeRd<omni::fabric::Token>(path, attributeName);
if (!pAttributeValue || pAttributeValue->size() == 0) {
return true;
}
}
return false;
}
std::vector<omni::fabric::TokenC>
getAttributesToCopy(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path) {
std::vector<omni::fabric::TokenC> attributeNames;
const auto attributes = fabricStage.getAttributeNamesAndTypes(path);
const auto& names = attributes.first;
const auto& types = attributes.second;
for (uint64_t i = 0; i < names.size(); ++i) {
const auto& name = names[i];
const auto& type = types[i];
if (!isOutput(name) && !isConnection(type) && !isEmptyToken(fabricStage, path, name, type)) {
attributeNames.push_back(name.asTokenC());
}
}
return attributeNames;
}
struct FabricAttribute {
omni::fabric::Token name;
omni::fabric::Type type;
};
std::vector<FabricAttribute>
getAttributesToCreate(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path) {
std::vector<FabricAttribute> attributeNames;
const auto attributes = fabricStage.getAttributeNamesAndTypes(path);
const auto& names = attributes.first;
const auto& types = attributes.second;
for (uint64_t i = 0; i < names.size(); ++i) {
const auto& name = names[i];
const auto& type = types[i];
if (isOutput(name) || isEmptyToken(fabricStage, path, name, type)) {
// In C++ 20 this can be emplace_back without the {}
attributeNames.push_back({name, type});
}
}
return attributeNames;
}
void getConnectedPrimsRecursive(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& path,
std::vector<omni::fabric::Path>& connectedPaths) {
const auto connections = getConnections(fabricStage, path);
for (const auto& connection : connections) {
if (!CppUtil::contains(connectedPaths, connection.pConnection->path)) {
connectedPaths.push_back(connection.pConnection->path);
getConnectedPrimsRecursive(fabricStage, connection.pConnection->path, connectedPaths);
}
}
}
std::vector<omni::fabric::Path>
getPrimsInMaterialNetwork(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path) {
std::vector<omni::fabric::Path> paths;
paths.push_back(path);
getConnectedPrimsRecursive(fabricStage, path, paths);
return paths;
}
omni::fabric::Path getMaterialSource(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path) {
if (fabricStage.attributeExistsWithType(path, FabricTokens::_materialSource, FabricTypes::_materialSource)) {
const auto materialSourceFabric =
fabricStage.getArrayAttributeRd<omni::fabric::PathC>(path, FabricTokens::_materialSource);
if (!materialSourceFabric.empty()) {
return *materialSourceFabric.begin();
}
}
return path;
}
} // namespace
std::vector<omni::fabric::Path> copyMaterial(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& srcMaterialPath,
const omni::fabric::Path& dstMaterialPath) {
const auto iFabricStage = carb::getCachedInterface<omni::fabric::IStageReaderWriter>();
const auto materialSourcePath = getMaterialSource(fabricStage, srcMaterialPath);
const auto srcPaths = getPrimsInMaterialNetwork(fabricStage, materialSourcePath);
std::vector<omni::fabric::Path> dstPaths;
dstPaths.reserve(srcPaths.size());
for (const auto& srcPath : srcPaths) {
auto dstPath = omni::fabric::Path();
if (srcPath == materialSourcePath) {
dstPath = dstMaterialPath;
} else {
const auto name = omni::fabric::Token(std::strrchr(srcPath.getText(), '/') + 1);
dstPath = FabricUtil::getCopiedShaderPath(dstMaterialPath, srcMaterialPath.appendChild(name));
}
dstPaths.push_back(dstPath);
fabricStage.createPrim(dstPath);
// This excludes connections, outputs, and empty tokens
// The material network will be reconnected later once all the prims have been copied
// The reason for excluding outputs and empty tokens is so that Omniverse doesn't print the warning
// [Warning] [omni.fabric.plugin] Warning: input has no valid data
const auto attributesToCopy = getAttributesToCopy(fabricStage, srcPath);
iFabricStage->copySpecifiedAttributes(
fabricStage.getId(),
srcPath,
attributesToCopy.data(),
dstPath,
attributesToCopy.data(),
attributesToCopy.size());
// Add the outputs and empty tokens back. This doesn't print a warning.
const auto attributesToCreate = getAttributesToCreate(fabricStage, srcPath);
for (const auto& attribute : attributesToCreate) {
fabricStage.createAttribute(dstPath, attribute.name, attribute.type);
}
}
// Reconnect the prims
for (uint64_t i = 0; i < srcPaths.size(); ++i) {
const auto& srcPath = srcPaths[i];
const auto& dstPath = dstPaths[i];
const auto connections = getConnections(fabricStage, srcPath);
for (const auto& connection : connections) {
const auto index = CppUtil::indexOf(srcPaths, connection.pConnection->path);
assert(index != srcPaths.size()); // Ensure that all connections are part of the material network
const auto dstConnection =
omni::fabric::Connection{dstPaths[index].asPathC(), connection.pConnection->attrName};
fabricStage.createConnection(dstPath, connection.attributeName, dstConnection);
}
}
return dstPaths;
}
bool materialHasCesiumNodes(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& materialPath) {
const auto materialSourcePath = getMaterialSource(fabricStage, materialPath);
const auto paths = getPrimsInMaterialNetwork(fabricStage, materialSourcePath);
for (const auto& path : paths) {
const auto mdlIdentifier = getMdlIdentifier(fabricStage, path);
if (isCesiumNode(mdlIdentifier)) {
return true;
}
}
return false;
}
bool isCesiumNode(const omni::fabric::Token& mdlIdentifier) {
return mdlIdentifier == FabricTokens::cesium_base_color_texture_float4 ||
mdlIdentifier == FabricTokens::cesium_raster_overlay_float4 ||
mdlIdentifier == FabricTokens::cesium_feature_id_int || isCesiumPropertyNode(mdlIdentifier);
}
bool isCesiumPropertyNode(const omni::fabric::Token& mdlIdentifier) {
return mdlIdentifier == FabricTokens::cesium_property_int || mdlIdentifier == FabricTokens::cesium_property_int2 ||
mdlIdentifier == FabricTokens::cesium_property_int3 || mdlIdentifier == FabricTokens::cesium_property_int4 ||
mdlIdentifier == FabricTokens::cesium_property_float ||
mdlIdentifier == FabricTokens::cesium_property_float2 ||
mdlIdentifier == FabricTokens::cesium_property_float3 ||
mdlIdentifier == FabricTokens::cesium_property_float4;
}
bool isShaderConnectedToMaterial(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& materialPath,
const omni::fabric::Path& shaderPath) {
const auto materialSourcePath = getMaterialSource(fabricStage, materialPath);
const auto paths = getPrimsInMaterialNetwork(fabricStage, materialSourcePath);
return CppUtil::contains(paths, shaderPath);
}
omni::fabric::Token getMdlIdentifier(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path) {
if (fabricStage.attributeExists(path, FabricTokens::info_mdl_sourceAsset_subIdentifier)) {
const auto pInfoMdlSourceAssetSubIdentifierFabric =
fabricStage.getAttributeRd<omni::fabric::Token>(path, FabricTokens::info_mdl_sourceAsset_subIdentifier);
if (pInfoMdlSourceAssetSubIdentifierFabric) {
return *pInfoMdlSourceAssetSubIdentifierFabric;
}
}
return {};
}
omni::fabric::Type getPrimvarType(DataType type) {
const auto baseDataType = DataTypeUtil::getPrimvarBaseDataType(type);
const auto componentCount = DataTypeUtil::getComponentCount(type);
return {baseDataType, static_cast<uint8_t>(componentCount), 1, omni::fabric::AttributeRole::eNone};
}
MdlExternalPropertyType getMdlExternalPropertyType(const omni::fabric::Token& mdlIdentifier) {
assert(isCesiumPropertyNode(mdlIdentifier));
if (mdlIdentifier == FabricTokens::cesium_property_int) {
return MdlExternalPropertyType::INT32;
} else if (mdlIdentifier == FabricTokens::cesium_property_int2) {
return MdlExternalPropertyType::VEC2_INT32;
} else if (mdlIdentifier == FabricTokens::cesium_property_int3) {
return MdlExternalPropertyType::VEC3_INT32;
} else if (mdlIdentifier == FabricTokens::cesium_property_int4) {
return MdlExternalPropertyType::VEC4_INT32;
} else if (mdlIdentifier == FabricTokens::cesium_property_float) {
return MdlExternalPropertyType::FLOAT32;
} else if (mdlIdentifier == FabricTokens::cesium_property_float2) {
return MdlExternalPropertyType::VEC2_FLOAT32;
} else if (mdlIdentifier == FabricTokens::cesium_property_float3) {
return MdlExternalPropertyType::VEC3_FLOAT32;
} else if (mdlIdentifier == FabricTokens::cesium_property_float4) {
return MdlExternalPropertyType::VEC4_FLOAT32;
}
return MdlExternalPropertyType::INT32;
}
bool typesCompatible(MdlExternalPropertyType externalType, MdlInternalPropertyType internalType) {
switch (externalType) {
case MdlExternalPropertyType::INT32:
switch (internalType) {
case MdlInternalPropertyType::INT32:
return true;
default:
return false;
}
case MdlExternalPropertyType::FLOAT32:
switch (internalType) {
case MdlInternalPropertyType::FLOAT32:
case MdlInternalPropertyType::INT32_NORM:
return true;
default:
return false;
}
case MdlExternalPropertyType::VEC2_INT32:
switch (internalType) {
case MdlInternalPropertyType::VEC2_INT32:
return true;
default:
return false;
}
case MdlExternalPropertyType::VEC2_FLOAT32:
switch (internalType) {
case MdlInternalPropertyType::VEC2_FLOAT32:
case MdlInternalPropertyType::VEC2_INT32_NORM:
return true;
default:
return false;
}
case MdlExternalPropertyType::VEC3_INT32:
switch (internalType) {
case MdlInternalPropertyType::VEC3_INT32:
return true;
default:
return false;
}
case MdlExternalPropertyType::VEC3_FLOAT32:
switch (internalType) {
case MdlInternalPropertyType::VEC3_FLOAT32:
case MdlInternalPropertyType::VEC3_INT32_NORM:
return true;
default:
return false;
}
case MdlExternalPropertyType::VEC4_INT32:
switch (internalType) {
case MdlInternalPropertyType::VEC4_INT32:
return true;
default:
return false;
}
case MdlExternalPropertyType::VEC4_FLOAT32:
switch (internalType) {
case MdlInternalPropertyType::VEC4_FLOAT32:
case MdlInternalPropertyType::VEC4_INT32_NORM:
return true;
default:
return false;
}
case MdlExternalPropertyType::MAT2_FLOAT32:
switch (internalType) {
case MdlInternalPropertyType::MAT2_INT32:
case MdlInternalPropertyType::MAT2_FLOAT32:
case MdlInternalPropertyType::MAT2_INT32_NORM:
return true;
default:
return false;
}
case MdlExternalPropertyType::MAT3_FLOAT32:
switch (internalType) {
case MdlInternalPropertyType::MAT3_INT32:
case MdlInternalPropertyType::MAT3_FLOAT32:
case MdlInternalPropertyType::MAT3_INT32_NORM:
return true;
default:
return false;
}
case MdlExternalPropertyType::MAT4_FLOAT32:
switch (internalType) {
case MdlInternalPropertyType::MAT4_INT32:
case MdlInternalPropertyType::MAT4_FLOAT32:
case MdlInternalPropertyType::MAT4_INT32_NORM:
return true;
default:
return false;
}
}
return false;
}
} // namespace cesium::omniverse::FabricUtil
| 39,284 | C++ | 39.5 | 168 | 0.60279 |
CesiumGS/cesium-omniverse/src/core/src/MathUtil.cpp | #include "cesium/omniverse/MathUtil.h"
#include <glm/gtx/euler_angles.hpp>
#include <glm/gtx/matrix_decompose.hpp>
namespace cesium::omniverse::MathUtil {
EulerAngleOrder getReversedEulerAngleOrder(EulerAngleOrder eulerAngleOrder) {
switch (eulerAngleOrder) {
case EulerAngleOrder::XYZ:
return EulerAngleOrder::ZYX;
case EulerAngleOrder::XZY:
return EulerAngleOrder::YZX;
case EulerAngleOrder::YXZ:
return EulerAngleOrder::ZXY;
case EulerAngleOrder::YZX:
return EulerAngleOrder::XZY;
case EulerAngleOrder::ZXY:
return EulerAngleOrder::YXZ;
case EulerAngleOrder::ZYX:
return EulerAngleOrder::XYZ;
}
return EulerAngleOrder::XYZ;
}
DecomposedEuler decomposeEuler(const glm::dmat4& matrix, EulerAngleOrder eulerAngleOrder) {
glm::dvec3 scale;
glm::dquat rotation;
glm::dvec3 translation;
glm::dvec3 skew;
glm::dvec4 perspective;
[[maybe_unused]] const auto decomposable = glm::decompose(matrix, scale, rotation, translation, skew, perspective);
assert(decomposable);
const auto rotationMatrix = glm::mat4_cast(rotation);
glm::dvec3 rotationEuler(0.0);
switch (eulerAngleOrder) {
case EulerAngleOrder::XYZ:
glm::extractEulerAngleXYZ(rotationMatrix, rotationEuler.x, rotationEuler.y, rotationEuler.z);
break;
case EulerAngleOrder::XZY:
glm::extractEulerAngleXZY(rotationMatrix, rotationEuler.x, rotationEuler.z, rotationEuler.y);
break;
case EulerAngleOrder::YXZ:
glm::extractEulerAngleYXZ(rotationMatrix, rotationEuler.y, rotationEuler.x, rotationEuler.z);
break;
case EulerAngleOrder::YZX:
glm::extractEulerAngleYZX(rotationMatrix, rotationEuler.y, rotationEuler.z, rotationEuler.x);
break;
case EulerAngleOrder::ZXY:
glm::extractEulerAngleZXY(rotationMatrix, rotationEuler.z, rotationEuler.x, rotationEuler.y);
break;
case EulerAngleOrder::ZYX:
glm::extractEulerAngleZYX(rotationMatrix, rotationEuler.z, rotationEuler.y, rotationEuler.x);
break;
}
return {translation, rotationEuler, scale};
}
Decomposed decompose(const glm::dmat4& matrix) {
glm::dvec3 scale;
glm::dquat rotation;
glm::dvec3 translation;
glm::dvec3 skew;
glm::dvec4 perspective;
[[maybe_unused]] const auto decomposable = glm::decompose(matrix, scale, rotation, translation, skew, perspective);
assert(decomposable);
return {translation, rotation, scale};
}
glm::dmat4 composeEuler(
const glm::dvec3& translation,
const glm::dvec3& rotation,
const glm::dvec3& scale,
EulerAngleOrder eulerAngleOrder) {
const auto translationMatrix = glm::translate(glm::dmat4(1.0), translation);
const auto scaleMatrix = glm::scale(glm::dmat4(1.0), scale);
auto rotationMatrix = glm::dmat4(1.0);
switch (eulerAngleOrder) {
case EulerAngleOrder::XYZ:
rotationMatrix = glm::eulerAngleXYZ(rotation.x, rotation.y, rotation.z);
break;
case EulerAngleOrder::XZY:
rotationMatrix = glm::eulerAngleXZY(rotation.x, rotation.z, rotation.y);
break;
case EulerAngleOrder::YXZ:
rotationMatrix = glm::eulerAngleYXZ(rotation.y, rotation.x, rotation.z);
break;
case EulerAngleOrder::YZX:
rotationMatrix = glm::eulerAngleYZX(rotation.y, rotation.z, rotation.x);
break;
case EulerAngleOrder::ZXY:
rotationMatrix = glm::eulerAngleZXY(rotation.z, rotation.x, rotation.y);
break;
case EulerAngleOrder::ZYX:
rotationMatrix = glm::eulerAngleZYX(rotation.z, rotation.y, rotation.x);
break;
}
return translationMatrix * rotationMatrix * scaleMatrix;
}
glm::dmat4 compose(const glm::dvec3& translation, const glm::dquat& rotation, const glm::dvec3& scale) {
const auto translationMatrix = glm::translate(glm::dmat4(1.0), translation);
const auto rotationMatrix = glm::mat4_cast(rotation);
const auto scaleMatrix = glm::scale(glm::dmat4(1.0), scale);
return translationMatrix * rotationMatrix * scaleMatrix;
}
bool equal(const CesiumGeospatial::Cartographic& a, const CesiumGeospatial::Cartographic& b) {
const auto& aVec = *reinterpret_cast<const glm::dvec3*>(&a);
const auto& bVec = *reinterpret_cast<const glm::dvec3*>(&b);
return aVec == bVec;
}
bool epsilonEqual(const CesiumGeospatial::Cartographic& a, const CesiumGeospatial::Cartographic& b, double epsilon) {
const auto& aVec = *reinterpret_cast<const glm::dvec3*>(&a);
const auto& bVec = *reinterpret_cast<const glm::dvec3*>(&b);
return glm::all(glm::epsilonEqual(aVec, bVec, epsilon));
}
bool epsilonEqual(const glm::dmat4& a, const glm::dmat4& b, double epsilon) {
return glm::all(glm::epsilonEqual(a[0], b[0], epsilon)) && glm::all(glm::epsilonEqual(a[1], b[1], epsilon)) &&
glm::all(glm::epsilonEqual(a[2], b[2], epsilon)) && glm::all(glm::epsilonEqual(a[3], b[3], epsilon));
}
bool epsilonEqual(const glm::dvec3& a, const glm::dvec3& b, double epsilon) {
return glm::all(glm::epsilonEqual(a, b, epsilon));
}
bool epsilonEqual(const glm::dquat& a, const glm::dquat& b, double epsilon) {
return glm::all(glm::epsilonEqual(a, b, epsilon));
}
glm::dvec3 getCorner(const std::array<glm::dvec3, 2>& extent, uint64_t index) {
return {
(index & 1) ? extent[1].x : extent[0].x,
(index & 2) ? extent[1].y : extent[0].y,
(index & 4) ? extent[1].z : extent[0].z,
};
}
std::array<glm::dvec3, 2> transformExtent(const std::array<glm::dvec3, 2>& extent, const glm::dmat4& transform) {
const auto min = std::numeric_limits<double>::lowest();
const auto max = std::numeric_limits<double>::max();
glm::dvec3 transformedMin(max);
glm::dvec3 transformedMax(min);
for (uint64_t i = 0; i < 8; ++i) {
const auto position = MathUtil::getCorner(extent, i);
const auto transformedPosition = glm::dvec3(transform * glm::dvec4(position, 1.0));
transformedMin = glm::min(transformedMin, transformedPosition);
transformedMax = glm::max(transformedMax, transformedPosition);
}
return {{transformedMin, transformedMax}};
}
} // namespace cesium::omniverse::MathUtil
| 6,440 | C++ | 36.666666 | 119 | 0.664286 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/OmniTileMapServiceRasterOverlay.h | #pragma once
#include "cesium/omniverse/OmniRasterOverlay.h"
#include <CesiumRasterOverlays/TileMapServiceRasterOverlay.h>
#include <CesiumUtility/IntrusivePointer.h>
#include <string>
namespace cesium::omniverse {
class OmniTileMapServiceRasterOverlay final : public OmniRasterOverlay {
public:
OmniTileMapServiceRasterOverlay(Context* pContext, const pxr::SdfPath& path);
~OmniTileMapServiceRasterOverlay() override = default;
OmniTileMapServiceRasterOverlay(const OmniTileMapServiceRasterOverlay&) = delete;
OmniTileMapServiceRasterOverlay& operator=(const OmniTileMapServiceRasterOverlay&) = delete;
OmniTileMapServiceRasterOverlay(OmniTileMapServiceRasterOverlay&&) noexcept = default;
OmniTileMapServiceRasterOverlay& operator=(OmniTileMapServiceRasterOverlay&&) noexcept = default;
[[nodiscard]] CesiumRasterOverlays::RasterOverlay* getRasterOverlay() const override;
[[nodiscard]] std::string getUrl() const;
[[nodiscard]] int getMinimumZoomLevel() const;
[[nodiscard]] int getMaximumZoomLevel() const;
[[nodiscard]] bool getSpecifyZoomLevels() const;
void reload() override;
private:
CesiumUtility::IntrusivePointer<CesiumRasterOverlays::TileMapServiceRasterOverlay> _pTileMapServiceRasterOverlay;
};
} // namespace cesium::omniverse
| 1,306 | C | 39.843749 | 117 | 0.795559 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/AssetTroubleshootingDetails.h | #pragma once
#include <cstdint>
namespace cesium::omniverse {
struct AssetTroubleshootingDetails {
int64_t assetId;
bool assetExistsInUserAccount{false};
};
} // namespace cesium::omniverse
| 202 | C | 14.615383 | 41 | 0.747525 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/TokenTroubleshootingDetails.h | #pragma once
#include <CesiumIonClient/Token.h>
namespace cesium::omniverse {
struct TokenTroubleshootingDetails {
CesiumIonClient::Token token;
bool isValid{false};
bool allowsAccessToAsset{false};
bool associatedWithUserAccount{false};
bool showDetails{false};
};
} // namespace cesium::omniverse
| 323 | C | 19.249999 | 42 | 0.749226 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/UsdNotificationHandler.h | #pragma once
#include <pxr/usd/usd/notice.h>
namespace cesium::omniverse {
class Context;
class UsdNotificationHandler final : public pxr::TfWeakBase {
public:
UsdNotificationHandler(Context* pContext);
~UsdNotificationHandler();
UsdNotificationHandler(const UsdNotificationHandler&) = delete;
UsdNotificationHandler& operator=(const UsdNotificationHandler&) = delete;
UsdNotificationHandler(UsdNotificationHandler&&) noexcept = delete;
UsdNotificationHandler& operator=(UsdNotificationHandler&&) noexcept = delete;
void onStageLoaded();
void onUpdateFrame();
void clear();
private:
enum class ChangedPrimType {
CESIUM_DATA,
CESIUM_TILESET,
CESIUM_ION_RASTER_OVERLAY,
CESIUM_POLYGON_RASTER_OVERLAY,
CESIUM_WEB_MAP_SERVICE_RASTER_OVERLAY,
CESIUM_TILE_MAP_SERVICE_RASTER_OVERLAY,
CESIUM_WEB_MAP_TILE_SERVICE_RASTER_OVERLAY,
CESIUM_GEOREFERENCE,
CESIUM_GLOBE_ANCHOR,
CESIUM_ION_SERVER,
CESIUM_CARTOGRAPHIC_POLYGON,
USD_SHADER,
OTHER,
};
enum class ChangedType {
PROPERTY_CHANGED,
PRIM_ADDED,
PRIM_REMOVED,
};
struct ChangedPrim {
pxr::SdfPath primPath;
std::vector<pxr::TfToken> properties;
ChangedPrimType primType;
ChangedType changedType;
};
bool processChangedPrims();
[[nodiscard]] bool processChangedPrim(const ChangedPrim& changedPrim) const;
bool alreadyRegistered(const pxr::SdfPath& path);
void onObjectsChanged(const pxr::UsdNotice::ObjectsChanged& objectsChanged);
void onPrimAdded(const pxr::SdfPath& path);
void onPrimRemoved(const pxr::SdfPath& path);
void onPropertyChanged(const pxr::SdfPath& path);
void insertAddedPrim(const pxr::SdfPath& primPath, ChangedPrimType primType);
void insertRemovedPrim(const pxr::SdfPath& primPath, ChangedPrimType primType);
void
insertPropertyChanged(const pxr::SdfPath& primPath, ChangedPrimType primType, const pxr::TfToken& propertyName);
ChangedPrimType getTypeFromStage(const pxr::SdfPath& path) const;
ChangedPrimType getTypeFromAssetRegistry(const pxr::SdfPath& path) const;
Context* _pContext;
pxr::TfNotice::Key _noticeListenerKey;
std::vector<ChangedPrim> _changedPrims;
};
} // namespace cesium::omniverse
| 2,368 | C | 30.171052 | 116 | 0.708193 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/Context.h | #pragma once
#include <pxr/usd/usd/common.h>
#include <filesystem>
#include <memory>
#include <vector>
#include <gsl/span>
namespace omni::fabric {
class StageReaderWriter;
}
namespace CesiumUtility {
class CreditSystem;
}
namespace CesiumAsync {
class AsyncSystem;
class IAssetAccessor;
class ICacheDatabase;
} // namespace CesiumAsync
namespace cesium::omniverse {
class AssetRegistry;
class CesiumIonServerManager;
class FabricResourceManager;
class Logger;
class TaskProcessor;
class UsdNotificationHandler;
struct RenderStatistics;
struct Viewport;
class Context {
public:
Context(const std::filesystem::path& cesiumExtensionLocation);
~Context();
Context(const Context&) = delete;
Context& operator=(const Context&) = delete;
Context(Context&&) noexcept = delete;
Context& operator=(Context&&) noexcept = delete;
[[nodiscard]] const std::filesystem::path& getCesiumExtensionLocation() const;
[[nodiscard]] const std::filesystem::path& getCertificatePath() const;
[[nodiscard]] const pxr::TfToken& getCesiumMdlPathToken() const;
[[nodiscard]] std::shared_ptr<TaskProcessor> getTaskProcessor() const;
[[nodiscard]] const CesiumAsync::AsyncSystem& getAsyncSystem() const;
[[nodiscard]] std::shared_ptr<CesiumAsync::IAssetAccessor> getAssetAccessor() const;
[[nodiscard]] std::shared_ptr<CesiumUtility::CreditSystem> getCreditSystem() const;
[[nodiscard]] std::shared_ptr<Logger> getLogger() const;
[[nodiscard]] const AssetRegistry& getAssetRegistry() const;
[[nodiscard]] AssetRegistry& getAssetRegistry();
[[nodiscard]] const FabricResourceManager& getFabricResourceManager() const;
[[nodiscard]] FabricResourceManager& getFabricResourceManager();
[[nodiscard]] const CesiumIonServerManager& getCesiumIonServerManager() const;
[[nodiscard]] CesiumIonServerManager& getCesiumIonServerManager();
void clearStage();
void reloadStage();
void clearAccessorCache();
void onUpdateFrame(const gsl::span<const Viewport>& viewports, bool waitForLoadingTiles);
void onUsdStageChanged(int64_t stageId);
[[nodiscard]] const pxr::UsdStageWeakPtr& getUsdStage() const;
[[nodiscard]] pxr::UsdStageWeakPtr& getUsdStage();
[[nodiscard]] int64_t getUsdStageId() const;
[[nodiscard]] bool hasUsdStage() const;
[[nodiscard]] omni::fabric::StageReaderWriter& getFabricStage() const;
[[nodiscard]] RenderStatistics getRenderStatistics() const;
[[nodiscard]] int64_t getContextId() const;
private:
std::filesystem::path _cesiumExtensionLocation;
std::filesystem::path _certificatePath;
pxr::TfToken _cesiumMdlPathToken;
std::shared_ptr<TaskProcessor> _pTaskProcessor;
std::unique_ptr<CesiumAsync::AsyncSystem> _pAsyncSystem;
std::shared_ptr<Logger> _pLogger;
std::shared_ptr<CesiumAsync::IAssetAccessor> _pAssetAccessor;
std::shared_ptr<CesiumAsync::ICacheDatabase> _pCacheDatabase;
std::shared_ptr<CesiumUtility::CreditSystem> _pCreditSystem;
std::unique_ptr<AssetRegistry> _pAssetRegistry;
std::unique_ptr<FabricResourceManager> _pFabricResourceManager;
std::unique_ptr<CesiumIonServerManager> _pCesiumIonServerManager;
std::unique_ptr<UsdNotificationHandler> _pUsdNotificationHandler;
int64_t _contextId;
pxr::UsdStageWeakPtr _pUsdStage;
std::unique_ptr<omni::fabric::StageReaderWriter> _pFabricStage;
int64_t _usdStageId{0};
};
} // namespace cesium::omniverse
| 3,467 | C | 33 | 93 | 0.744159 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/UsdScopedEdit.h | #include <pxr/usd/usd/stage.h>
namespace cesium::omniverse {
class UsdScopedEdit {
public:
UsdScopedEdit(const pxr::UsdStageWeakPtr& pStage);
~UsdScopedEdit();
UsdScopedEdit(const UsdScopedEdit&) = delete;
UsdScopedEdit& operator=(const UsdScopedEdit&) = delete;
UsdScopedEdit(UsdScopedEdit&&) noexcept = delete;
UsdScopedEdit& operator=(UsdScopedEdit&&) noexcept = delete;
private:
pxr::UsdStageWeakPtr _pStage;
pxr::SdfLayerHandle _sessionLayer;
bool _sessionLayerWasEditable;
pxr::UsdEditTarget _originalEditTarget;
};
} // namespace cesium::omniverse
| 603 | C | 26.454544 | 64 | 0.729685 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricFeaturesUtil.h | #pragma once
#include <cstdint>
#include <vector>
namespace cesium::omniverse {
struct FabricFeatureId;
struct FabricFeaturesInfo;
enum class FabricFeatureIdType;
} // namespace cesium::omniverse
namespace cesium::omniverse::FabricFeaturesUtil {
FabricFeatureIdType getFeatureIdType(const FabricFeatureId& featureId);
std::vector<FabricFeatureIdType> getFeatureIdTypes(const FabricFeaturesInfo& featuresInfo);
std::vector<uint64_t> getSetIndexMapping(const FabricFeaturesInfo& featuresInfo, FabricFeatureIdType type);
bool hasFeatureIdType(const FabricFeaturesInfo& featuresInfo, FabricFeatureIdType type);
} // namespace cesium::omniverse::FabricFeaturesUtil
| 665 | C | 32.299998 | 107 | 0.83609 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricVertexAttributeDescriptor.h | #pragma once
#include "cesium/omniverse/DataType.h"
#include <omni/fabric/IToken.h>
namespace cesium::omniverse {
struct FabricVertexAttributeDescriptor {
DataType type;
omni::fabric::Token fabricAttributeName;
std::string gltfAttributeName;
// Make sure to update this function when adding new fields to the struct
// In C++ 20 we can use the default equality comparison (= default)
// clang-format off
bool operator==(const FabricVertexAttributeDescriptor& other) const {
return type == other.type &&
fabricAttributeName == other.fabricAttributeName &&
gltfAttributeName == other.gltfAttributeName;
}
// clang-format on
// This is needed for std::set to be sorted
bool operator<(const FabricVertexAttributeDescriptor& other) const {
return fabricAttributeName < other.fabricAttributeName;
}
};
} // namespace cesium::omniverse
| 930 | C | 29.032257 | 77 | 0.701075 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricMaterialPool.h | #pragma once
#include "cesium/omniverse/FabricMaterial.h"
#include "cesium/omniverse/FabricMaterialDescriptor.h"
#include "cesium/omniverse/ObjectPool.h"
#include <pxr/usd/usd/common.h>
namespace cesium::omniverse {
class FabricMaterialPool final : public ObjectPool<FabricMaterial> {
public:
FabricMaterialPool(
Context* pContext,
int64_t poolId,
const FabricMaterialDescriptor& materialDescriptor,
uint64_t initialCapacity,
const pxr::TfToken& defaultWhiteTextureAssetPathToken,
const pxr::TfToken& defaultTransparentTextureAssetPathToken,
bool debugRandomColors);
~FabricMaterialPool() override = default;
FabricMaterialPool(const FabricMaterialPool&) = delete;
FabricMaterialPool& operator=(const FabricMaterialPool&) = delete;
FabricMaterialPool(FabricMaterialPool&&) noexcept = default;
FabricMaterialPool& operator=(FabricMaterialPool&&) noexcept = default;
[[nodiscard]] const FabricMaterialDescriptor& getMaterialDescriptor() const;
[[nodiscard]] int64_t getPoolId() const;
void updateShaderInput(const pxr::SdfPath& shaderPath, const pxr::TfToken& attributeName);
protected:
std::shared_ptr<FabricMaterial> createObject(uint64_t objectId) const override;
void setActive(FabricMaterial* pMaterial, bool active) const override;
private:
Context* _pContext;
int64_t _poolId;
FabricMaterialDescriptor _materialDescriptor;
pxr::TfToken _defaultWhiteTextureAssetPathToken;
pxr::TfToken _defaultTransparentTextureAssetPathToken;
bool _debugRandomColors;
};
} // namespace cesium::omniverse
| 1,632 | C | 34.499999 | 94 | 0.756127 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricGeometry.h | #pragma once
#include "cesium/omniverse/FabricGeometryDescriptor.h"
#include <glm/fwd.hpp>
#include <omni/fabric/IPath.h>
namespace CesiumGltf {
struct MeshPrimitive;
struct Model;
} // namespace CesiumGltf
namespace cesium::omniverse {
class Context;
struct FabricMaterialInfo;
class FabricGeometry {
public:
FabricGeometry(
Context* pContext,
const omni::fabric::Path& path,
const FabricGeometryDescriptor& geometryDescriptor,
int64_t poolId);
~FabricGeometry();
FabricGeometry(const FabricGeometry&) = delete;
FabricGeometry& operator=(const FabricGeometry&) = delete;
FabricGeometry(FabricGeometry&&) noexcept = default;
FabricGeometry& operator=(FabricGeometry&&) noexcept = default;
void setGeometry(
int64_t tilesetId,
const glm::dmat4& ecefToPrimWorldTransform,
const glm::dmat4& gltfLocalToEcefTransform,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const FabricMaterialInfo& materialInfo,
bool smoothNormals,
const std::unordered_map<uint64_t, uint64_t>& texcoordIndexMapping,
const std::unordered_map<uint64_t, uint64_t>& rasterOverlayTexcoordIndexMapping);
void setActive(bool active);
void setVisibility(bool visible);
[[nodiscard]] const omni::fabric::Path& getPath() const;
[[nodiscard]] const FabricGeometryDescriptor& getGeometryDescriptor() const;
[[nodiscard]] int64_t getPoolId() const;
void setMaterial(const omni::fabric::Path& materialPath);
private:
void initialize();
void reset();
bool stageDestroyed();
Context* _pContext;
omni::fabric::Path _path;
FabricGeometryDescriptor _geometryDescriptor;
int64_t _poolId;
int64_t _stageId;
};
} // namespace cesium::omniverse
| 1,829 | C | 27.59375 | 89 | 0.708037 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricMaterial.h | #pragma once
#include "cesium/omniverse/FabricMaterialDescriptor.h"
#include "cesium/omniverse/FabricMaterialInfo.h"
#include <glm/glm.hpp>
#include <omni/fabric/IPath.h>
#include <unordered_map>
namespace omni::fabric {
struct Type;
}
namespace omni::ui {
class DynamicTextureProvider;
}
namespace cesium::omniverse {
class FabricTexture;
enum class MdlInternalPropertyType;
struct FabricPropertyDescriptor;
struct FabricTextureInfo;
class FabricMaterial {
public:
FabricMaterial(
Context* pContext,
const omni::fabric::Path& path,
const FabricMaterialDescriptor& materialDescriptor,
const pxr::TfToken& defaultWhiteTextureAssetPathToken,
const pxr::TfToken& defaultTransparentTextureAssetPathToken,
bool debugRandomColors,
int64_t poolId);
~FabricMaterial();
FabricMaterial(const FabricMaterial&) = delete;
FabricMaterial& operator=(const FabricMaterial&) = delete;
FabricMaterial(FabricMaterial&&) noexcept = default;
FabricMaterial& operator=(FabricMaterial&&) noexcept = default;
void setMaterial(
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
int64_t tilesetId,
const FabricMaterialInfo& materialInfo,
const FabricFeaturesInfo& featuresInfo,
FabricTexture* pBaseColorTexture,
const std::vector<std::shared_ptr<FabricTexture>>& featureIdTextures,
const std::vector<std::shared_ptr<FabricTexture>>& propertyTextures,
const std::vector<std::shared_ptr<FabricTexture>>& propertyTableTextures,
const glm::dvec3& displayColor,
double displayOpacity,
const std::unordered_map<uint64_t, uint64_t>& texcoordIndexMapping,
const std::vector<uint64_t>& featureIdIndexSetIndexMapping,
const std::vector<uint64_t>& featureIdAttributeSetIndexMapping,
const std::vector<uint64_t>& featureIdTextureSetIndexMapping,
const std::unordered_map<uint64_t, uint64_t>& propertyTextureIndexMapping);
void setRasterOverlay(
FabricTexture* pTexture,
const FabricTextureInfo& textureInfo,
uint64_t rasterOverlayIndex,
double alpha,
const std::unordered_map<uint64_t, uint64_t>& rasterOverlayTexcoordIndexMapping);
void setRasterOverlayAlpha(uint64_t rasterOverlayIndex, double alpha);
void setDisplayColorAndOpacity(const glm::dvec3& displayColor, double displayOpacity);
void updateShaderInput(const omni::fabric::Path& shaderPath, const omni::fabric::Token& attributeName);
void clearRasterOverlay(uint64_t rasterOverlayIndex);
void setActive(bool active);
[[nodiscard]] const omni::fabric::Path& getPath() const;
[[nodiscard]] const FabricMaterialDescriptor& getMaterialDescriptor() const;
[[nodiscard]] int64_t getPoolId() const;
private:
void initializeNodes();
void initializeDefaultMaterial();
void initializeExistingMaterial(const omni::fabric::Path& path);
void createMaterial(const omni::fabric::Path& path);
void createShader(const omni::fabric::Path& path);
void createTextureCommon(
const omni::fabric::Path& path,
const omni::fabric::Token& subIdentifier,
const std::vector<std::pair<omni::fabric::Type, omni::fabric::Token>>& additionalAttributes = {});
void createTexture(const omni::fabric::Path& path);
void createRasterOverlay(const omni::fabric::Path& path);
void createRasterOverlayResolverCommon(
const omni::fabric::Path& path,
uint64_t textureCount,
const omni::fabric::Token& subidentifier);
void createRasterOverlayResolver(const omni::fabric::Path& path, uint64_t textureCount);
void createClippingRasterOverlayResolver(const omni::fabric::Path& path, uint64_t textureCount);
void createFeatureIdIndex(const omni::fabric::Path& path);
void createFeatureIdAttribute(const omni::fabric::Path& path);
void createFeatureIdTexture(const omni::fabric::Path& path);
void createPropertyAttributePropertyInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType);
void createPropertyAttributePropertyNormalizedInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType,
const omni::fabric::Type& maximumValueType);
void createPropertyAttributePropertyFloat(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType);
void createPropertyAttributeProperty(const omni::fabric::Path& path, MdlInternalPropertyType type);
void createPropertyTexturePropertyInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType);
void createPropertyTexturePropertyNormalizedInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType,
const omni::fabric::Type& maximumValueType);
void createPropertyTextureProperty(const omni::fabric::Path& path, MdlInternalPropertyType type);
void createPropertyTablePropertyInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType);
void createPropertyTablePropertyNormalizedInt(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType,
const omni::fabric::Type& maximumValueType);
void createPropertyTablePropertyFloat(
const omni::fabric::Path& path,
const omni::fabric::Token& subidentifier,
const omni::fabric::Type& noDataType,
const omni::fabric::Type& defaultValueType,
const omni::fabric::Type& offsetType,
const omni::fabric::Type& scaleType);
void createPropertyTableProperty(const omni::fabric::Path& path, MdlInternalPropertyType type);
void reset();
void setShaderValues(
const omni::fabric::Path& path,
const FabricMaterialInfo& materialInfo,
const glm::dvec3& displayColor,
double displayOpacity);
void setTextureValues(
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex);
void setRasterOverlayValues(
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex,
double alpha);
void setRasterOverlayAlphaValue(const omni::fabric::Path& path, double alpha);
void setFeatureIdIndexValues(const omni::fabric::Path& path, int nullFeatureId);
void setFeatureIdAttributeValues(const omni::fabric::Path& path, const std::string& primvarName, int nullFeatureId);
void setFeatureIdTextureValues(
const omni::fabric::Path& path,
const pxr::TfToken& textureAssetPathToken,
const FabricTextureInfo& textureInfo,
uint64_t texcoordIndex,
int nullFeatureId);
void createConnectionsToCopiedPaths();
void destroyConnectionsToCopiedPaths();
void createConnectionsToProperties();
void destroyConnectionsToProperties();
bool stageDestroyed();
Context* _pContext;
omni::fabric::Path _materialPath;
FabricMaterialDescriptor _materialDescriptor;
pxr::TfToken _defaultWhiteTextureAssetPathToken;
pxr::TfToken _defaultTransparentTextureAssetPathToken;
bool _debugRandomColors;
int64_t _poolId;
int64_t _stageId;
bool _usesDefaultMaterial;
FabricAlphaMode _alphaMode{FabricAlphaMode::OPAQUE};
glm::dvec3 _debugColor{1.0, 1.0, 1.0};
omni::fabric::Path _shaderPath;
omni::fabric::Path _baseColorTexturePath;
std::vector<omni::fabric::Path> _rasterOverlayPaths;
omni::fabric::Path _overlayRasterOverlayResolverPath;
omni::fabric::Path _clippingRasterOverlayResolverPath;
std::vector<omni::fabric::Path> _featureIdPaths;
std::vector<omni::fabric::Path> _featureIdIndexPaths;
std::vector<omni::fabric::Path> _featureIdAttributePaths;
std::vector<omni::fabric::Path> _featureIdTexturePaths;
std::vector<omni::fabric::Path> _propertyPaths;
std::unordered_map<MdlInternalPropertyType, std::vector<omni::fabric::Path>> _propertyAttributePropertyPaths;
std::unordered_map<MdlInternalPropertyType, std::vector<omni::fabric::Path>> _propertyTexturePropertyPaths;
std::unordered_map<MdlInternalPropertyType, std::vector<omni::fabric::Path>> _propertyTablePropertyPaths;
std::vector<omni::fabric::Path> _copiedBaseColorTexturePaths;
std::vector<omni::fabric::Path> _copiedRasterOverlayPaths;
std::vector<omni::fabric::Path> _copiedFeatureIdPaths;
std::vector<omni::fabric::Path> _copiedPropertyPaths;
std::vector<omni::fabric::Path> _allPaths;
};
} // namespace cesium::omniverse
| 9,803 | C | 41.626087 | 120 | 0.714373 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/SetDefaultTokenResult.h | #pragma once
#include <string>
namespace cesium::omniverse {
enum SetDefaultTokenResultCode {
NOT_SET_IN_SESSION = -1,
OK = 0,
NOT_CONNECTED_TO_ION = 1,
CREATE_FAILED = 2,
};
namespace SetDefaultTokenResultMessages {
inline const std::string_view NOT_SET_IN_SESSION_MESSAGE = "Default token has not been set this session.";
inline const std::string_view OK_MESSAGE = "OK";
inline const std::string_view NOT_CONNECTED_TO_ION_MESSAGE = "Not connected to ion.";
inline const std::string_view CREATE_FAILED_MESSAGE_BASE = "Create failed: {1} ({2})";
} // namespace SetDefaultTokenResultMessages
/**
* Stores information about the last action to set the default token. A code and a relevant user
* friendly message are stored.
*/
struct SetDefaultTokenResult {
int code{SetDefaultTokenResultCode::NOT_SET_IN_SESSION};
std::string message{SetDefaultTokenResultMessages::NOT_SET_IN_SESSION_MESSAGE};
};
} // namespace cesium::omniverse
| 961 | C | 31.066666 | 106 | 0.738814 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricUtil.h | #pragma once
#include <glm/fwd.hpp>
#include <pxr/usd/usd/common.h>
#include <string>
namespace omni::fabric {
class StageReaderWriter;
class Path;
class Token;
struct Type;
} // namespace omni::fabric
namespace cesium::omniverse {
enum class DataType;
enum class MdlExternalPropertyType;
enum class MdlInternalPropertyType;
struct FabricStatistics;
} // namespace cesium::omniverse
namespace cesium::omniverse::FabricUtil {
// -1 means the prim is not associated with a tileset yet
const int64_t NO_TILESET_ID{-1};
std::string printFabricStage(omni::fabric::StageReaderWriter& fabricStage);
FabricStatistics getStatistics(omni::fabric::StageReaderWriter& fabricStage);
void destroyPrim(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path);
void setTilesetTransform(
omni::fabric::StageReaderWriter& fabricStage,
int64_t tilesetId,
const glm::dmat4& ecefToPrimWorldTransform);
omni::fabric::Path toFabricPath(const pxr::SdfPath& path);
omni::fabric::Token toFabricToken(const pxr::TfToken& token);
omni::fabric::Path joinPaths(const omni::fabric::Path& absolutePath, const omni::fabric::Token& relativePath);
omni::fabric::Path getCopiedShaderPath(const omni::fabric::Path& materialPath, const omni::fabric::Path& shaderPath);
std::vector<omni::fabric::Path> copyMaterial(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& srcMaterialPath,
const omni::fabric::Path& dstMaterialPath);
bool materialHasCesiumNodes(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& materialPath);
bool isCesiumNode(const omni::fabric::Token& mdlIdentifier);
bool isCesiumPropertyNode(const omni::fabric::Token& mdlIdentifier);
bool isShaderConnectedToMaterial(
omni::fabric::StageReaderWriter& fabricStage,
const omni::fabric::Path& materialPath,
const omni::fabric::Path& shaderPath);
omni::fabric::Token getMdlIdentifier(omni::fabric::StageReaderWriter& fabricStage, const omni::fabric::Path& path);
omni::fabric::Type getPrimvarType(DataType type);
MdlExternalPropertyType getMdlExternalPropertyType(const omni::fabric::Token& mdlIdentifier);
bool typesCompatible(MdlExternalPropertyType externalType, MdlInternalPropertyType internalType);
} // namespace cesium::omniverse::FabricUtil
| 2,284 | C | 39.087719 | 117 | 0.788529 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FilesystemUtil.h | #pragma once
#include <filesystem>
namespace cesium::omniverse::FilesystemUtil {
std::filesystem::path getCesiumCacheDirectory();
std::filesystem::path getUserHomeDirectory();
} // namespace cesium::omniverse::FilesystemUtil
| 227 | C | 24.333331 | 48 | 0.792952 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/UsdTokens.h | #pragma once
#include <omni/fabric/FabricUSD.h>
#include <pxr/base/tf/staticTokens.h>
// clang-format off
PXR_NAMESPACE_OPEN_SCOPE
#ifdef CESIUM_OMNI_MSVC
__pragma(warning(push)) __pragma(warning(disable : 4003))
#endif
// Note: variable names should match the USD token names as closely as possible, with special characters converted to underscores
#define USD_TOKENS \
(base_color_texture) \
(cesium_base_color_texture_float4) \
(cesium_feature_id_int) \
(cesium_raster_overlay_float4) \
(cesium_internal_clipping_raster_overlay_resolver) \
(cesium_internal_feature_id_attribute_lookup) \
(cesium_internal_feature_id_texture_lookup) \
(cesium_internal_raster_overlay_lookup) \
(cesium_internal_raster_overlay_resolver) \
(cesium_internal_material) \
(cesium_internal_property_attribute_float_lookup) \
(cesium_internal_property_attribute_float2_lookup) \
(cesium_internal_property_attribute_float3_lookup) \
(cesium_internal_property_attribute_float4_lookup) \
(cesium_internal_property_attribute_int_lookup) \
(cesium_internal_property_attribute_int2_lookup) \
(cesium_internal_property_attribute_int3_lookup) \
(cesium_internal_property_attribute_int4_lookup) \
(cesium_internal_property_attribute_normalized_int_lookup) \
(cesium_internal_property_attribute_normalized_int2_lookup) \
(cesium_internal_property_attribute_normalized_int3_lookup) \
(cesium_internal_property_attribute_normalized_int4_lookup) \
(cesium_internal_property_table_float_lookup) \
(cesium_internal_property_table_float2_lookup) \
(cesium_internal_property_table_float3_lookup) \
(cesium_internal_property_table_float4_lookup) \
(cesium_internal_property_table_int_lookup) \
(cesium_internal_property_table_int2_lookup) \
(cesium_internal_property_table_int3_lookup) \
(cesium_internal_property_table_int4_lookup) \
(cesium_internal_property_table_normalized_int_lookup) \
(cesium_internal_property_table_normalized_int2_lookup) \
(cesium_internal_property_table_normalized_int3_lookup) \
(cesium_internal_property_table_normalized_int4_lookup) \
(cesium_internal_property_texture_int_lookup) \
(cesium_internal_property_texture_int2_lookup) \
(cesium_internal_property_texture_int3_lookup) \
(cesium_internal_property_texture_int4_lookup) \
(cesium_internal_property_texture_normalized_int_lookup) \
(cesium_internal_property_texture_normalized_int2_lookup) \
(cesium_internal_property_texture_normalized_int3_lookup) \
(cesium_internal_property_texture_normalized_int4_lookup) \
(cesium_internal_texture_lookup) \
(cesium_property_float) \
(cesium_property_float2) \
(cesium_property_float3) \
(cesium_property_float4) \
(cesium_property_int) \
(cesium_property_int2) \
(cesium_property_int3) \
(cesium_property_int4) \
(clipping_raster_overlay_resolver) \
(doubleSided) \
(extent) \
(faceVertexCounts) \
(faceVertexIndices) \
(raster_overlay) \
(raster_overlay_resolver) \
(Material) \
(Mesh) \
(none) \
(points) \
(primvarInterpolations) \
(primvars) \
(Shader) \
(sourceAsset) \
(subdivisionScheme) \
(vertex) \
(vertexId) \
(_cesium_gltfLocalToEcefTransform) \
(_cesium_tilesetId) \
(_deletedPrims) \
(_materialSource) \
(_paramColorSpace) \
(_sdrMetadata) \
(_worldExtent) \
(_worldOrientation) \
(_worldPosition) \
(_worldScale) \
(_worldVisibility) \
((info_implementationSource, "info:implementationSource")) \
((info_mdl_sourceAsset, "info:mdl:sourceAsset")) \
((info_mdl_sourceAsset_subIdentifier, "info:mdl:sourceAsset:subIdentifier")) \
((inputs_alpha, "inputs:alpha")) \
((inputs_alpha_clip, "inputs:alpha_clip")) \
((inputs_alpha_cutoff, "inputs:alpha_cutoff")) \
((inputs_alpha_mode, "inputs:alpha_mode")) \
((inputs_base_alpha, "inputs:base_alpha")) \
((inputs_base_color_factor, "inputs:base_color_factor")) \
((inputs_base_color_texture, "inputs:base_color_texture")) \
((inputs_channels, "inputs:channels")) \
((inputs_channel_count, "inputs:channel_count")) \
((inputs_default_value, "inputs:default_value")) \
((inputs_emissive_factor, "inputs:emissive_factor")) \
((inputs_excludeFromWhiteMode, "inputs:excludeFromWhiteMode")) \
((inputs_feature_id, "inputs:feature_id")) \
((inputs_feature_id_set_index, "inputs:feature_id_set_index")) \
((inputs_has_no_data, "inputs:has_no_data")) \
((inputs_raster_overlay, "inputs:raster_overlay")) \
((inputs_raster_overlay_count, "inputs:raster_overlay_count")) \
((inputs_raster_overlay_index, "inputs:raster_overlay_index")) \
((inputs_maximum_value, "inputs:maximum_value")) \
((inputs_metallic_factor, "inputs:metallic_factor")) \
((inputs_no_data, "inputs:no_data")) \
((inputs_null_feature_id, "inputs:null_feature_id")) \
((inputs_offset, "inputs:offset")) \
((inputs_primvar_name, "inputs:primvar_name")) \
((inputs_property_id, "inputs:property_id")) \
((inputs_property_table_texture, "inputs:property_table_texture")) \
((inputs_property_value, "inputs:property_value")) \
((inputs_roughness_factor, "inputs:roughness_factor")) \
((inputs_scale, "inputs:scale")) \
((inputs_texture, "inputs:texture")) \
((inputs_tex_coord_index, "inputs:tex_coord_index")) \
((inputs_tex_coord_offset, "inputs:tex_coord_offset")) \
((inputs_tex_coord_rotation, "inputs:tex_coord_rotation")) \
((inputs_tex_coord_scale, "inputs:tex_coord_scale")) \
((inputs_tile_color, "inputs:tile_color")) \
((inputs_wrap_s, "inputs:wrap_s")) \
((inputs_wrap_t, "inputs:wrap_t")) \
((material_binding, "material:binding")) \
((outputs_mdl_displacement, "outputs:mdl:displacement")) \
((outputs_mdl_surface, "outputs:mdl:surface")) \
((outputs_mdl_volume, "outputs:mdl:volume")) \
((outputs_out, "outputs:out")) \
((primvars_COLOR_0, "primvars:COLOR_0")) \
((primvars_displayColor, "primvars:displayColor")) \
((primvars_displayOpacity, "primvars:displayOpacity")) \
((primvars_normals, "primvars:normals")) \
((primvars_vertexId, "primvars:vertexId")) \
((xformOp_orient, "xformOp:orient")) \
((xformOp_rotateXYZ, "xformOp:rotateXYZ")) \
((xformOp_rotateXZY, "xformOp:rotateXZY")) \
((xformOp_rotateYXZ, "xformOp:rotateYXZ")) \
((xformOp_rotateYZX, "xformOp:rotateYZX")) \
((xformOp_rotateZXY, "xformOp:rotateZXY")) \
((xformOp_rotateZYX, "xformOp:rotateZYX")) \
((xformOp_scale, "xformOp:scale")) \
((xformOp_translate, "xformOp:translate")) \
((_auto, "auto"))
#ifdef CESIUM_OMNI_CLANG
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
#endif
TF_DECLARE_PUBLIC_TOKENS(UsdTokens, USD_TOKENS);
#ifdef CESIUM_OMNI_CLANG
#pragma clang diagnostic pop
#endif
#define FABRIC_DEFINE_TOKEN_ELEM(elem) const omni::fabric::TokenC elem = omni::fabric::asInt(pxr::UsdTokens->elem);
#define FABRIC_DEFINE_TOKEN(r, data, elem) \
BOOST_PP_TUPLE_ELEM(1, 0, BOOST_PP_IIF(TF_PP_IS_TUPLE(elem), \
(FABRIC_DEFINE_TOKEN_ELEM(BOOST_PP_TUPLE_ELEM(2, 0, elem))), \
(FABRIC_DEFINE_TOKEN_ELEM(elem))))
#define FABRIC_DEFINE_TOKENS(seq) BOOST_PP_SEQ_FOR_EACH(FABRIC_DEFINE_TOKEN, ~, seq)
#define FABRIC_DECLARE_TOKEN_ELEM(elem) extern const omni::fabric::TokenC elem;
#define FABRIC_DECLARE_TOKEN(r, data, elem) \
BOOST_PP_TUPLE_ELEM(1, 0, BOOST_PP_IIF(TF_PP_IS_TUPLE(elem), \
(FABRIC_DECLARE_TOKEN_ELEM(BOOST_PP_TUPLE_ELEM(2, 0, elem))), \
(FABRIC_DECLARE_TOKEN_ELEM(elem))))
#define FABRIC_DECLARE_TOKENS(seq) BOOST_PP_SEQ_FOR_EACH(FABRIC_DECLARE_TOKEN, ~, seq)
#ifdef CESIUM_OMNI_MSVC
__pragma(warning(pop))
#endif
PXR_NAMESPACE_CLOSE_SCOPE
namespace cesium::omniverse::FabricTokens {
FABRIC_DECLARE_TOKENS(USD_TOKENS);
const omni::fabric::TokenC feature_id_n(uint64_t index);
const omni::fabric::TokenC raster_overlay_n(uint64_t index);
const omni::fabric::TokenC inputs_raster_overlay_n(uint64_t index);
const omni::fabric::TokenC primvars_st_n(uint64_t index);
const omni::fabric::TokenC property_n(uint64_t index);
}
namespace cesium::omniverse::FabricTypes {
// Due to legacy support the eRelationship type is defined as a scalar value but is secretly an array
const omni::fabric::Type doubleSided(omni::fabric::BaseDataType::eBool, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type extent(omni::fabric::BaseDataType::eDouble, 6, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type faceVertexCounts(omni::fabric::BaseDataType::eInt, 1, 1, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type faceVertexIndices(omni::fabric::BaseDataType::eInt, 1, 1, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type info_implementationSource(omni::fabric::BaseDataType::eToken, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type info_mdl_sourceAsset(omni::fabric::BaseDataType::eAsset, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type info_mdl_sourceAsset_subIdentifier(omni::fabric::BaseDataType::eToken, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_alpha(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_alpha_cutoff(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_alpha_mode(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_base_alpha(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_base_color_factor(omni::fabric::BaseDataType::eFloat, 3, 0, omni::fabric::AttributeRole::eColor);
const omni::fabric::Type inputs_channels(omni::fabric::BaseDataType::eInt, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_channel_count(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_default_value_float(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_default_value_float2(omni::fabric::BaseDataType::eFloat, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_default_value_float3(omni::fabric::BaseDataType::eFloat, 3, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_default_value_float4(omni::fabric::BaseDataType::eFloat, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_default_value_int(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_default_value_int2(omni::fabric::BaseDataType::eInt, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_default_value_int3(omni::fabric::BaseDataType::eInt, 3, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_default_value_int4(omni::fabric::BaseDataType::eInt, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_emissive_factor(omni::fabric::BaseDataType::eFloat, 3, 0, omni::fabric::AttributeRole::eColor);
const omni::fabric::Type inputs_excludeFromWhiteMode(omni::fabric::BaseDataType::eBool, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_has_no_data(omni::fabric::BaseDataType::eBool, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_raster_overlay_count(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_maximum_value_int(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_maximum_value_int2(omni::fabric::BaseDataType::eInt, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_maximum_value_int3(omni::fabric::BaseDataType::eInt, 3, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_maximum_value_int4(omni::fabric::BaseDataType::eInt, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_metallic_factor(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_no_data_float(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_no_data_float2(omni::fabric::BaseDataType::eFloat, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_no_data_float3(omni::fabric::BaseDataType::eFloat, 3, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_no_data_float4(omni::fabric::BaseDataType::eFloat, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_no_data_int(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_no_data_int2(omni::fabric::BaseDataType::eInt, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_no_data_int3(omni::fabric::BaseDataType::eInt, 3, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_no_data_int4(omni::fabric::BaseDataType::eInt, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_null_feature_id(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_offset_float(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_offset_float2(omni::fabric::BaseDataType::eFloat, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_offset_float3(omni::fabric::BaseDataType::eFloat, 3, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_offset_float4(omni::fabric::BaseDataType::eFloat, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_primvar_name(omni::fabric::BaseDataType::eUChar, 1, 1, omni::fabric::AttributeRole::eText);
const omni::fabric::Type inputs_property_table_texture(omni::fabric::BaseDataType::eAsset, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_roughness_factor(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_scale_float(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_scale_float2(omni::fabric::BaseDataType::eFloat, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_scale_float3(omni::fabric::BaseDataType::eFloat, 3, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_scale_float4(omni::fabric::BaseDataType::eFloat, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_texture(omni::fabric::BaseDataType::eAsset, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_tex_coord_index(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_tex_coord_offset(omni::fabric::BaseDataType::eFloat, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_tex_coord_rotation(omni::fabric::BaseDataType::eFloat, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_tex_coord_scale(omni::fabric::BaseDataType::eFloat, 2, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_tile_color(omni::fabric::BaseDataType::eFloat, 4, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_wrap_s(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type inputs_wrap_t(omni::fabric::BaseDataType::eInt, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type Material(omni::fabric::BaseDataType::eTag, 1, 0, omni::fabric::AttributeRole::ePrimTypeName);
const omni::fabric::Type material_binding(omni::fabric::BaseDataType::eRelationship, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type Mesh(omni::fabric::BaseDataType::eTag, 1, 0, omni::fabric::AttributeRole::ePrimTypeName);
const omni::fabric::Type outputs_out(omni::fabric::BaseDataType::eToken, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type points(omni::fabric::BaseDataType::eFloat, 3, 1, omni::fabric::AttributeRole::ePosition);
const omni::fabric::Type primvarInterpolations(omni::fabric::BaseDataType::eToken, 1, 1, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type primvars(omni::fabric::BaseDataType::eToken, 1, 1, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type primvars_COLOR_0(omni::fabric::BaseDataType::eFloat, 4, 1, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type primvars_normals(omni::fabric::BaseDataType::eFloat, 3, 1, omni::fabric::AttributeRole::eNormal);
const omni::fabric::Type primvars_st(omni::fabric::BaseDataType::eFloat, 2, 1, omni::fabric::AttributeRole::eTexCoord);
const omni::fabric::Type primvars_vertexId(omni::fabric::BaseDataType::eFloat, 1, 1, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type Shader(omni::fabric::BaseDataType::eTag, 1, 0, omni::fabric::AttributeRole::ePrimTypeName);
const omni::fabric::Type subdivisionScheme(omni::fabric::BaseDataType::eToken, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type _cesium_gltfLocalToEcefTransform(omni::fabric::BaseDataType::eDouble, 16, 0, omni::fabric::AttributeRole::eMatrix);
const omni::fabric::Type _cesium_tilesetId(omni::fabric::BaseDataType::eInt64, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type _materialSource(omni::fabric::BaseDataType::eRelationship, 1, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type _paramColorSpace(omni::fabric::BaseDataType::eToken, 1, 1, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type _sdrMetadata(omni::fabric::BaseDataType::eToken, 1, 1, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type _worldExtent(omni::fabric::BaseDataType::eDouble, 6, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type _worldOrientation(omni::fabric::BaseDataType::eFloat, 4, 0, omni::fabric::AttributeRole::eQuaternion);
const omni::fabric::Type _worldPosition(omni::fabric::BaseDataType::eDouble, 3, 0, omni::fabric::AttributeRole::eNone);
const omni::fabric::Type _worldScale(omni::fabric::BaseDataType::eFloat, 3, 0, omni::fabric::AttributeRole::eVector);
const omni::fabric::Type _worldVisibility(omni::fabric::BaseDataType::eBool, 1, 0, omni::fabric::AttributeRole::eNone);
}
// clang-format on
| 18,626 | C | 63.453287 | 140 | 0.727102 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/CesiumIonServerManager.h | #pragma once
#include "cesium/omniverse/AssetTroubleshootingDetails.h"
#include "cesium/omniverse/SetDefaultTokenResult.h"
#include "cesium/omniverse/TokenTroubleshootingDetails.h"
#include <pxr/usd/sdf/path.h>
#include <memory>
namespace CesiumIonClient {
struct Token;
}
namespace cesium::omniverse {
class CesiumIonSession;
class Context;
class OmniIonServer;
class CesiumIonServerManager {
public:
CesiumIonServerManager(Context* pContext);
~CesiumIonServerManager() = default;
CesiumIonServerManager(const CesiumIonServerManager&) = delete;
CesiumIonServerManager& operator=(const CesiumIonServerManager&) = delete;
CesiumIonServerManager(CesiumIonServerManager&&) noexcept = delete;
CesiumIonServerManager& operator=(CesiumIonServerManager&&) noexcept = delete;
void onUpdateFrame();
void setProjectDefaultToken(const CesiumIonClient::Token& token);
void connectToIon();
[[nodiscard]] OmniIonServer* getCurrentIonServer() const;
[[nodiscard]] std::shared_ptr<CesiumIonSession> getCurrentIonSession() const;
[[nodiscard]] std::optional<CesiumIonClient::Token> getDefaultToken() const;
[[nodiscard]] SetDefaultTokenResult getSetDefaultTokenResult() const;
[[nodiscard]] bool isDefaultTokenSet() const;
void createToken(const std::string& name);
void selectToken(const CesiumIonClient::Token& token);
void specifyToken(const std::string& token);
[[nodiscard]] std::optional<AssetTroubleshootingDetails> getAssetTroubleshootingDetails() const;
[[nodiscard]] std::optional<TokenTroubleshootingDetails> getAssetTokenTroubleshootingDetails() const;
[[nodiscard]] std::optional<TokenTroubleshootingDetails> getDefaultTokenTroubleshootingDetails() const;
void updateTroubleshootingDetails(
const pxr::SdfPath& tilesetPath,
int64_t tilesetIonAssetId,
uint64_t tokenEventId,
uint64_t assetEventId);
void updateTroubleshootingDetails(
const pxr::SdfPath& tilesetPath,
[[maybe_unused]] int64_t tilesetIonAssetId,
int64_t rasterOverlayIonAssetId,
uint64_t tokenEventId,
uint64_t assetEventId);
void updateTokenTroubleshootingDetails(
int64_t assetId,
const std::string& token,
uint64_t eventId,
TokenTroubleshootingDetails& details);
void updateAssetTroubleshootingDetails(int64_t assetId, uint64_t eventId, AssetTroubleshootingDetails& details);
private:
Context* _pContext;
SetDefaultTokenResult _lastSetTokenResult;
std::optional<AssetTroubleshootingDetails> _assetTroubleshootingDetails;
std::optional<TokenTroubleshootingDetails> _assetTokenTroubleshootingDetails;
std::optional<TokenTroubleshootingDetails> _defaultTokenTroubleshootingDetails;
};
} // namespace cesium::omniverse
| 2,814 | C | 37.561643 | 116 | 0.762615 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricStatistics.h | #pragma once
#include <cstdint>
namespace cesium::omniverse {
struct FabricStatistics {
uint64_t materialsCapacity{0};
uint64_t materialsLoaded{0};
uint64_t geometriesCapacity{0};
uint64_t geometriesLoaded{0};
uint64_t geometriesRendered{0};
uint64_t trianglesLoaded{0};
uint64_t trianglesRendered{0};
};
} // namespace cesium::omniverse
| 370 | C | 19.61111 | 35 | 0.718919 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/OmniRasterOverlay.h | #pragma once
#include "cesium/omniverse/OmniTileset.h"
#include <CesiumRasterOverlays/RasterOverlay.h>
#include <pxr/usd/sdf/path.h>
namespace CesiumRasterOverlays {
class RasterOverlay;
}
namespace cesium::omniverse {
class Context;
class OmniTileset;
enum class FabricOverlayRenderMethod;
class OmniRasterOverlay {
friend void OmniTileset::addRasterOverlayIfExists(const OmniRasterOverlay* pOverlay);
friend pxr::SdfPath
OmniTileset::getRasterOverlayPathIfExists(const CesiumRasterOverlays::RasterOverlay& rasterOverlay);
public:
OmniRasterOverlay(Context* pContext, const pxr::SdfPath& path);
virtual ~OmniRasterOverlay() = default;
OmniRasterOverlay(const OmniRasterOverlay&) = delete;
OmniRasterOverlay& operator=(const OmniRasterOverlay&) = delete;
OmniRasterOverlay(OmniRasterOverlay&&) noexcept = default;
OmniRasterOverlay& operator=(OmniRasterOverlay&&) noexcept = default;
[[nodiscard]] const pxr::SdfPath& getPath() const;
[[nodiscard]] bool getShowCreditsOnScreen() const;
[[nodiscard]] double getAlpha() const;
[[nodiscard]] FabricOverlayRenderMethod getOverlayRenderMethod() const;
[[nodiscard]] float getMaximumScreenSpaceError() const;
[[nodiscard]] int getMaximumTextureSize() const;
[[nodiscard]] int getMaximumSimultaneousTileLoads() const;
[[nodiscard]] int getSubTileCacheBytes() const;
[[nodiscard]] CesiumRasterOverlays::RasterOverlayOptions createRasterOverlayOptions() const;
void updateRasterOverlayOptions() const;
virtual void reload() = 0;
protected:
[[nodiscard]] virtual CesiumRasterOverlays::RasterOverlay* getRasterOverlay() const = 0;
Context* _pContext;
pxr::SdfPath _path;
private:
void setRasterOverlayOptionsFromUsd(CesiumRasterOverlays::RasterOverlayOptions& options) const;
};
} // namespace cesium::omniverse
| 1,865 | C | 33.555555 | 104 | 0.764611 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/OmniIonRasterOverlay.h | #pragma once
#include "cesium/omniverse/OmniRasterOverlay.h"
#include <CesiumRasterOverlays/IonRasterOverlay.h>
#include <CesiumUtility/IntrusivePointer.h>
namespace CesiumIonClient {
struct Token;
}
namespace cesium::omniverse {
class OmniIonRasterOverlay final : public OmniRasterOverlay {
public:
OmniIonRasterOverlay(Context* pContext, const pxr::SdfPath& path);
~OmniIonRasterOverlay() override = default;
OmniIonRasterOverlay(const OmniIonRasterOverlay&) = delete;
OmniIonRasterOverlay& operator=(const OmniIonRasterOverlay&) = delete;
OmniIonRasterOverlay(OmniIonRasterOverlay&&) noexcept = default;
OmniIonRasterOverlay& operator=(OmniIonRasterOverlay&&) noexcept = default;
[[nodiscard]] int64_t getIonAssetId() const;
[[nodiscard]] CesiumIonClient::Token getIonAccessToken() const;
[[nodiscard]] std::string getIonApiUrl() const;
[[nodiscard]] pxr::SdfPath getResolvedIonServerPath() const;
[[nodiscard]] CesiumRasterOverlays::RasterOverlay* getRasterOverlay() const override;
void reload() override;
private:
CesiumUtility::IntrusivePointer<CesiumRasterOverlays::IonRasterOverlay> _pIonRasterOverlay;
};
} // namespace cesium::omniverse
| 1,212 | C | 33.657142 | 95 | 0.771452 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/AssetRegistry.h | #pragma once
#include <pxr/usd/usd/common.h>
#include <vector>
#include <gsl/span>
namespace cesium::omniverse {
class Context;
class OmniCartographicPolygon;
class OmniData;
class OmniGeoreference;
class OmniGlobeAnchor;
class OmniRasterOverlay;
class OmniIonRasterOverlay;
class OmniIonServer;
class OmniPolygonRasterOverlay;
class OmniTileset;
class OmniWebMapServiceRasterOverlay;
class OmniTileMapServiceRasterOverlay;
class OmniWebMapTileServiceRasterOverlay;
struct Viewport;
enum AssetType {
DATA,
TILESET,
ION_RASTER_OVERLAY,
POLYGON_RASTER_OVERLAY,
WEB_MAP_SERVICE_RASTER_OVERLAY,
TILE_MAP_SERVICE_RASTER_OVERLAY,
WEB_MAP_TILE_SERVICE_RASTER_OVERLAY,
GEOREFERENCE,
GLOBE_ANCHOR,
ION_SERVER,
CARTOGRAPHIC_POLYGON,
OTHER,
};
class AssetRegistry {
public:
AssetRegistry(Context* pContext);
~AssetRegistry();
AssetRegistry(const AssetRegistry&) = delete;
AssetRegistry& operator=(const AssetRegistry&) = delete;
AssetRegistry(AssetRegistry&&) noexcept = delete;
AssetRegistry& operator=(AssetRegistry&&) noexcept = delete;
void onUpdateFrame(const gsl::span<const Viewport>& viewports, bool waitForLoadingTiles);
OmniData& addData(const pxr::SdfPath& path);
void removeData(const pxr::SdfPath& path);
[[nodiscard]] OmniData* getData(const pxr::SdfPath& path) const;
[[nodiscard]] OmniData* getFirstData() const;
OmniTileset& addTileset(const pxr::SdfPath& path);
void removeTileset(const pxr::SdfPath& path);
[[nodiscard]] OmniTileset* getTileset(const pxr::SdfPath& path) const;
[[nodiscard]] const std::vector<std::unique_ptr<OmniTileset>>& getTilesets() const;
OmniIonRasterOverlay& addIonRasterOverlay(const pxr::SdfPath& path);
void removeIonRasterOverlay(const pxr::SdfPath& path);
[[nodiscard]] OmniIonRasterOverlay* getIonRasterOverlay(const pxr::SdfPath& path) const;
[[nodiscard]] OmniIonRasterOverlay* getIonRasterOverlayByIonAssetId(int64_t ionAssetId) const;
[[nodiscard]] const std::vector<std::unique_ptr<OmniIonRasterOverlay>>& getIonRasterOverlays() const;
OmniPolygonRasterOverlay& addPolygonRasterOverlay(const pxr::SdfPath& path);
void removePolygonRasterOverlay(const pxr::SdfPath& path);
[[nodiscard]] OmniPolygonRasterOverlay* getPolygonRasterOverlay(const pxr::SdfPath& path) const;
[[nodiscard]] const std::vector<std::unique_ptr<OmniPolygonRasterOverlay>>& getPolygonRasterOverlays() const;
OmniWebMapServiceRasterOverlay& addWebMapServiceRasterOverlay(const pxr::SdfPath& path);
void removeWebMapServiceRasterOverlay(const pxr::SdfPath& path);
[[nodiscard]] OmniWebMapServiceRasterOverlay* getWebMapServiceRasterOverlay(const pxr::SdfPath& path) const;
OmniTileMapServiceRasterOverlay& addTileMapServiceRasterOverlay(const pxr::SdfPath& path);
void removeTileMapServiceRasterOverlay(const pxr::SdfPath& path);
[[nodiscard]] OmniTileMapServiceRasterOverlay* getTileMapServiceRasterOverlay(const pxr::SdfPath& path) const;
OmniWebMapTileServiceRasterOverlay& addWebMapTileServiceRasterOverlay(const pxr::SdfPath& path);
void removeWebMapTileServiceRasterOverlay(const pxr::SdfPath& path);
[[nodiscard]] OmniWebMapTileServiceRasterOverlay* getWebMapTileServiceRasterOverlay(const pxr::SdfPath& path) const;
[[nodiscard]] OmniRasterOverlay* getRasterOverlay(const pxr::SdfPath& path) const;
OmniGeoreference& addGeoreference(const pxr::SdfPath& path);
void removeGeoreference(const pxr::SdfPath& path);
[[nodiscard]] OmniGeoreference* getGeoreference(const pxr::SdfPath& path) const;
[[nodiscard]] const std::vector<std::unique_ptr<OmniGeoreference>>& getGeoreferences() const;
[[nodiscard]] OmniGeoreference* getFirstGeoreference() const;
OmniGlobeAnchor& addGlobeAnchor(const pxr::SdfPath& path);
void removeGlobeAnchor(const pxr::SdfPath& path);
[[nodiscard]] OmniGlobeAnchor* getGlobeAnchor(const pxr::SdfPath& path) const;
[[nodiscard]] const std::vector<std::unique_ptr<OmniGlobeAnchor>>& getGlobeAnchors() const;
OmniIonServer& addIonServer(const pxr::SdfPath& path);
void removeIonServer(const pxr::SdfPath& path);
[[nodiscard]] OmniIonServer* getIonServer(const pxr::SdfPath& path) const;
[[nodiscard]] const std::vector<std::unique_ptr<OmniIonServer>>& getIonServers() const;
[[nodiscard]] OmniIonServer* getFirstIonServer() const;
OmniCartographicPolygon& addCartographicPolygon(const pxr::SdfPath& path);
void removeCartographicPolygon(const pxr::SdfPath& path);
[[nodiscard]] OmniCartographicPolygon* getCartographicPolygon(const pxr::SdfPath& path) const;
[[nodiscard]] const std::vector<std::unique_ptr<OmniCartographicPolygon>>& getCartographicPolygons() const;
[[nodiscard]] AssetType getAssetType(const pxr::SdfPath& path) const;
[[nodiscard]] bool hasAsset(const pxr::SdfPath& path) const;
void clear();
private:
Context* _pContext;
std::vector<std::unique_ptr<OmniData>> _datas;
std::vector<std::unique_ptr<OmniTileset>> _tilesets;
std::vector<std::unique_ptr<OmniIonRasterOverlay>> _ionRasterOverlays;
std::vector<std::unique_ptr<OmniPolygonRasterOverlay>> _polygonRasterOverlays;
std::vector<std::unique_ptr<OmniWebMapServiceRasterOverlay>> _webMapServiceRasterOverlays;
std::vector<std::unique_ptr<OmniTileMapServiceRasterOverlay>> _tileMapServiceRasterOverlays;
std::vector<std::unique_ptr<OmniWebMapTileServiceRasterOverlay>> _webMapTileServiceRasterOverlays;
std::vector<std::unique_ptr<OmniGeoreference>> _georeferences;
std::vector<std::unique_ptr<OmniGlobeAnchor>> _globeAnchors;
std::vector<std::unique_ptr<OmniIonServer>> _ionServers;
std::vector<std::unique_ptr<OmniCartographicPolygon>> _cartographicPolygons;
int64_t _tilesetId{0};
};
} // namespace cesium::omniverse
| 5,880 | C | 43.55303 | 120 | 0.763095 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/MetadataUtil.h | #pragma once
#include "cesium/omniverse/Context.h"
#include "cesium/omniverse/DataType.h"
#include "cesium/omniverse/FabricPropertyInfo.h"
#include "cesium/omniverse/GltfUtil.h"
#include "cesium/omniverse/Logger.h"
#include <CesiumGltf/ExtensionExtMeshFeatures.h>
#include <CesiumGltf/ExtensionMeshPrimitiveExtStructuralMetadata.h>
#include <CesiumGltf/ExtensionModelExtStructuralMetadata.h>
#include <CesiumGltf/PropertyAttribute.h>
#include <CesiumGltf/PropertyAttributeView.h>
#include <CesiumGltf/PropertyTableView.h>
#include <CesiumGltf/PropertyTexture.h>
#include <CesiumGltf/PropertyTextureView.h>
namespace cesium::omniverse {
struct FabricPropertyDescriptor;
struct FabricTextureData;
} // namespace cesium::omniverse
namespace cesium::omniverse::MetadataUtil {
template <typename Callback, typename UnsupportedCallback>
void forEachPropertyAttributeProperty(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
Callback&& callback,
const UnsupportedCallback& unsupportedCallback) {
const auto pStructuralMetadataModel = model.getExtension<CesiumGltf::ExtensionModelExtStructuralMetadata>();
if (!pStructuralMetadataModel) {
return;
}
const auto pStructuralMetadataPrimitive =
primitive.getExtension<CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata>();
if (!pStructuralMetadataPrimitive) {
return;
}
for (const auto& propertyAttributeIndex : pStructuralMetadataPrimitive->propertyAttributes) {
const auto pPropertyAttribute =
model.getSafe(&pStructuralMetadataModel->propertyAttributes, static_cast<int32_t>(propertyAttributeIndex));
if (!pPropertyAttribute) {
context.getLogger()->warn("Property attribute index {} is out of range.", propertyAttributeIndex);
continue;
}
const auto propertyAttributeView = CesiumGltf::PropertyAttributeView(model, *pPropertyAttribute);
if (propertyAttributeView.status() != CesiumGltf::PropertyAttributeViewStatus::Valid) {
context.getLogger()->warn(
"Property attribute is invalid and will be ignored. Status code: {}",
static_cast<int>(propertyAttributeView.status()));
continue;
}
propertyAttributeView.forEachProperty(
primitive,
[&context,
callback = std::forward<Callback>(callback),
&unsupportedCallback,
&propertyAttributeView,
&pStructuralMetadataModel,
&pPropertyAttribute](const std::string& propertyId, const auto& propertyAttributePropertyView) {
if (propertyAttributePropertyView.status() != CesiumGltf::PropertyAttributePropertyViewStatus::Valid) {
unsupportedCallback(
propertyId,
fmt::format(
"Property \"{}\" is invalid and will be ignored. Status code: {}",
propertyId,
static_cast<int>(propertyAttributePropertyView.status())));
return;
}
const auto& schema = pStructuralMetadataModel->schema;
if (!schema.has_value()) {
unsupportedCallback(
propertyId, fmt::format("No schema found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto pClassDefinition = propertyAttributeView.getClass();
if (!pClassDefinition) {
unsupportedCallback(
propertyId, fmt::format("No class found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto pClassProperty = propertyAttributeView.getClassProperty(propertyId);
if (!pClassProperty) {
unsupportedCallback(
propertyId,
fmt::format("No class property found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto& propertyAttributeProperty = pPropertyAttribute->properties.at(propertyId);
callback(
propertyId,
schema.value(),
*pClassDefinition,
*pClassProperty,
*pPropertyAttribute,
propertyAttributeProperty,
propertyAttributeView,
propertyAttributePropertyView);
});
}
}
template <typename Callback, typename UnsupportedCallback>
void forEachPropertyTextureProperty(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
Callback&& callback,
const UnsupportedCallback& unsupportedCallback) {
const auto pStructuralMetadataModel = model.getExtension<CesiumGltf::ExtensionModelExtStructuralMetadata>();
if (!pStructuralMetadataModel) {
return;
}
const auto pStructuralMetadataPrimitive =
primitive.getExtension<CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata>();
if (!pStructuralMetadataPrimitive) {
return;
}
for (const auto& propertyTextureIndex : pStructuralMetadataPrimitive->propertyTextures) {
const auto pPropertyTexture =
model.getSafe(&pStructuralMetadataModel->propertyTextures, static_cast<int32_t>(propertyTextureIndex));
if (!pPropertyTexture) {
context.getLogger()->warn(fmt::format("Property texture index {} is out of range.", propertyTextureIndex));
continue;
}
const auto propertyTextureView = CesiumGltf::PropertyTextureView(model, *pPropertyTexture);
if (propertyTextureView.status() != CesiumGltf::PropertyTextureViewStatus::Valid) {
context.getLogger()->warn(
"Property texture is invalid and will be ignored. Status code: {}",
static_cast<int>(propertyTextureView.status()));
continue;
}
propertyTextureView.forEachProperty(
[&context,
callback = std::forward<Callback>(callback),
&unsupportedCallback,
&propertyTextureView,
&pStructuralMetadataModel,
&pPropertyTexture](const std::string& propertyId, const auto& propertyTexturePropertyView) {
if (propertyTexturePropertyView.status() != CesiumGltf::PropertyTexturePropertyViewStatus::Valid) {
unsupportedCallback(
propertyId,
fmt::format(
"Property \"{}\" is invalid and will be ignored. Status code: {}",
propertyId,
static_cast<int>(propertyTexturePropertyView.status())));
return;
}
const auto& schema = pStructuralMetadataModel->schema;
if (!schema.has_value()) {
unsupportedCallback(
propertyId, fmt::format("No schema found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto pClassDefinition = propertyTextureView.getClass();
if (!pClassDefinition) {
unsupportedCallback(
propertyId, fmt::format("No class found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto pClassProperty = propertyTextureView.getClassProperty(propertyId);
if (!pClassProperty) {
unsupportedCallback(
propertyId,
fmt::format("No class property found. Property \"{}\" will be ignored.", propertyId));
return;
}
if (!propertyTexturePropertyView.getImage()) {
unsupportedCallback(
propertyId, fmt::format("No image found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto& propertyTextureProperty = pPropertyTexture->properties.at(propertyId);
callback(
propertyId,
schema.value(),
*pClassDefinition,
*pClassProperty,
*pPropertyTexture,
propertyTextureProperty,
propertyTextureView,
propertyTexturePropertyView);
});
}
}
template <typename Callback, typename UnsupportedCallback>
void forEachPropertyTableProperty(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
Callback&& callback,
const UnsupportedCallback& unsupportedCallback) {
const auto pStructuralMetadataModel = model.getExtension<CesiumGltf::ExtensionModelExtStructuralMetadata>();
if (!pStructuralMetadataModel) {
return;
}
const auto pMeshFeatures = primitive.getExtension<CesiumGltf::ExtensionExtMeshFeatures>();
if (!pMeshFeatures) {
return;
}
for (uint64_t i = 0; i < pMeshFeatures->featureIds.size(); ++i) {
const auto featureIdSetIndex = i;
const auto& featureId = pMeshFeatures->featureIds[featureIdSetIndex];
if (featureId.propertyTable.has_value()) {
const auto pPropertyTable = model.getSafe(
&pStructuralMetadataModel->propertyTables, static_cast<int32_t>(featureId.propertyTable.value()));
if (!pPropertyTable) {
context.getLogger()->warn(
fmt::format("Property table index {} is out of range.", featureId.propertyTable.value()));
continue;
}
const auto propertyTableView = CesiumGltf::PropertyTableView(model, *pPropertyTable);
if (propertyTableView.status() != CesiumGltf::PropertyTableViewStatus::Valid) {
context.getLogger()->warn(
"Property table is invalid and will be ignored. Status code: {}",
static_cast<int>(propertyTableView.status()));
continue;
}
propertyTableView.forEachProperty(
[&context,
callback = std::forward<Callback>(callback),
&unsupportedCallback,
&propertyTableView,
&pStructuralMetadataModel,
&pPropertyTable,
featureIdSetIndex](const std::string& propertyId, const auto& propertyTablePropertyView) {
if (propertyTablePropertyView.status() != CesiumGltf::PropertyTablePropertyViewStatus::Valid) {
unsupportedCallback(
propertyId,
fmt::format(
"Property \"{}\" is invalid and will be ignored. Status code: {}",
propertyId,
static_cast<int>(propertyTablePropertyView.status())));
return;
}
const auto& schema = pStructuralMetadataModel->schema;
if (!schema.has_value()) {
unsupportedCallback(
propertyId, fmt::format("No schema found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto pClassDefinition = propertyTableView.getClass();
if (!pClassDefinition) {
unsupportedCallback(
propertyId, fmt::format("No class found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto pClassProperty = propertyTableView.getClassProperty(propertyId);
if (!pClassProperty) {
unsupportedCallback(
propertyId,
fmt::format("No class property found. Property \"{}\" will be ignored.", propertyId));
return;
}
const auto& propertyTableProperty = pPropertyTable->properties.at(propertyId);
callback(
propertyId,
schema.value(),
*pClassDefinition,
*pClassProperty,
*pPropertyTable,
propertyTableProperty,
propertyTableView,
propertyTablePropertyView,
featureIdSetIndex);
});
}
}
}
template <typename Callback, typename UnsupportedCallback>
void forEachStyleablePropertyAttributeProperty(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
Callback&& callback,
const UnsupportedCallback& unsupportedCallback) {
forEachPropertyAttributeProperty(
context,
model,
primitive,
[&context, callback = std::forward<Callback>(callback), &unsupportedCallback](
const std::string& propertyId,
[[maybe_unused]] const CesiumGltf::Schema& schema,
[[maybe_unused]] const CesiumGltf::Class& classDefinition,
[[maybe_unused]] const CesiumGltf::ClassProperty& classProperty,
[[maybe_unused]] const CesiumGltf::PropertyAttribute& propertyAttribute,
const CesiumGltf::PropertyAttributeProperty& propertyAttributeProperty,
[[maybe_unused]] const CesiumGltf::PropertyAttributeView& propertyAttributeView,
const auto& propertyAttributePropertyView) {
using RawType = decltype(propertyAttributePropertyView.getRaw(0));
using TransformedType = typename std::decay_t<decltype(propertyAttributePropertyView.get(0))>::value_type;
constexpr auto type = DataTypeUtil::getTypeReverse<RawType, TransformedType>();
if constexpr (DataTypeUtil::isMatrix<type>()) {
unsupportedCallback(
propertyId,
fmt::format(
"Matrix properties are not supported for styling. Property \"{}\" will be ignored.",
propertyId));
return;
} else {
const auto& attribute = propertyAttributeProperty.attribute;
// For some reason the static cast is needed in MSVC
const auto propertyInfo = FabricPropertyInfo<static_cast<cesium::omniverse::DataType>(type)>{
propertyAttributePropertyView.offset(),
propertyAttributePropertyView.scale(),
propertyAttributePropertyView.min(),
propertyAttributePropertyView.max(),
propertyAttributePropertyView.required(),
propertyAttributePropertyView.noData(),
propertyAttributePropertyView.defaultValue(),
};
const auto property =
FabricPropertyAttributePropertyInfo<static_cast<cesium::omniverse::DataType>(type)>{
attribute,
propertyInfo,
};
callback(propertyId, propertyAttributePropertyView, property);
}
},
unsupportedCallback);
}
template <typename Callback, typename UnsupportedCallback>
void forEachStyleablePropertyTextureProperty(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
Callback&& callback,
const UnsupportedCallback& unsupportedCallback) {
forEachPropertyTextureProperty(
context,
model,
primitive,
[&context, callback = std::forward<Callback>(callback), &unsupportedCallback, &model](
const std::string& propertyId,
[[maybe_unused]] const CesiumGltf::Schema& schema,
[[maybe_unused]] const CesiumGltf::Class& classDefinition,
[[maybe_unused]] const CesiumGltf::ClassProperty& classProperty,
[[maybe_unused]] const CesiumGltf::PropertyTexture& propertyTexture,
const CesiumGltf::PropertyTextureProperty& propertyTextureProperty,
[[maybe_unused]] const CesiumGltf::PropertyTextureView& propertyTextureView,
const auto& propertyTexturePropertyView) {
using RawType = decltype(propertyTexturePropertyView.getRaw(0.0, 0.0));
using TransformedType =
typename std::decay_t<decltype(propertyTexturePropertyView.get(0.0, 0.0))>::value_type;
constexpr auto IsArray = HAS_MEMBER(RawType, size());
if constexpr (IsArray) {
unsupportedCallback(
propertyId,
fmt::format(
"Array properties are not supported for styling. Property \"{}\" will be ignored.",
propertyId));
return;
} else {
constexpr auto type = DataTypeUtil::getTypeReverse<RawType, TransformedType>();
if constexpr (DataTypeUtil::getComponentByteLength<type>() > 1) {
unsupportedCallback(
propertyId,
fmt::format(
"Only 8-bit per-component property texture properties are supported for styling. Property "
"\"{}\" will be ignored.",
propertyId));
return;
} else {
const auto textureInfo = GltfUtil::getPropertyTexturePropertyInfo(model, propertyTextureProperty);
if (textureInfo.channels.size() != DataTypeUtil::getComponentCount<type>()) {
unsupportedCallback(
propertyId,
fmt::format(
"Properties with components that are packed across multiple texture channels are not "
"supported for styling. Property \"{}\" will be ignored.",
propertyId));
return;
}
if (textureInfo.channels.size() > 4) {
unsupportedCallback(
propertyId,
fmt::format(
"Properties with more than four channels are not supported for styling. Property "
"\"{}\" will be ignored.",
propertyId));
return;
}
const auto propertyInfo = FabricPropertyInfo<static_cast<cesium::omniverse::DataType>(type)>{
propertyTexturePropertyView.offset(),
propertyTexturePropertyView.scale(),
propertyTexturePropertyView.min(),
propertyTexturePropertyView.max(),
propertyTexturePropertyView.required(),
propertyTexturePropertyView.noData(),
propertyTexturePropertyView.defaultValue(),
};
const auto property =
FabricPropertyTexturePropertyInfo<static_cast<cesium::omniverse::DataType>(type)>{
textureInfo,
static_cast<uint64_t>(propertyTextureProperty.index),
propertyInfo,
};
callback(propertyId, propertyTexturePropertyView, property);
}
}
},
unsupportedCallback);
}
template <typename Callback, typename UnsupportedCallback>
void forEachStyleablePropertyTableProperty(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
Callback&& callback,
const UnsupportedCallback& unsupportedCallback) {
forEachPropertyTableProperty(
context,
model,
primitive,
[&context, callback = std::forward<Callback>(callback), &unsupportedCallback](
const std::string& propertyId,
[[maybe_unused]] const CesiumGltf::Schema& schema,
[[maybe_unused]] const CesiumGltf::Class& classDefinition,
[[maybe_unused]] const CesiumGltf::ClassProperty& classProperty,
[[maybe_unused]] const CesiumGltf::PropertyTable& propertyTable,
[[maybe_unused]] const CesiumGltf::PropertyTableProperty& propertyTableProperty,
[[maybe_unused]] const CesiumGltf::PropertyTableView& propertyTableView,
const auto& propertyTablePropertyView,
uint64_t featureIdSetIndex) {
using RawType = decltype(propertyTablePropertyView.getRaw(0));
using TransformedType = typename std::decay_t<decltype(propertyTablePropertyView.get(0))>::value_type;
constexpr auto IsArray = HAS_MEMBER(RawType, size());
constexpr auto IsBoolean = std::is_same_v<RawType, bool>;
constexpr auto IsString = std::is_same_v<RawType, std::string_view>;
if constexpr (IsArray) {
unsupportedCallback(
propertyId,
fmt::format(
"Array properties are not supported for styling. Property \"{}\" will be ignored.",
propertyId));
return;
} else if constexpr (IsBoolean) {
unsupportedCallback(
propertyId,
fmt::format(
"Boolean properties are not supported for styling. Property \"{}\" will be ignored.",
propertyId));
return;
} else if constexpr (IsString) {
unsupportedCallback(
propertyId,
fmt::format(
"String properties are not supported for styling. Property \"{}\" will be ignored.",
propertyId));
return;
} else {
constexpr auto type = DataTypeUtil::getTypeReverse<RawType, TransformedType>();
constexpr auto unnormalizedComponentType = DataTypeUtil::getUnnormalizedComponentType<type>();
if constexpr (DataTypeUtil::isMatrix<type>()) {
unsupportedCallback(
propertyId,
fmt::format(
"Matrix properties are not supported for styling. Property \"{}\" will be ignored.",
propertyId));
return;
} else if constexpr (unnormalizedComponentType == DataType::UINT32) {
unsupportedCallback(
propertyId,
fmt::format(
"UINT32 properties are not supported for styling due to potential precision loss. Property "
"\"{}\" will be ignored.",
propertyId));
return;
} else if constexpr (unnormalizedComponentType == DataType::UINT64) {
unsupportedCallback(
propertyId,
fmt::format(
"UINT64 properties are not supported for styling due to potential precision loss. Property "
"\"{}\" will be ignored.",
propertyId));
return;
} else if constexpr (unnormalizedComponentType == DataType::INT64) {
unsupportedCallback(
propertyId,
fmt::format(
"INT64 properties are not supported for styling due to potential precision loss. Property "
"\"{}\" will be ignored.",
propertyId));
return;
} else {
if constexpr (unnormalizedComponentType == DataType::FLOAT64) {
unsupportedCallback(
propertyId,
fmt::format(
"64-bit float properties are converted to 32-bit floats for styling. Some precision "
"loss "
"may occur for property \"{}\".",
propertyId));
}
const auto propertyInfo = FabricPropertyInfo<static_cast<cesium::omniverse::DataType>(type)>{
propertyTablePropertyView.offset(),
propertyTablePropertyView.scale(),
propertyTablePropertyView.min(),
propertyTablePropertyView.max(),
propertyTablePropertyView.required(),
propertyTablePropertyView.noData(),
propertyTablePropertyView.defaultValue(),
};
const auto property =
FabricPropertyTablePropertyInfo<static_cast<cesium::omniverse::DataType>(type)>{
featureIdSetIndex,
propertyInfo,
};
callback(propertyId, propertyTablePropertyView, property);
}
}
},
unsupportedCallback);
}
std::tuple<std::vector<FabricPropertyDescriptor>, std::map<std::string, std::string>> getStyleableProperties(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive);
std::vector<const CesiumGltf::ImageCesium*> getPropertyTextureImages(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive);
std::unordered_map<uint64_t, uint64_t> getPropertyTextureIndexMapping(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive);
std::vector<FabricTextureData> encodePropertyTables(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive);
uint64_t getPropertyTableTextureCount(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive);
} // namespace cesium::omniverse::MetadataUtil
| 26,987 | C | 44.130435 | 120 | 0.561974 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/SettingsWrapper.h | #pragma once
#include <cstdint>
#include <string>
#include <vector>
namespace cesium::omniverse::Settings {
struct AccessToken {
std::string ionApiUrl;
std::string accessToken;
};
std::vector<AccessToken> getAccessTokens();
void setAccessToken(const AccessToken& accessToken);
void removeAccessToken(const std::string& ionApiUrl);
void clearTokens();
uint64_t getMaxCacheItems();
} // namespace cesium::omniverse::Settings
| 437 | C | 18.90909 | 53 | 0.757437 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricRenderResources.h | #pragma once
#include <glm/glm.hpp>
#include <vector>
namespace cesium::omniverse {
struct FabricMesh;
struct FabricRenderResources {
FabricRenderResources() = default;
~FabricRenderResources() = default;
FabricRenderResources(const FabricRenderResources&) = delete;
FabricRenderResources& operator=(const FabricRenderResources&) = delete;
FabricRenderResources(FabricRenderResources&&) noexcept = default;
FabricRenderResources& operator=(FabricRenderResources&&) noexcept = default;
std::vector<FabricMesh> fabricMeshes;
};
} // namespace cesium::omniverse
| 594 | C | 24.869564 | 81 | 0.762626 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/UsdUtil.h | #pragma once
#include "CesiumUsdSchemas/rasterOverlay.h"
#include <glm/fwd.hpp>
#include <pxr/base/gf/declare.h>
#include <pxr/usd/usd/common.h>
#include <pxr/usd/usdGeom/basisCurves.h>
#include <pxr/usd/usdGeom/xformOp.h>
PXR_NAMESPACE_OPEN_SCOPE
class CesiumData;
class CesiumGeoreference;
class CesiumGlobeAnchorAPI;
class CesiumRasterOverlay;
class CesiumIonRasterOverlay;
class CesiumIonServer;
class CesiumPolygonRasterOverlay;
class CesiumSession;
class CesiumTileset;
class CesiumWebMapServiceRasterOverlay;
class CesiumTileMapServiceRasterOverlay;
class CesiumWebMapTileServiceRasterOverlay;
class UsdGeomBasisCurves;
class UsdGeomXformable;
class UsdGeomXformOp;
class UsdShadeShader;
PXR_NAMESPACE_CLOSE_SCOPE
namespace Cesium3DTilesSelection {
class ViewState;
}
namespace CesiumGeospatial {
class Cartographic;
class Ellipsoid;
class LocalHorizontalCoordinateSystem;
} // namespace CesiumGeospatial
namespace cesium::omniverse {
class Context;
struct Viewport;
} // namespace cesium::omniverse
namespace cesium::omniverse::MathUtil {
enum class EulerAngleOrder;
}
namespace cesium::omniverse::UsdUtil {
glm::dvec3 usdToGlmVector(const pxr::GfVec3d& vector);
glm::fvec3 usdToGlmVector(const pxr::GfVec3f& vector);
glm::dmat4 usdToGlmMatrix(const pxr::GfMatrix4d& matrix);
glm::dquat usdToGlmQuat(const pxr::GfQuatd& quat);
glm::fquat usdToGlmQuat(const pxr::GfQuatf& quat);
std::array<glm::dvec3, 2> usdToGlmExtent(const pxr::GfRange3d& extent);
pxr::GfVec3d glmToUsdVector(const glm::dvec3& vector);
pxr::GfVec2f glmToUsdVector(const glm::fvec2& vector);
pxr::GfVec3f glmToUsdVector(const glm::fvec3& vector);
pxr::GfVec4f glmToUsdVector(const glm::fvec4& vector);
pxr::GfRange3d glmToUsdExtent(const std::array<glm::dvec3, 2>& extent);
pxr::GfQuatd glmToUsdQuat(const glm::dquat& quat);
pxr::GfQuatf glmToUsdQuat(const glm::fquat& quat);
pxr::GfMatrix4d glmToUsdMatrix(const glm::dmat4& matrix);
glm::dmat4 computePrimLocalToWorldTransform(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
glm::dmat4 computePrimWorldToLocalTransform(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
glm::dmat4 computeEcefToStageTransform(const Context& context, const pxr::SdfPath& georeferencePath);
glm::dmat4 computeEcefToPrimWorldTransform(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath);
glm::dmat4 computePrimWorldToEcefTransform(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath);
glm::dmat4 computeEcefToPrimLocalTransform(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath);
glm::dmat4 computePrimLocalToEcefTransform(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath);
CesiumGeospatial::LocalHorizontalCoordinateSystem computeLocalCoordinateSystem(
const pxr::UsdStageWeakPtr& pStage,
const CesiumGeospatial::Cartographic& origin,
const CesiumGeospatial::Ellipsoid& ellipsoid);
Cesium3DTilesSelection::ViewState computeViewState(
const Context& context,
const pxr::SdfPath& georeferencePath,
const pxr::SdfPath& primPath,
const Viewport& viewport);
bool primExists(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isSchemaValid(const pxr::UsdSchemaBase& schema);
bool isPrimVisible(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
const std::string& getName(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::TfToken getUsdUpAxis(const pxr::UsdStageWeakPtr& pStage);
double getUsdMetersPerUnit(const pxr::UsdStageWeakPtr& pStage);
pxr::SdfPath getRootPath(const pxr::UsdStageWeakPtr& pStage);
pxr::SdfPath
makeUniquePath(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& parentPath, const std::string& name);
std::string getSafeName(const std::string& name);
pxr::TfToken getDynamicTextureProviderAssetPathToken(const std::string_view& name);
pxr::CesiumData defineCesiumData(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumTileset defineCesiumTileset(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumIonRasterOverlay defineCesiumIonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumPolygonRasterOverlay
defineCesiumPolygonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumGeoreference defineCesiumGeoreference(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumIonServer defineCesiumIonServer(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumGlobeAnchorAPI applyCesiumGlobeAnchor(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumSession defineCesiumSession(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumData getCesiumData(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumTileset getCesiumTileset(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumRasterOverlay getCesiumRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumIonRasterOverlay getCesiumIonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumPolygonRasterOverlay
getCesiumPolygonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumWebMapServiceRasterOverlay
getCesiumWebMapServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumTileMapServiceRasterOverlay
getCesiumTileMapServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumWebMapTileServiceRasterOverlay
getCesiumWebMapTileServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumGeoreference getCesiumGeoreference(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumGlobeAnchorAPI getCesiumGlobeAnchor(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumIonServer getCesiumIonServer(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::UsdGeomBasisCurves getCesiumCartographicPolygon(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::UsdShadeShader getUsdShader(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::UsdGeomBasisCurves getUsdBasisCurves(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
pxr::CesiumSession getOrCreateCesiumSession(const pxr::UsdStageWeakPtr& pStage);
bool isCesiumData(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumTileset(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumIonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumPolygonRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumWebMapServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumTileMapServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumWebMapTileServiceRasterOverlay(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumGeoreference(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumIonServer(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumCartographicPolygon(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isCesiumSession(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool hasCesiumGlobeAnchor(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isUsdShader(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
bool isUsdMaterial(const pxr::UsdStageWeakPtr& pStage, const pxr::SdfPath& path);
glm::dvec3 getTranslate(const pxr::UsdGeomXformOp& translateOp);
glm::dvec3 getRotate(const pxr::UsdGeomXformOp& rotateOp);
glm::dquat getOrient(const pxr::UsdGeomXformOp& orientOp);
glm::dvec3 getScale(const pxr::UsdGeomXformOp& scaleOp);
void setTranslate(pxr::UsdGeomXformOp& translateOp, const glm::dvec3& translate);
void setRotate(pxr::UsdGeomXformOp& rotateOp, const glm::dvec3& rotate);
void setOrient(pxr::UsdGeomXformOp& orientOp, const glm::dquat& orient);
void setScale(pxr::UsdGeomXformOp& scaleOp, const glm::dvec3& scale);
struct TranslateRotateScaleOps {
pxr::UsdGeomXformOp translateOp;
pxr::UsdGeomXformOp rotateOrOrientOp;
pxr::UsdGeomXformOp scaleOp;
MathUtil::EulerAngleOrder eulerAngleOrder;
};
std::optional<TranslateRotateScaleOps> getOrCreateTranslateRotateScaleOps(const pxr::UsdGeomXformable& xformable);
}; // namespace cesium::omniverse::UsdUtil
| 8,823 | C | 48.853107 | 119 | 0.808682 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/OmniWebMapServiceRasterOverlay.h | #pragma once
#include "cesium/omniverse/OmniRasterOverlay.h"
#include <CesiumRasterOverlays/WebMapServiceRasterOverlay.h>
#include <CesiumUtility/IntrusivePointer.h>
#include <string>
namespace cesium::omniverse {
class OmniWebMapServiceRasterOverlay final : public OmniRasterOverlay {
public:
OmniWebMapServiceRasterOverlay(Context* pContext, const pxr::SdfPath& path);
~OmniWebMapServiceRasterOverlay() override = default;
OmniWebMapServiceRasterOverlay(const OmniWebMapServiceRasterOverlay&) = delete;
OmniWebMapServiceRasterOverlay& operator=(const OmniWebMapServiceRasterOverlay&) = delete;
OmniWebMapServiceRasterOverlay(OmniWebMapServiceRasterOverlay&&) noexcept = default;
OmniWebMapServiceRasterOverlay& operator=(OmniWebMapServiceRasterOverlay&&) noexcept = default;
[[nodiscard]] CesiumRasterOverlays::RasterOverlay* getRasterOverlay() const override;
[[nodiscard]] std::string getBaseUrl() const;
[[nodiscard]] int getMinimumLevel() const;
[[nodiscard]] int getMaximumLevel() const;
[[nodiscard]] int getTileWidth() const;
[[nodiscard]] int getTileHeight() const;
[[nodiscard]] std::string getLayers() const;
void reload() override;
private:
CesiumUtility::IntrusivePointer<CesiumRasterOverlays::WebMapServiceRasterOverlay> _pWebMapServiceRasterOverlay;
};
} // namespace cesium::omniverse
| 1,373 | C | 39.411764 | 115 | 0.782229 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/OmniData.h | #pragma once
#include <pxr/usd/sdf/path.h>
namespace cesium::omniverse {
class Context;
class OmniData {
public:
OmniData(Context* pContext, const pxr::SdfPath& path);
~OmniData() = default;
OmniData(const OmniData&) = delete;
OmniData& operator=(const OmniData&) = delete;
OmniData(OmniData&&) noexcept = default;
OmniData& operator=(OmniData&&) noexcept = default;
[[nodiscard]] const pxr::SdfPath& getPath() const;
[[nodiscard]] pxr::SdfPath getSelectedIonServerPath() const;
[[nodiscard]] bool getDebugDisableMaterials() const;
[[nodiscard]] bool getDebugDisableTextures() const;
[[nodiscard]] bool getDebugDisableGeometryPool() const;
[[nodiscard]] bool getDebugDisableMaterialPool() const;
[[nodiscard]] bool getDebugDisableTexturePool() const;
[[nodiscard]] uint64_t getDebugGeometryPoolInitialCapacity() const;
[[nodiscard]] uint64_t getDebugMaterialPoolInitialCapacity() const;
[[nodiscard]] uint64_t getDebugTexturePoolInitialCapacity() const;
[[nodiscard]] bool getDebugRandomColors() const;
[[nodiscard]] bool getDebugDisableGeoreferencing() const;
private:
Context* _pContext;
pxr::SdfPath _path;
};
} // namespace cesium::omniverse
| 1,236 | C | 33.36111 | 71 | 0.718447 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricFeaturesInfo.h | #pragma once
#include "cesium/omniverse/FabricTextureInfo.h"
#include <optional>
#include <variant>
#include <vector>
namespace cesium::omniverse {
enum class FabricFeatureIdType {
INDEX,
ATTRIBUTE,
TEXTURE,
};
struct FabricFeatureId {
std::optional<uint64_t> nullFeatureId;
uint64_t featureCount;
std::variant<std::monostate, uint64_t, FabricTextureInfo> featureIdStorage;
};
struct FabricFeaturesInfo {
std::vector<FabricFeatureId> featureIds;
};
} // namespace cesium::omniverse
| 517 | C | 17.499999 | 79 | 0.73501 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/TaskProcessor.h | #pragma once
#include <CesiumAsync/ITaskProcessor.h>
#include <pxr/base/work/dispatcher.h>
namespace cesium::omniverse {
class TaskProcessor final : public CesiumAsync::ITaskProcessor {
public:
TaskProcessor() = default;
~TaskProcessor() override = default;
TaskProcessor(const TaskProcessor&) = delete;
TaskProcessor& operator=(const TaskProcessor&) = delete;
TaskProcessor(TaskProcessor&&) noexcept = delete;
TaskProcessor& operator=(TaskProcessor&&) noexcept = delete;
void startTask(std::function<void()> f) override;
private:
// TODO: should we being using something in Carbonite instead?
pxr::WorkDispatcher _dispatcher;
};
} // namespace cesium::omniverse
| 709 | C | 27.399999 | 66 | 0.730606 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricTextureData.h | #pragma once
#include <carb/RenderingTypes.h>
#include <vector>
namespace cesium::omniverse {
struct FabricTextureData {
std::vector<std::byte> bytes;
uint64_t width;
uint64_t height;
carb::Format format;
};
} // namespace cesium::omniverse
| 262 | C | 14.470587 | 33 | 0.694656 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricTextureInfo.h | #pragma once
#include <glm/glm.hpp>
#include <vector>
namespace cesium::omniverse {
struct FabricTextureInfo {
glm::dvec2 offset;
double rotation;
glm::dvec2 scale;
uint64_t setIndex;
int32_t wrapS;
int32_t wrapT;
bool flipVertical;
std::vector<uint8_t> channels;
// Make sure to update this function when adding new fields to the struct
// In C++ 20 we can use the default equality comparison (= default)
// clang-format off
bool operator==(const FabricTextureInfo& other) const {
return offset == other.offset &&
rotation == other.rotation &&
scale == other.scale &&
setIndex == other.setIndex &&
wrapS == other.wrapS &&
wrapT == other.wrapT &&
flipVertical == other.flipVertical &&
channels == other.channels;
}
// clang-format on
};
} // namespace cesium::omniverse
| 945 | C | 25.277777 | 77 | 0.596825 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricMaterialDescriptor.h | #pragma once
#include <pxr/usd/sdf/path.h>
namespace CesiumGltf {
struct Model;
struct MeshPrimitive;
} // namespace CesiumGltf
namespace cesium::omniverse {
class Context;
enum class FabricFeatureIdType;
enum class FabricOverlayRenderMethod;
struct FabricFeaturesInfo;
struct FabricRasterOverlaysInfo;
struct FabricMaterialInfo;
struct FabricPropertyDescriptor;
/**
* @brief A descriptor used to initialize a {@link FabricMaterial} and {@link FabricMaterialPool}.
*
* The descriptor uniquely identifies the topology of a {@link FabricMaterial} i.e. what Fabric prims
* need to be created and how they're connected. It is distinct from {@FabricMaterialInfo} which
* supplies the actual material values.
*
* Materials that have the same material descriptor will be assigned to the same material pool.
* To reduce the number of material pools that are needed the list of member variables should be
* as limited as possible.
*/
class FabricMaterialDescriptor {
public:
FabricMaterialDescriptor(
const Context& context,
const CesiumGltf::Model& model,
const CesiumGltf::MeshPrimitive& primitive,
const FabricMaterialInfo& materialInfo,
const FabricFeaturesInfo& featuresInfo,
const FabricRasterOverlaysInfo& rasterOverlaysInfo,
const pxr::SdfPath& tilesetMaterialPath);
[[nodiscard]] bool hasVertexColors() const;
[[nodiscard]] bool hasBaseColorTexture() const;
[[nodiscard]] const std::vector<FabricFeatureIdType>& getFeatureIdTypes() const;
[[nodiscard]] const std::vector<FabricOverlayRenderMethod>& getRasterOverlayRenderMethods() const;
[[nodiscard]] bool hasTilesetMaterial() const;
[[nodiscard]] const pxr::SdfPath& getTilesetMaterialPath() const;
[[nodiscard]] const std::vector<FabricPropertyDescriptor>& getStyleableProperties() const;
[[nodiscard]] const std::map<std::string, std::string>& getUnsupportedPropertyWarnings() const;
bool operator==(const FabricMaterialDescriptor& other) const;
private:
bool _hasVertexColors;
bool _hasBaseColorTexture;
std::vector<FabricFeatureIdType> _featureIdTypes;
std::vector<FabricOverlayRenderMethod> _rasterOverlayRenderMethods;
pxr::SdfPath _tilesetMaterialPath;
std::vector<FabricPropertyDescriptor> _styleableProperties;
std::map<std::string, std::string> _unsupportedPropertyWarnings;
};
} // namespace cesium::omniverse
| 2,410 | C | 36.671874 | 102 | 0.763071 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/CesiumIonSession.h | #pragma once
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/SharedFuture.h>
#include <CesiumIonClient/Connection.h>
#include <memory>
#include <optional>
#include <vector>
namespace CesiumAsync {
class IAssetAccessor;
}
namespace cesium::omniverse {
class CesiumIonSession {
public:
CesiumIonSession(
const CesiumAsync::AsyncSystem& asyncSystem,
std::shared_ptr<CesiumAsync::IAssetAccessor> pAssetAccessor,
std::string ionServerUrl,
std::string ionApiUrl,
int64_t ionApplicationId);
~CesiumIonSession() = default;
CesiumIonSession(const CesiumIonSession&) = delete;
CesiumIonSession& operator=(const CesiumIonSession&) = delete;
CesiumIonSession(CesiumIonSession&&) noexcept = default;
CesiumIonSession& operator=(CesiumIonSession&&) noexcept = default;
[[nodiscard]] std::shared_ptr<CesiumAsync::IAssetAccessor> getAssetAccessor() const {
return this->_pAssetAccessor;
}
[[nodiscard]] const CesiumAsync::AsyncSystem& getAsyncSystem() const {
return this->_asyncSystem;
}
CesiumAsync::AsyncSystem& getAsyncSystem() {
return this->_asyncSystem;
}
[[nodiscard]] bool isConnected() const {
return this->_connection.has_value();
}
[[nodiscard]] bool isConnecting() const {
return this->_isConnecting;
}
[[nodiscard]] bool isResuming() const {
return this->_isResuming;
}
[[nodiscard]] bool isProfileLoaded() const {
return this->_profile.has_value();
}
[[nodiscard]] bool isLoadingProfile() const {
return this->_isLoadingProfile;
}
[[nodiscard]] bool isAssetListLoaded() const {
return this->_assets.has_value();
}
[[nodiscard]] bool isLoadingAssetList() const {
return this->_isLoadingAssets;
}
[[nodiscard]] bool isTokenListLoaded() const {
return this->_tokens.has_value();
}
[[nodiscard]] bool isLoadingTokenList() const {
return this->_isLoadingTokens;
}
void connect();
void resume();
void disconnect();
void tick();
void refreshProfile();
void refreshAssets();
void refreshTokens();
[[nodiscard]] const std::optional<CesiumIonClient::Connection>& getConnection() const;
const CesiumIonClient::Profile& getProfile();
const CesiumIonClient::Assets& getAssets();
const std::vector<CesiumIonClient::Token>& getTokens();
[[nodiscard]] const std::string& getAuthorizeUrl() const {
return this->_authorizeUrl;
}
bool refreshProfileIfNeeded();
bool refreshAssetsIfNeeded();
bool refreshTokensIfNeeded();
/**
* Finds the details of the specified token in the user's account.
*
* If this session is not connected, returns std::nullopt.
*
* Even if the list of tokens is already loaded, this method does a new query
* in order get the most up-to-date information about the token.
*
* @param token The token.
* @return The details of the token, or an error response if the token does
* not exist in the signed-in user account.
*/
[[nodiscard]] CesiumAsync::Future<CesiumIonClient::Response<CesiumIonClient::Token>>
findToken(const std::string& token) const;
private:
CesiumAsync::AsyncSystem _asyncSystem;
std::shared_ptr<CesiumAsync::IAssetAccessor> _pAssetAccessor;
std::optional<CesiumIonClient::Connection> _connection;
std::optional<CesiumIonClient::Profile> _profile;
std::optional<CesiumIonClient::Assets> _assets;
std::optional<std::vector<CesiumIonClient::Token>> _tokens;
std::optional<CesiumAsync::SharedFuture<CesiumIonClient::Token>> _projectDefaultTokenDetailsFuture;
bool _isConnecting;
bool _isResuming;
bool _isLoadingProfile;
bool _isLoadingAssets;
bool _isLoadingTokens;
bool _loadProfileQueued;
bool _loadAssetsQueued;
bool _loadTokensQueued;
std::string _authorizeUrl;
std::string _ionServerUrl;
std::string _ionApiUrl;
int64_t _ionApplicationId;
};
} // namespace cesium::omniverse
| 4,107 | C | 28.768116 | 103 | 0.679815 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricPrepareRenderResources.h | #pragma once
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <Cesium3DTilesSelection/IPrepareRendererResources.h>
namespace cesium::omniverse {
class Context;
struct FabricMesh;
class OmniTileset;
class FabricPrepareRenderResources final : public Cesium3DTilesSelection::IPrepareRendererResources {
public:
FabricPrepareRenderResources(Context* pContext, OmniTileset* pTileset);
~FabricPrepareRenderResources() override = default;
FabricPrepareRenderResources(const FabricPrepareRenderResources&) = delete;
FabricPrepareRenderResources& operator=(const FabricPrepareRenderResources&) = delete;
FabricPrepareRenderResources(FabricPrepareRenderResources&&) noexcept = default;
FabricPrepareRenderResources& operator=(FabricPrepareRenderResources&&) noexcept = default;
CesiumAsync::Future<Cesium3DTilesSelection::TileLoadResultAndRenderResources> prepareInLoadThread(
const CesiumAsync::AsyncSystem& asyncSystem,
Cesium3DTilesSelection::TileLoadResult&& tileLoadResult,
const glm::dmat4& tileToEcefTransform,
const std::any& rendererOptions) override;
void* prepareInMainThread(Cesium3DTilesSelection::Tile& tile, void* pLoadThreadResult) override;
void free(Cesium3DTilesSelection::Tile& tile, void* pLoadThreadResult, void* pMainThreadResult) noexcept override;
void* prepareRasterInLoadThread(CesiumGltf::ImageCesium& image, const std::any& rendererOptions) override;
void*
prepareRasterInMainThread(CesiumRasterOverlays::RasterOverlayTile& rasterTile, void* pLoadThreadResult) override;
void freeRaster(
const CesiumRasterOverlays::RasterOverlayTile& rasterTile,
void* pLoadThreadResult,
void* pMainThreadResult) noexcept override;
void attachRasterInMainThread(
const Cesium3DTilesSelection::Tile& tile,
int32_t overlayTextureCoordinateID,
const CesiumRasterOverlays::RasterOverlayTile& rasterTile,
void* pMainThreadRendererResources,
const glm::dvec2& translation,
const glm::dvec2& scale) override;
void detachRasterInMainThread(
const Cesium3DTilesSelection::Tile& tile,
int32_t overlayTextureCoordinateID,
const CesiumRasterOverlays::RasterOverlayTile& rasterTile,
void* pMainThreadRendererResources) noexcept override;
[[nodiscard]] bool tilesetExists() const;
void detachTileset();
private:
Context* _pContext;
OmniTileset* _pTileset;
};
} // namespace cesium::omniverse
| 2,547 | C | 36.470588 | 118 | 0.769533 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/CppUtil.h | #pragma once
#include <algorithm>
#include <array>
#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <unordered_set>
#include <vector>
namespace cesium::omniverse::CppUtil {
template <typename T, typename L, uint64_t... I> const auto& dispatchImpl(std::index_sequence<I...>, L lambda) {
static std::array<decltype(lambda(std::integral_constant<T, T(0)>{})), sizeof...(I)> array = {
{lambda(std::integral_constant<T, T(I)>{})...}};
return array;
}
template <uint64_t T_COUNT, typename T, typename L, typename... P> auto dispatch(L lambda, T n, P&&... p) {
const auto& array = dispatchImpl<T>(std::make_index_sequence<T_COUNT>{}, lambda);
return array[static_cast<uint64_t>(n)](std::forward<P>(p)...);
}
template <typename T> const T& defaultValue(const T* pValue, const T& defaultValue) {
return pValue ? *pValue : defaultValue;
}
template <typename T, typename U> T defaultValue(const std::optional<U>& optional, const T& defaultValue) {
return optional.has_value() ? static_cast<T>(optional.value()) : defaultValue;
}
template <typename T> uint64_t getIndexFromRef(const std::vector<T>& vector, const T& item) {
return static_cast<uint64_t>(&item - vector.data());
};
template <typename T, typename U> std::optional<T> castOptional(const std::optional<U>& optional) {
return optional.has_value() ? std::make_optional(static_cast<T>(optional.value())) : std::nullopt;
}
template <typename T, typename U> uint64_t indexOf(const std::vector<T>& vector, const U& value) {
return static_cast<uint64_t>(std::distance(vector.begin(), std::find(vector.begin(), vector.end(), value)));
}
template <typename T, typename U> uint64_t indexOfByMember(const std::vector<T>& vector, U T::*member, const U& value) {
return static_cast<uint64_t>(
std::distance(vector.begin(), std::find_if(vector.begin(), vector.end(), [&value, &member](const auto& item) {
return item.*member == value;
})));
}
template <typename T, typename U> bool contains(const std::vector<T>& vector, const U& value) {
return std::find(vector.begin(), vector.end(), value) != vector.end();
}
// In C++ 20 we can use std::ranges::common_range instead of having a separate version for std::array
template <typename T, size_t C, typename U> bool contains(const std::array<T, C>& array, const U& value) {
return std::find(array.begin(), array.end(), value) != array.end();
}
template <typename T, typename U> bool contains(const std::unordered_set<T>& set, const U& value) {
return set.find(value) != set.end();
}
template <typename T, typename U> bool contains(const std::map<T, U>& map, const U& value) {
return map.find(value) != map.end();
}
template <typename T, typename U> bool containsByMember(const std::vector<T>& vector, U T::*member, const U& value) {
return indexOfByMember(vector, member, value) != vector.size();
}
template <typename T, typename F> bool containsIf(const std::vector<T>& vector, const F& condition) {
return std::find_if(vector.begin(), vector.end(), condition) != vector.end();
}
template <typename T, typename F> void eraseIf(std::vector<T>& vector, const F& condition) {
vector.erase(std::remove_if(vector.begin(), vector.end(), condition), vector.end());
}
template <typename T, typename F> uint64_t countIf(const std::vector<T>& vector, const F& condition) {
return static_cast<uint64_t>(std::count_if(vector.begin(), vector.end(), condition));
}
template <typename T> const T& getElementByIndex(const std::set<T>& set, uint64_t index) {
assert(index < set.size());
return *std::next(set.begin(), static_cast<int>(index));
}
template <typename T, typename F> void sort(std::vector<T>& vector, const F& comparison) {
std::sort(vector.begin(), vector.end(), comparison);
}
template <typename T> void append(std::vector<T>& vector, const std::vector<T>& append) {
vector.insert(vector.end(), append.begin(), append.end());
}
template <typename T, typename F> constexpr auto hasMemberImpl(F&& f) -> decltype(f(std::declval<T>()), true) {
return true;
}
template <typename> constexpr bool hasMemberImpl(...) {
return false;
}
#define HAS_MEMBER(T, EXPR) CppUtil::hasMemberImpl<T>([](auto&& obj) -> decltype(obj.EXPR) {})
} // namespace cesium::omniverse::CppUtil
| 4,382 | C | 38.845454 | 120 | 0.67435 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/Logger.h | #pragma once
#include "cesium/omniverse/CppUtil.h"
#include <spdlog/logger.h>
#include <unordered_set>
namespace cesium::omniverse {
class Logger final : public spdlog::logger {
public:
Logger();
template <typename T> void oneTimWarning(const T& warning) {
if (CppUtil::contains(_oneTimeWarnings, warning)) {
return;
}
_oneTimeWarnings.insert(warning);
warn(warning);
}
template <typename... Args> void oneTimeWarning(spdlog::format_string_t<Args...> fmt, Args&&... args) {
const auto warning = fmt::format(fmt, std::forward<Args>(args)...);
if (CppUtil::contains(_oneTimeWarnings, warning)) {
return;
}
_oneTimeWarnings.insert(warning);
warn(warning);
}
private:
std::unordered_set<std::string> _oneTimeWarnings;
};
} // namespace cesium::omniverse
| 886 | C | 21.174999 | 107 | 0.623025 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/UrlAssetAccessor.h | /* <editor-fold desc="MIT License">
Copyright(c) 2023 Timothy Moore
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
</editor-fold> */
#pragma once
#include "CesiumAsync/AsyncSystem.h"
#include "CesiumAsync/IAssetAccessor.h"
#include <curl/curl.h>
#include <cstddef>
#include <filesystem>
#include <memory>
#include <mutex>
#include <vector>
namespace cesium::omniverse {
// A cache that permits reuse of CURL handles. This is extremely important for performance
// because libcurl will keep existing connections open if a curl handle is not destroyed
// ("cleaned up").
struct CurlCache {
struct CacheEntry {
CacheEntry()
: curl(nullptr)
, free(false) {}
CacheEntry(CURL* curl_, bool free_)
: curl(curl_)
, free(free_) {}
CURL* curl;
bool free;
};
std::mutex cacheMutex;
std::vector<CacheEntry> cache;
CURL* get() {
std::lock_guard<std::mutex> lock(cacheMutex);
for (auto& entry : cache) {
if (entry.free) {
entry.free = false;
return entry.curl;
}
}
cache.emplace_back(curl_easy_init(), false);
return cache.back().curl;
}
void release(CURL* curl) {
std::lock_guard<std::mutex> lock(cacheMutex);
for (auto& entry : cache) {
if (curl == entry.curl) {
curl_easy_reset(curl);
entry.free = true;
return;
}
}
throw std::logic_error("releasing a curl handle that is not in the cache");
}
};
// Simple implementation of AssetAcessor that can make network and local requests
class UrlAssetAccessor final : public CesiumAsync::IAssetAccessor {
public:
UrlAssetAccessor(const std::filesystem::path& certificatePath = {});
~UrlAssetAccessor() override;
CesiumAsync::Future<std::shared_ptr<CesiumAsync::IAssetRequest>>
get(const CesiumAsync::AsyncSystem& asyncSystem,
const std::string& url,
const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers) override;
CesiumAsync::Future<std::shared_ptr<CesiumAsync::IAssetRequest>> request(
const CesiumAsync::AsyncSystem& asyncSystem,
const std::string& verb,
const std::string& url,
const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers,
const gsl::span<const std::byte>& contentPayload) override;
void tick() noexcept override;
friend class CurlHandle;
private:
CurlCache curlCache;
std::string userAgent;
curl_slist* setCommonOptions(CURL* curl, const std::string& url, const CesiumAsync::HttpHeaders& headers);
std::string _certificatePath;
};
} // namespace cesium::omniverse
| 3,738 | C | 33.62037 | 110 | 0.68031 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/OmniTileset.h | #pragma once
#include <glm/glm.hpp>
#include <pxr/usd/sdf/path.h>
#include <optional>
#include <gsl/span>
namespace Cesium3DTilesSelection {
class Tileset;
class ViewState;
class ViewUpdateResult;
} // namespace Cesium3DTilesSelection
namespace CesiumRasterOverlays {
class RasterOverlay;
}
namespace CesiumGltf {
struct Model;
}
namespace CesiumIonClient {
struct Token;
}
namespace cesium::omniverse {
class Context;
class FabricPrepareRenderResources;
class OmniRasterOverlay;
struct TilesetStatistics;
struct Viewport;
enum TilesetSourceType {
ION,
URL,
};
class OmniTileset {
public:
OmniTileset(Context* pContext, const pxr::SdfPath& path, int64_t tilesetId);
~OmniTileset();
OmniTileset(const OmniTileset&) = delete;
OmniTileset& operator=(const OmniTileset&) = delete;
OmniTileset(OmniTileset&&) noexcept = default;
OmniTileset& operator=(OmniTileset&&) noexcept = default;
[[nodiscard]] const pxr::SdfPath& getPath() const;
[[nodiscard]] int64_t getTilesetId() const;
[[nodiscard]] TilesetStatistics getStatistics() const;
[[nodiscard]] TilesetSourceType getSourceType() const;
[[nodiscard]] std::string getUrl() const;
[[nodiscard]] int64_t getIonAssetId() const;
[[nodiscard]] CesiumIonClient::Token getIonAccessToken() const;
[[nodiscard]] std::string getIonApiUrl() const;
[[nodiscard]] pxr::SdfPath getResolvedIonServerPath() const;
[[nodiscard]] double getMaximumScreenSpaceError() const;
[[nodiscard]] bool getPreloadAncestors() const;
[[nodiscard]] bool getPreloadSiblings() const;
[[nodiscard]] bool getForbidHoles() const;
[[nodiscard]] uint32_t getMaximumSimultaneousTileLoads() const;
[[nodiscard]] uint64_t getMaximumCachedBytes() const;
[[nodiscard]] uint32_t getLoadingDescendantLimit() const;
[[nodiscard]] bool getEnableFrustumCulling() const;
[[nodiscard]] bool getEnableFogCulling() const;
[[nodiscard]] bool getEnforceCulledScreenSpaceError() const;
[[nodiscard]] double getMainThreadLoadingTimeLimit() const;
[[nodiscard]] double getCulledScreenSpaceError() const;
[[nodiscard]] bool getSuspendUpdate() const;
[[nodiscard]] bool getSmoothNormals() const;
[[nodiscard]] bool getShowCreditsOnScreen() const;
[[nodiscard]] pxr::SdfPath getResolvedGeoreferencePath() const;
[[nodiscard]] pxr::SdfPath getMaterialPath() const;
[[nodiscard]] glm::dvec3 getDisplayColor() const;
[[nodiscard]] double getDisplayOpacity() const;
[[nodiscard]] std::vector<pxr::SdfPath> getRasterOverlayPaths() const;
void updateTilesetOptions();
void reload();
[[nodiscard]] pxr::SdfPath getRasterOverlayPathIfExists(const CesiumRasterOverlays::RasterOverlay& rasterOverlay);
void updateRasterOverlayAlpha(const pxr::SdfPath& rasterOverlayPath);
void updateShaderInput(const pxr::SdfPath& shaderPath, const pxr::TfToken& attributeName);
void updateDisplayColorAndOpacity();
void addRasterOverlayIfExists(const OmniRasterOverlay* overlay);
void onUpdateFrame(const gsl::span<const Viewport>& viewports, bool waitForLoadingTiles);
private:
void updateTransform();
void updateView(const gsl::span<const Viewport>& viewports, bool waitForLoadingTiles);
[[nodiscard]] bool updateExtent();
void updateLoadStatus();
void destroyNativeTileset();
std::unique_ptr<Cesium3DTilesSelection::Tileset> _pTileset;
std::shared_ptr<FabricPrepareRenderResources> _pRenderResourcesPreparer;
const Cesium3DTilesSelection::ViewUpdateResult* _pViewUpdateResult;
Context* _pContext;
pxr::SdfPath _path;
int64_t _tilesetId;
glm::dmat4 _ecefToPrimWorldTransform{};
std::vector<Cesium3DTilesSelection::ViewState> _viewStates;
bool _extentSet{false};
bool _activeLoading{false};
};
} // namespace cesium::omniverse
| 3,856 | C | 32.833333 | 118 | 0.739108 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/DataType.h | #pragma once
namespace cesium::omniverse {
enum class DataType {
UINT8,
INT8,
UINT16,
INT16,
UINT32,
INT32,
UINT64,
INT64,
FLOAT32,
FLOAT64,
UINT8_NORM,
INT8_NORM,
UINT16_NORM,
INT16_NORM,
UINT32_NORM,
INT32_NORM,
UINT64_NORM,
INT64_NORM,
VEC2_UINT8,
VEC2_INT8,
VEC2_UINT16,
VEC2_INT16,
VEC2_UINT32,
VEC2_INT32,
VEC2_UINT64,
VEC2_INT64,
VEC2_FLOAT32,
VEC2_FLOAT64,
VEC2_UINT8_NORM,
VEC2_INT8_NORM,
VEC2_UINT16_NORM,
VEC2_INT16_NORM,
VEC2_UINT32_NORM,
VEC2_INT32_NORM,
VEC2_UINT64_NORM,
VEC2_INT64_NORM,
VEC3_UINT8,
VEC3_INT8,
VEC3_UINT16,
VEC3_INT16,
VEC3_UINT32,
VEC3_INT32,
VEC3_UINT64,
VEC3_INT64,
VEC3_FLOAT32,
VEC3_FLOAT64,
VEC3_UINT8_NORM,
VEC3_INT8_NORM,
VEC3_UINT16_NORM,
VEC3_INT16_NORM,
VEC3_UINT32_NORM,
VEC3_INT32_NORM,
VEC3_UINT64_NORM,
VEC3_INT64_NORM,
VEC4_UINT8,
VEC4_INT8,
VEC4_UINT16,
VEC4_INT16,
VEC4_UINT32,
VEC4_INT32,
VEC4_UINT64,
VEC4_INT64,
VEC4_FLOAT32,
VEC4_FLOAT64,
VEC4_UINT8_NORM,
VEC4_INT8_NORM,
VEC4_UINT16_NORM,
VEC4_INT16_NORM,
VEC4_UINT32_NORM,
VEC4_INT32_NORM,
VEC4_UINT64_NORM,
VEC4_INT64_NORM,
MAT2_UINT8,
MAT2_INT8,
MAT2_UINT16,
MAT2_INT16,
MAT2_UINT32,
MAT2_INT32,
MAT2_UINT64,
MAT2_INT64,
MAT2_FLOAT32,
MAT2_FLOAT64,
MAT2_UINT8_NORM,
MAT2_INT8_NORM,
MAT2_UINT16_NORM,
MAT2_INT16_NORM,
MAT2_UINT32_NORM,
MAT2_INT32_NORM,
MAT2_UINT64_NORM,
MAT2_INT64_NORM,
MAT3_UINT8,
MAT3_INT8,
MAT3_UINT16,
MAT3_INT16,
MAT3_UINT32,
MAT3_INT32,
MAT3_UINT64,
MAT3_INT64,
MAT3_FLOAT32,
MAT3_FLOAT64,
MAT3_UINT8_NORM,
MAT3_INT8_NORM,
MAT3_UINT16_NORM,
MAT3_INT16_NORM,
MAT3_UINT32_NORM,
MAT3_INT32_NORM,
MAT3_UINT64_NORM,
MAT3_INT64_NORM,
MAT4_UINT8,
MAT4_INT8,
MAT4_UINT16,
MAT4_INT16,
MAT4_UINT32,
MAT4_INT32,
MAT4_UINT64,
MAT4_INT64,
MAT4_FLOAT32,
MAT4_FLOAT64,
MAT4_UINT8_NORM,
MAT4_INT8_NORM,
MAT4_UINT16_NORM,
MAT4_INT16_NORM,
MAT4_UINT32_NORM,
MAT4_INT32_NORM,
MAT4_UINT64_NORM,
MAT4_INT64_NORM,
};
enum class MdlInternalPropertyType {
INT32,
FLOAT32,
INT32_NORM,
VEC2_INT32,
VEC2_FLOAT32,
VEC2_INT32_NORM,
VEC3_INT32,
VEC3_FLOAT32,
VEC3_INT32_NORM,
VEC4_INT32,
VEC4_FLOAT32,
VEC4_INT32_NORM,
MAT2_INT32,
MAT2_FLOAT32,
MAT2_INT32_NORM,
MAT3_INT32,
MAT3_FLOAT32,
MAT3_INT32_NORM,
MAT4_INT32,
MAT4_FLOAT32,
MAT4_INT32_NORM,
};
enum class MdlExternalPropertyType {
INT32,
FLOAT32,
VEC2_INT32,
VEC2_FLOAT32,
VEC3_INT32,
VEC3_FLOAT32,
VEC4_INT32,
VEC4_FLOAT32,
MAT2_FLOAT32,
MAT3_FLOAT32,
MAT4_FLOAT32,
};
} // namespace cesium::omniverse
| 2,998 | C | 16.33526 | 36 | 0.602068 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricVertexAttributeAccessors.h | #pragma once
#include "cesium/omniverse/DataType.h"
#include "cesium/omniverse/DataTypeUtil.h"
#ifdef CESIUM_OMNI_MSVC
#pragma push_macro("OPAQUE")
#undef OPAQUE
#endif
#include <CesiumGltf/AccessorView.h>
#include <glm/fwd.hpp>
#include <gsl/span>
namespace cesium::omniverse {
class PositionsAccessor {
public:
PositionsAccessor();
PositionsAccessor(const CesiumGltf::AccessorView<glm::fvec3>& view);
void fill(const gsl::span<glm::fvec3>& values) const;
[[nodiscard]] const glm::fvec3& get(uint64_t index) const;
[[nodiscard]] uint64_t size() const;
private:
CesiumGltf::AccessorView<glm::fvec3> _view;
uint64_t _size;
};
class IndicesAccessor {
public:
IndicesAccessor();
IndicesAccessor(uint64_t size);
IndicesAccessor(const CesiumGltf::AccessorView<uint8_t>& uint8View);
IndicesAccessor(const CesiumGltf::AccessorView<uint16_t>& uint16View);
IndicesAccessor(const CesiumGltf::AccessorView<uint32_t>& uint32View);
template <typename T> static IndicesAccessor FromTriangleStrips(const CesiumGltf::AccessorView<T>& view);
template <typename T> static IndicesAccessor FromTriangleFans(const CesiumGltf::AccessorView<T>& view);
void fill(const gsl::span<int>& values) const;
[[nodiscard]] uint32_t get(uint64_t index) const;
[[nodiscard]] uint64_t size() const;
private:
std::vector<uint32_t> _computed;
CesiumGltf::AccessorView<uint8_t> _uint8View;
CesiumGltf::AccessorView<uint16_t> _uint16View;
CesiumGltf::AccessorView<uint32_t> _uint32View;
uint64_t _size;
};
class NormalsAccessor {
public:
NormalsAccessor();
NormalsAccessor(const CesiumGltf::AccessorView<glm::fvec3>& view);
static NormalsAccessor GenerateSmooth(const PositionsAccessor& positions, const IndicesAccessor& indices);
void fill(const gsl::span<glm::fvec3>& values) const;
[[nodiscard]] uint64_t size() const;
private:
std::vector<glm::fvec3> _computed;
CesiumGltf::AccessorView<glm::fvec3> _view;
uint64_t _size;
};
class TexcoordsAccessor {
public:
TexcoordsAccessor();
TexcoordsAccessor(const CesiumGltf::AccessorView<glm::fvec2>& view, bool flipVertical);
void fill(const gsl::span<glm::fvec2>& values) const;
[[nodiscard]] uint64_t size() const;
private:
CesiumGltf::AccessorView<glm::fvec2> _view;
bool _flipVertical;
uint64_t _size;
};
class VertexColorsAccessor {
public:
VertexColorsAccessor();
VertexColorsAccessor(const CesiumGltf::AccessorView<glm::u8vec3>& uint8Vec3View);
VertexColorsAccessor(const CesiumGltf::AccessorView<glm::u8vec4>& uint8Vec4View);
VertexColorsAccessor(const CesiumGltf::AccessorView<glm::u16vec3>& uint16Vec3View);
VertexColorsAccessor(const CesiumGltf::AccessorView<glm::u16vec4>& uint16Vec4View);
VertexColorsAccessor(const CesiumGltf::AccessorView<glm::fvec3>& float32Vec3View);
VertexColorsAccessor(const CesiumGltf::AccessorView<glm::fvec4>& float32Vec4View);
/**
* @brief Copy accessor values to the given output values, including any data transformations.
*
* @param values The output values.
* @param repeat Indicates how many times each value in the accessor should be repeated in the output. Typically repeat is 1, but for voxel point clouds repeat is 8.
*/
void fill(const gsl::span<glm::fvec4>& values, uint64_t repeat = 1) const;
[[nodiscard]] uint64_t size() const;
private:
CesiumGltf::AccessorView<glm::u8vec3> _uint8Vec3View;
CesiumGltf::AccessorView<glm::u8vec4> _uint8Vec4View;
CesiumGltf::AccessorView<glm::u16vec3> _uint16Vec3View;
CesiumGltf::AccessorView<glm::u16vec4> _uint16Vec4View;
CesiumGltf::AccessorView<glm::fvec3> _float32Vec3View;
CesiumGltf::AccessorView<glm::fvec4> _float32Vec4View;
uint64_t _size;
};
class VertexIdsAccessor {
public:
VertexIdsAccessor();
VertexIdsAccessor(uint64_t size);
void fill(const gsl::span<float>& values, uint64_t repeat = 1) const;
[[nodiscard]] uint64_t size() const;
private:
uint64_t _size;
};
class FaceVertexCountsAccessor {
public:
FaceVertexCountsAccessor();
FaceVertexCountsAccessor(uint64_t size);
void fill(const gsl::span<int>& values) const;
[[nodiscard]] uint64_t size() const;
private:
uint64_t _size;
};
template <DataType T> class VertexAttributeAccessor {
public:
VertexAttributeAccessor()
: _size(0){};
VertexAttributeAccessor(const CesiumGltf::AccessorView<DataTypeUtil::GetNativeType<T>>& view)
: _view(view)
, _size(static_cast<uint64_t>(view.size())) {}
void fill(
const gsl::span<DataTypeUtil::GetNativeType<DataTypeUtil::getPrimvarType<T>()>>& values,
uint64_t repeat = 1) const {
const auto size = values.size();
assert(size == _size * repeat);
for (uint64_t i = 0; i < size; ++i) {
values[i] = static_cast<DataTypeUtil::GetNativeType<DataTypeUtil::getPrimvarType<T>()>>(
_view[static_cast<int64_t>(i / repeat)]);
}
}
[[nodiscard]] uint64_t size() const {
return _size;
}
private:
CesiumGltf::AccessorView<DataTypeUtil::GetNativeType<T>> _view;
uint64_t _size;
};
} // namespace cesium::omniverse
| 5,285 | C | 30.094117 | 169 | 0.70123 |
CesiumGS/cesium-omniverse/src/core/include/cesium/omniverse/FabricGeometryPool.h | #pragma once
#include "cesium/omniverse/FabricGeometry.h"
#include "cesium/omniverse/FabricGeometryDescriptor.h"
#include "cesium/omniverse/ObjectPool.h"
namespace cesium::omniverse {
class FabricGeometryPool final : public ObjectPool<FabricGeometry> {
public:
FabricGeometryPool(
Context* pContext,
int64_t poolId,
const FabricGeometryDescriptor& geometryDescriptor,
uint64_t initialCapacity);
~FabricGeometryPool() override = default;
FabricGeometryPool(const FabricGeometryPool&) = delete;
FabricGeometryPool& operator=(const FabricGeometryPool&) = delete;
FabricGeometryPool(FabricGeometryPool&&) noexcept = default;
FabricGeometryPool& operator=(FabricGeometryPool&&) noexcept = default;
[[nodiscard]] const FabricGeometryDescriptor& getGeometryDescriptor() const;
[[nodiscard]] int64_t getPoolId() const;
protected:
[[nodiscard]] std::shared_ptr<FabricGeometry> createObject(uint64_t objectId) const override;
void setActive(FabricGeometry* pGeometry, bool active) const override;
private:
Context* _pContext;
int64_t _poolId;
FabricGeometryDescriptor _geometryDescriptor;
};
} // namespace cesium::omniverse
| 1,212 | C | 32.694444 | 97 | 0.750825 |
Subsets and Splits