Copy disabled (too large)
Download .txt
Showing preview only (17,629K chars total). Download the full file to get everything.
Repository: TY424/AbsGS
Branch: main
Commit: 87d7a5aac21c
Files: 1513
Total size: 16.5 MB
Directory structure:
gitextract_iv7jw_c9/
├── .gitignore
├── .gitmodules
├── LICENSE.md
├── README.md
├── arguments/
│ └── __init__.py
├── convert.py
├── environment.yml
├── full_eval.py
├── gaussian_renderer/
│ ├── __init__.py
│ └── network_gui.py
├── lpipsPyTorch/
│ ├── __init__.py
│ └── modules/
│ ├── lpips.py
│ ├── networks.py
│ └── utils.py
├── metrics.py
├── render.py
├── scene/
│ ├── __init__.py
│ ├── cameras.py
│ ├── colmap_loader.py
│ ├── dataset_readers.py
│ └── gaussian_model.py
├── submodules/
│ ├── diff-gaussian-rasterization-abs/
│ │ ├── .gitignore
│ │ ├── .gitmodules
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── cuda_rasterizer/
│ │ │ ├── auxiliary.h
│ │ │ ├── backward.cu
│ │ │ ├── backward.h
│ │ │ ├── config.h
│ │ │ ├── forward.cu
│ │ │ ├── forward.h
│ │ │ ├── rasterizer.h
│ │ │ ├── rasterizer_impl.cu
│ │ │ └── rasterizer_impl.h
│ │ ├── diff_gaussian_rasterization_abs/
│ │ │ └── __init__.py
│ │ ├── ext.cpp
│ │ ├── rasterize_points.cu
│ │ ├── rasterize_points.h
│ │ ├── setup.py
│ │ └── third_party/
│ │ ├── glm/
│ │ │ ├── .appveyor.yml
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── CMakeLists.txt
│ │ │ ├── cmake/
│ │ │ │ └── cmake_uninstall.cmake.in
│ │ │ ├── copying.txt
│ │ │ ├── doc/
│ │ │ │ ├── api/
│ │ │ │ │ ├── a00001_source.html
│ │ │ │ │ ├── a00002_source.html
│ │ │ │ │ ├── a00003_source.html
│ │ │ │ │ ├── a00004_source.html
│ │ │ │ │ ├── a00005_source.html
│ │ │ │ │ ├── a00006_source.html
│ │ │ │ │ ├── a00007.html
│ │ │ │ │ ├── a00007_source.html
│ │ │ │ │ ├── a00008.html
│ │ │ │ │ ├── a00008_source.html
│ │ │ │ │ ├── a00009.html
│ │ │ │ │ ├── a00009_source.html
│ │ │ │ │ ├── a00010.html
│ │ │ │ │ ├── a00010_source.html
│ │ │ │ │ ├── a00011.html
│ │ │ │ │ ├── a00011_source.html
│ │ │ │ │ ├── a00012.html
│ │ │ │ │ ├── a00012_source.html
│ │ │ │ │ ├── a00013.html
│ │ │ │ │ ├── a00013_source.html
│ │ │ │ │ ├── a00014.html
│ │ │ │ │ ├── a00014_source.html
│ │ │ │ │ ├── a00015.html
│ │ │ │ │ ├── a00015_source.html
│ │ │ │ │ ├── a00016.html
│ │ │ │ │ ├── a00016_source.html
│ │ │ │ │ ├── a00017.html
│ │ │ │ │ ├── a00017_source.html
│ │ │ │ │ ├── a00018.html
│ │ │ │ │ ├── a00018_source.html
│ │ │ │ │ ├── a00019_source.html
│ │ │ │ │ ├── a00020_source.html
│ │ │ │ │ ├── a00021.html
│ │ │ │ │ ├── a00021_source.html
│ │ │ │ │ ├── a00022.html
│ │ │ │ │ ├── a00022_source.html
│ │ │ │ │ ├── a00023.html
│ │ │ │ │ ├── a00023_source.html
│ │ │ │ │ ├── a00024.html
│ │ │ │ │ ├── a00024_source.html
│ │ │ │ │ ├── a00025.html
│ │ │ │ │ ├── a00025_source.html
│ │ │ │ │ ├── a00026.html
│ │ │ │ │ ├── a00026_source.html
│ │ │ │ │ ├── a00027.html
│ │ │ │ │ ├── a00027_source.html
│ │ │ │ │ ├── a00028.html
│ │ │ │ │ ├── a00028_source.html
│ │ │ │ │ ├── a00029.html
│ │ │ │ │ ├── a00029_source.html
│ │ │ │ │ ├── a00030.html
│ │ │ │ │ ├── a00030_source.html
│ │ │ │ │ ├── a00031.html
│ │ │ │ │ ├── a00031_source.html
│ │ │ │ │ ├── a00032.html
│ │ │ │ │ ├── a00032_source.html
│ │ │ │ │ ├── a00033.html
│ │ │ │ │ ├── a00033_source.html
│ │ │ │ │ ├── a00034.html
│ │ │ │ │ ├── a00034_source.html
│ │ │ │ │ ├── a00035_source.html
│ │ │ │ │ ├── a00036.html
│ │ │ │ │ ├── a00036_source.html
│ │ │ │ │ ├── a00037.html
│ │ │ │ │ ├── a00037_source.html
│ │ │ │ │ ├── a00038.html
│ │ │ │ │ ├── a00038_source.html
│ │ │ │ │ ├── a00039.html
│ │ │ │ │ ├── a00039_source.html
│ │ │ │ │ ├── a00040.html
│ │ │ │ │ ├── a00040_source.html
│ │ │ │ │ ├── a00041.html
│ │ │ │ │ ├── a00041_source.html
│ │ │ │ │ ├── a00042.html
│ │ │ │ │ ├── a00042_source.html
│ │ │ │ │ ├── a00043.html
│ │ │ │ │ ├── a00043_source.html
│ │ │ │ │ ├── a00044.html
│ │ │ │ │ ├── a00044_source.html
│ │ │ │ │ ├── a00045.html
│ │ │ │ │ ├── a00045_source.html
│ │ │ │ │ ├── a00046.html
│ │ │ │ │ ├── a00046_source.html
│ │ │ │ │ ├── a00047_source.html
│ │ │ │ │ ├── a00048.html
│ │ │ │ │ ├── a00048_source.html
│ │ │ │ │ ├── a00049.html
│ │ │ │ │ ├── a00049_source.html
│ │ │ │ │ ├── a00050.html
│ │ │ │ │ ├── a00050_source.html
│ │ │ │ │ ├── a00051.html
│ │ │ │ │ ├── a00051_source.html
│ │ │ │ │ ├── a00052.html
│ │ │ │ │ ├── a00052_source.html
│ │ │ │ │ ├── a00053.html
│ │ │ │ │ ├── a00053_source.html
│ │ │ │ │ ├── a00054.html
│ │ │ │ │ ├── a00054_source.html
│ │ │ │ │ ├── a00055.html
│ │ │ │ │ ├── a00055_source.html
│ │ │ │ │ ├── a00056.html
│ │ │ │ │ ├── a00056_source.html
│ │ │ │ │ ├── a00057.html
│ │ │ │ │ ├── a00057_source.html
│ │ │ │ │ ├── a00058.html
│ │ │ │ │ ├── a00058_source.html
│ │ │ │ │ ├── a00059.html
│ │ │ │ │ ├── a00059_source.html
│ │ │ │ │ ├── a00060.html
│ │ │ │ │ ├── a00060_source.html
│ │ │ │ │ ├── a00061.html
│ │ │ │ │ ├── a00061_source.html
│ │ │ │ │ ├── a00062.html
│ │ │ │ │ ├── a00062_source.html
│ │ │ │ │ ├── a00063.html
│ │ │ │ │ ├── a00063_source.html
│ │ │ │ │ ├── a00064.html
│ │ │ │ │ ├── a00064_source.html
│ │ │ │ │ ├── a00065.html
│ │ │ │ │ ├── a00065_source.html
│ │ │ │ │ ├── a00066.html
│ │ │ │ │ ├── a00066_source.html
│ │ │ │ │ ├── a00067.html
│ │ │ │ │ ├── a00067_source.html
│ │ │ │ │ ├── a00068.html
│ │ │ │ │ ├── a00068_source.html
│ │ │ │ │ ├── a00069.html
│ │ │ │ │ ├── a00069_source.html
│ │ │ │ │ ├── a00070.html
│ │ │ │ │ ├── a00070_source.html
│ │ │ │ │ ├── a00071.html
│ │ │ │ │ ├── a00071_source.html
│ │ │ │ │ ├── a00072.html
│ │ │ │ │ ├── a00072_source.html
│ │ │ │ │ ├── a00073.html
│ │ │ │ │ ├── a00073_source.html
│ │ │ │ │ ├── a00074.html
│ │ │ │ │ ├── a00074_source.html
│ │ │ │ │ ├── a00075.html
│ │ │ │ │ ├── a00075_source.html
│ │ │ │ │ ├── a00076.html
│ │ │ │ │ ├── a00076_source.html
│ │ │ │ │ ├── a00077.html
│ │ │ │ │ ├── a00077_source.html
│ │ │ │ │ ├── a00078.html
│ │ │ │ │ ├── a00078_source.html
│ │ │ │ │ ├── a00079.html
│ │ │ │ │ ├── a00079_source.html
│ │ │ │ │ ├── a00080.html
│ │ │ │ │ ├── a00080_source.html
│ │ │ │ │ ├── a00081.html
│ │ │ │ │ ├── a00081_source.html
│ │ │ │ │ ├── a00082.html
│ │ │ │ │ ├── a00082_source.html
│ │ │ │ │ ├── a00083.html
│ │ │ │ │ ├── a00083_source.html
│ │ │ │ │ ├── a00084.html
│ │ │ │ │ ├── a00084_source.html
│ │ │ │ │ ├── a00085.html
│ │ │ │ │ ├── a00085_source.html
│ │ │ │ │ ├── a00086.html
│ │ │ │ │ ├── a00086_source.html
│ │ │ │ │ ├── a00087.html
│ │ │ │ │ ├── a00087_source.html
│ │ │ │ │ ├── a00088.html
│ │ │ │ │ ├── a00088_source.html
│ │ │ │ │ ├── a00089.html
│ │ │ │ │ ├── a00089_source.html
│ │ │ │ │ ├── a00090.html
│ │ │ │ │ ├── a00090_source.html
│ │ │ │ │ ├── a00091.html
│ │ │ │ │ ├── a00091_source.html
│ │ │ │ │ ├── a00092.html
│ │ │ │ │ ├── a00092_source.html
│ │ │ │ │ ├── a00093.html
│ │ │ │ │ ├── a00093_source.html
│ │ │ │ │ ├── a00094.html
│ │ │ │ │ ├── a00094_source.html
│ │ │ │ │ ├── a00095_source.html
│ │ │ │ │ ├── a00096.html
│ │ │ │ │ ├── a00096_source.html
│ │ │ │ │ ├── a00097.html
│ │ │ │ │ ├── a00097_source.html
│ │ │ │ │ ├── a00098.html
│ │ │ │ │ ├── a00098_source.html
│ │ │ │ │ ├── a00099.html
│ │ │ │ │ ├── a00099_source.html
│ │ │ │ │ ├── a00100.html
│ │ │ │ │ ├── a00100_source.html
│ │ │ │ │ ├── a00101.html
│ │ │ │ │ ├── a00101_source.html
│ │ │ │ │ ├── a00102.html
│ │ │ │ │ ├── a00102_source.html
│ │ │ │ │ ├── a00103.html
│ │ │ │ │ ├── a00103_source.html
│ │ │ │ │ ├── a00104.html
│ │ │ │ │ ├── a00104_source.html
│ │ │ │ │ ├── a00105.html
│ │ │ │ │ ├── a00105_source.html
│ │ │ │ │ ├── a00106.html
│ │ │ │ │ ├── a00106_source.html
│ │ │ │ │ ├── a00107.html
│ │ │ │ │ ├── a00107_source.html
│ │ │ │ │ ├── a00108.html
│ │ │ │ │ ├── a00108_source.html
│ │ │ │ │ ├── a00109.html
│ │ │ │ │ ├── a00109_source.html
│ │ │ │ │ ├── a00110.html
│ │ │ │ │ ├── a00110_source.html
│ │ │ │ │ ├── a00111.html
│ │ │ │ │ ├── a00111_source.html
│ │ │ │ │ ├── a00112.html
│ │ │ │ │ ├── a00112_source.html
│ │ │ │ │ ├── a00113.html
│ │ │ │ │ ├── a00113_source.html
│ │ │ │ │ ├── a00114.html
│ │ │ │ │ ├── a00114_source.html
│ │ │ │ │ ├── a00115.html
│ │ │ │ │ ├── a00115_source.html
│ │ │ │ │ ├── a00116.html
│ │ │ │ │ ├── a00116_source.html
│ │ │ │ │ ├── a00117.html
│ │ │ │ │ ├── a00117_source.html
│ │ │ │ │ ├── a00118.html
│ │ │ │ │ ├── a00118_source.html
│ │ │ │ │ ├── a00119.html
│ │ │ │ │ ├── a00119_source.html
│ │ │ │ │ ├── a00120.html
│ │ │ │ │ ├── a00120_source.html
│ │ │ │ │ ├── a00121.html
│ │ │ │ │ ├── a00121_source.html
│ │ │ │ │ ├── a00122.html
│ │ │ │ │ ├── a00122_source.html
│ │ │ │ │ ├── a00123.html
│ │ │ │ │ ├── a00123_source.html
│ │ │ │ │ ├── a00124_source.html
│ │ │ │ │ ├── a00125.html
│ │ │ │ │ ├── a00125_source.html
│ │ │ │ │ ├── a00126.html
│ │ │ │ │ ├── a00126_source.html
│ │ │ │ │ ├── a00127.html
│ │ │ │ │ ├── a00127_source.html
│ │ │ │ │ ├── a00128.html
│ │ │ │ │ ├── a00128_source.html
│ │ │ │ │ ├── a00129.html
│ │ │ │ │ ├── a00129_source.html
│ │ │ │ │ ├── a00130.html
│ │ │ │ │ ├── a00130_source.html
│ │ │ │ │ ├── a00131.html
│ │ │ │ │ ├── a00131_source.html
│ │ │ │ │ ├── a00132.html
│ │ │ │ │ ├── a00132_source.html
│ │ │ │ │ ├── a00133.html
│ │ │ │ │ ├── a00133_source.html
│ │ │ │ │ ├── a00134.html
│ │ │ │ │ ├── a00134_source.html
│ │ │ │ │ ├── a00135.html
│ │ │ │ │ ├── a00135_source.html
│ │ │ │ │ ├── a00136.html
│ │ │ │ │ ├── a00136_source.html
│ │ │ │ │ ├── a00137.html
│ │ │ │ │ ├── a00137_source.html
│ │ │ │ │ ├── a00138.html
│ │ │ │ │ ├── a00138_source.html
│ │ │ │ │ ├── a00139.html
│ │ │ │ │ ├── a00139_source.html
│ │ │ │ │ ├── a00140.html
│ │ │ │ │ ├── a00140_source.html
│ │ │ │ │ ├── a00141.html
│ │ │ │ │ ├── a00141_source.html
│ │ │ │ │ ├── a00142.html
│ │ │ │ │ ├── a00142_source.html
│ │ │ │ │ ├── a00143.html
│ │ │ │ │ ├── a00143_source.html
│ │ │ │ │ ├── a00144.html
│ │ │ │ │ ├── a00144_source.html
│ │ │ │ │ ├── a00145.html
│ │ │ │ │ ├── a00145_source.html
│ │ │ │ │ ├── a00146.html
│ │ │ │ │ ├── a00146_source.html
│ │ │ │ │ ├── a00147.html
│ │ │ │ │ ├── a00147_source.html
│ │ │ │ │ ├── a00148.html
│ │ │ │ │ ├── a00148_source.html
│ │ │ │ │ ├── a00149.html
│ │ │ │ │ ├── a00149_source.html
│ │ │ │ │ ├── a00150.html
│ │ │ │ │ ├── a00150_source.html
│ │ │ │ │ ├── a00151.html
│ │ │ │ │ ├── a00151_source.html
│ │ │ │ │ ├── a00152.html
│ │ │ │ │ ├── a00152_source.html
│ │ │ │ │ ├── a00153_source.html
│ │ │ │ │ ├── a00154.html
│ │ │ │ │ ├── a00154_source.html
│ │ │ │ │ ├── a00155.html
│ │ │ │ │ ├── a00155_source.html
│ │ │ │ │ ├── a00156.html
│ │ │ │ │ ├── a00156_source.html
│ │ │ │ │ ├── a00157.html
│ │ │ │ │ ├── a00157_source.html
│ │ │ │ │ ├── a00158.html
│ │ │ │ │ ├── a00158_source.html
│ │ │ │ │ ├── a00159.html
│ │ │ │ │ ├── a00159_source.html
│ │ │ │ │ ├── a00160.html
│ │ │ │ │ ├── a00160_source.html
│ │ │ │ │ ├── a00161.html
│ │ │ │ │ ├── a00161_source.html
│ │ │ │ │ ├── a00162.html
│ │ │ │ │ ├── a00162_source.html
│ │ │ │ │ ├── a00163_source.html
│ │ │ │ │ ├── a00164_source.html
│ │ │ │ │ ├── a00165.html
│ │ │ │ │ ├── a00165_source.html
│ │ │ │ │ ├── a00166.html
│ │ │ │ │ ├── a00166_source.html
│ │ │ │ │ ├── a00167.html
│ │ │ │ │ ├── a00167_source.html
│ │ │ │ │ ├── a00168.html
│ │ │ │ │ ├── a00168_source.html
│ │ │ │ │ ├── a00169.html
│ │ │ │ │ ├── a00169_source.html
│ │ │ │ │ ├── a00170.html
│ │ │ │ │ ├── a00170_source.html
│ │ │ │ │ ├── a00171.html
│ │ │ │ │ ├── a00171_source.html
│ │ │ │ │ ├── a00172.html
│ │ │ │ │ ├── a00172_source.html
│ │ │ │ │ ├── a00173.html
│ │ │ │ │ ├── a00173_source.html
│ │ │ │ │ ├── a00174.html
│ │ │ │ │ ├── a00174_source.html
│ │ │ │ │ ├── a00175.html
│ │ │ │ │ ├── a00175_source.html
│ │ │ │ │ ├── a00176.html
│ │ │ │ │ ├── a00176_source.html
│ │ │ │ │ ├── a00177.html
│ │ │ │ │ ├── a00177_source.html
│ │ │ │ │ ├── a00178.html
│ │ │ │ │ ├── a00178_source.html
│ │ │ │ │ ├── a00179.html
│ │ │ │ │ ├── a00179_source.html
│ │ │ │ │ ├── a00180.html
│ │ │ │ │ ├── a00180_source.html
│ │ │ │ │ ├── a00181.html
│ │ │ │ │ ├── a00181_source.html
│ │ │ │ │ ├── a00182.html
│ │ │ │ │ ├── a00182_source.html
│ │ │ │ │ ├── a00183.html
│ │ │ │ │ ├── a00183_source.html
│ │ │ │ │ ├── a00184.html
│ │ │ │ │ ├── a00184_source.html
│ │ │ │ │ ├── a00185.html
│ │ │ │ │ ├── a00185_source.html
│ │ │ │ │ ├── a00186.html
│ │ │ │ │ ├── a00186_source.html
│ │ │ │ │ ├── a00187.html
│ │ │ │ │ ├── a00187_source.html
│ │ │ │ │ ├── a00188.html
│ │ │ │ │ ├── a00188_source.html
│ │ │ │ │ ├── a00189.html
│ │ │ │ │ ├── a00189_source.html
│ │ │ │ │ ├── a00190.html
│ │ │ │ │ ├── a00190_source.html
│ │ │ │ │ ├── a00191.html
│ │ │ │ │ ├── a00191_source.html
│ │ │ │ │ ├── a00192.html
│ │ │ │ │ ├── a00192_source.html
│ │ │ │ │ ├── a00193.html
│ │ │ │ │ ├── a00193_source.html
│ │ │ │ │ ├── a00194.html
│ │ │ │ │ ├── a00194_source.html
│ │ │ │ │ ├── a00195.html
│ │ │ │ │ ├── a00195_source.html
│ │ │ │ │ ├── a00196.html
│ │ │ │ │ ├── a00196_source.html
│ │ │ │ │ ├── a00197.html
│ │ │ │ │ ├── a00197_source.html
│ │ │ │ │ ├── a00198.html
│ │ │ │ │ ├── a00198_source.html
│ │ │ │ │ ├── a00199.html
│ │ │ │ │ ├── a00199_source.html
│ │ │ │ │ ├── a00200.html
│ │ │ │ │ ├── a00200_source.html
│ │ │ │ │ ├── a00201.html
│ │ │ │ │ ├── a00201_source.html
│ │ │ │ │ ├── a00202.html
│ │ │ │ │ ├── a00202_source.html
│ │ │ │ │ ├── a00203.html
│ │ │ │ │ ├── a00203_source.html
│ │ │ │ │ ├── a00204.html
│ │ │ │ │ ├── a00204_source.html
│ │ │ │ │ ├── a00205.html
│ │ │ │ │ ├── a00205_source.html
│ │ │ │ │ ├── a00206.html
│ │ │ │ │ ├── a00206_source.html
│ │ │ │ │ ├── a00207.html
│ │ │ │ │ ├── a00207_source.html
│ │ │ │ │ ├── a00208.html
│ │ │ │ │ ├── a00208_source.html
│ │ │ │ │ ├── a00209.html
│ │ │ │ │ ├── a00209_source.html
│ │ │ │ │ ├── a00210.html
│ │ │ │ │ ├── a00210_source.html
│ │ │ │ │ ├── a00211.html
│ │ │ │ │ ├── a00211_source.html
│ │ │ │ │ ├── a00212.html
│ │ │ │ │ ├── a00212_source.html
│ │ │ │ │ ├── a00213.html
│ │ │ │ │ ├── a00213_source.html
│ │ │ │ │ ├── a00214.html
│ │ │ │ │ ├── a00214_source.html
│ │ │ │ │ ├── a00215.html
│ │ │ │ │ ├── a00215_source.html
│ │ │ │ │ ├── a00216.html
│ │ │ │ │ ├── a00216_source.html
│ │ │ │ │ ├── a00217.html
│ │ │ │ │ ├── a00217_source.html
│ │ │ │ │ ├── a00218.html
│ │ │ │ │ ├── a00218_source.html
│ │ │ │ │ ├── a00219.html
│ │ │ │ │ ├── a00219_source.html
│ │ │ │ │ ├── a00220.html
│ │ │ │ │ ├── a00220_source.html
│ │ │ │ │ ├── a00221.html
│ │ │ │ │ ├── a00221_source.html
│ │ │ │ │ ├── a00222.html
│ │ │ │ │ ├── a00222_source.html
│ │ │ │ │ ├── a00223.html
│ │ │ │ │ ├── a00223_source.html
│ │ │ │ │ ├── a00224.html
│ │ │ │ │ ├── a00224_source.html
│ │ │ │ │ ├── a00225.html
│ │ │ │ │ ├── a00225_source.html
│ │ │ │ │ ├── a00226.html
│ │ │ │ │ ├── a00226_source.html
│ │ │ │ │ ├── a00227.html
│ │ │ │ │ ├── a00227_source.html
│ │ │ │ │ ├── a00228.html
│ │ │ │ │ ├── a00228_source.html
│ │ │ │ │ ├── a00229.html
│ │ │ │ │ ├── a00229_source.html
│ │ │ │ │ ├── a00230.html
│ │ │ │ │ ├── a00230_source.html
│ │ │ │ │ ├── a00231.html
│ │ │ │ │ ├── a00231_source.html
│ │ │ │ │ ├── a00232.html
│ │ │ │ │ ├── a00232_source.html
│ │ │ │ │ ├── a00233.html
│ │ │ │ │ ├── a00233_source.html
│ │ │ │ │ ├── a00234.html
│ │ │ │ │ ├── a00234_source.html
│ │ │ │ │ ├── a00235.html
│ │ │ │ │ ├── a00235_source.html
│ │ │ │ │ ├── a00241.html
│ │ │ │ │ ├── a00242.html
│ │ │ │ │ ├── a00243.html
│ │ │ │ │ ├── a00244.html
│ │ │ │ │ ├── a00245.html
│ │ │ │ │ ├── a00246.html
│ │ │ │ │ ├── a00247.html
│ │ │ │ │ ├── a00248.html
│ │ │ │ │ ├── a00249.html
│ │ │ │ │ ├── a00250.html
│ │ │ │ │ ├── a00251.html
│ │ │ │ │ ├── a00252.html
│ │ │ │ │ ├── a00253.html
│ │ │ │ │ ├── a00254.html
│ │ │ │ │ ├── a00255.html
│ │ │ │ │ ├── a00256.html
│ │ │ │ │ ├── a00257.html
│ │ │ │ │ ├── a00258.html
│ │ │ │ │ ├── a00259.html
│ │ │ │ │ ├── a00260.html
│ │ │ │ │ ├── a00261.html
│ │ │ │ │ ├── a00262.html
│ │ │ │ │ ├── a00263.html
│ │ │ │ │ ├── a00264.html
│ │ │ │ │ ├── a00265.html
│ │ │ │ │ ├── a00266.html
│ │ │ │ │ ├── a00267.html
│ │ │ │ │ ├── a00268.html
│ │ │ │ │ ├── a00269.html
│ │ │ │ │ ├── a00270.html
│ │ │ │ │ ├── a00271.html
│ │ │ │ │ ├── a00272.html
│ │ │ │ │ ├── a00273.html
│ │ │ │ │ ├── a00274.html
│ │ │ │ │ ├── a00275.html
│ │ │ │ │ ├── a00276.html
│ │ │ │ │ ├── a00277.html
│ │ │ │ │ ├── a00278.html
│ │ │ │ │ ├── a00279.html
│ │ │ │ │ ├── a00280.html
│ │ │ │ │ ├── a00281.html
│ │ │ │ │ ├── a00282.html
│ │ │ │ │ ├── a00283.html
│ │ │ │ │ ├── a00284.html
│ │ │ │ │ ├── a00285.html
│ │ │ │ │ ├── a00286.html
│ │ │ │ │ ├── a00287.html
│ │ │ │ │ ├── a00288.html
│ │ │ │ │ ├── a00289.html
│ │ │ │ │ ├── a00290.html
│ │ │ │ │ ├── a00291.html
│ │ │ │ │ ├── a00292.html
│ │ │ │ │ ├── a00293.html
│ │ │ │ │ ├── a00294.html
│ │ │ │ │ ├── a00295.html
│ │ │ │ │ ├── a00296.html
│ │ │ │ │ ├── a00297.html
│ │ │ │ │ ├── a00298.html
│ │ │ │ │ ├── a00299.html
│ │ │ │ │ ├── a00300.html
│ │ │ │ │ ├── a00301.html
│ │ │ │ │ ├── a00302.html
│ │ │ │ │ ├── a00303.html
│ │ │ │ │ ├── a00304.html
│ │ │ │ │ ├── a00305.html
│ │ │ │ │ ├── a00306.html
│ │ │ │ │ ├── a00307.html
│ │ │ │ │ ├── a00308.html
│ │ │ │ │ ├── a00309.html
│ │ │ │ │ ├── a00310.html
│ │ │ │ │ ├── a00311.html
│ │ │ │ │ ├── a00312.html
│ │ │ │ │ ├── a00313.html
│ │ │ │ │ ├── a00314.html
│ │ │ │ │ ├── a00315.html
│ │ │ │ │ ├── a00316.html
│ │ │ │ │ ├── a00317.html
│ │ │ │ │ ├── a00318.html
│ │ │ │ │ ├── a00319.html
│ │ │ │ │ ├── a00320.html
│ │ │ │ │ ├── a00321.html
│ │ │ │ │ ├── a00322.html
│ │ │ │ │ ├── a00323.html
│ │ │ │ │ ├── a00324.html
│ │ │ │ │ ├── a00325.html
│ │ │ │ │ ├── a00326.html
│ │ │ │ │ ├── a00327.html
│ │ │ │ │ ├── a00328.html
│ │ │ │ │ ├── a00329.html
│ │ │ │ │ ├── a00330.html
│ │ │ │ │ ├── a00331.html
│ │ │ │ │ ├── a00332.html
│ │ │ │ │ ├── a00333.html
│ │ │ │ │ ├── a00334.html
│ │ │ │ │ ├── a00335.html
│ │ │ │ │ ├── a00336.html
│ │ │ │ │ ├── a00337.html
│ │ │ │ │ ├── a00338.html
│ │ │ │ │ ├── a00339.html
│ │ │ │ │ ├── a00340.html
│ │ │ │ │ ├── a00341.html
│ │ │ │ │ ├── a00342.html
│ │ │ │ │ ├── a00343.html
│ │ │ │ │ ├── a00344.html
│ │ │ │ │ ├── a00345.html
│ │ │ │ │ ├── a00346.html
│ │ │ │ │ ├── a00347.html
│ │ │ │ │ ├── a00348.html
│ │ │ │ │ ├── a00349.html
│ │ │ │ │ ├── a00350.html
│ │ │ │ │ ├── a00351.html
│ │ │ │ │ ├── a00352.html
│ │ │ │ │ ├── a00353.html
│ │ │ │ │ ├── a00354.html
│ │ │ │ │ ├── a00355.html
│ │ │ │ │ ├── a00356.html
│ │ │ │ │ ├── a00357.html
│ │ │ │ │ ├── a00358.html
│ │ │ │ │ ├── a00359.html
│ │ │ │ │ ├── a00360.html
│ │ │ │ │ ├── a00361.html
│ │ │ │ │ ├── a00362.html
│ │ │ │ │ ├── a00363.html
│ │ │ │ │ ├── a00364.html
│ │ │ │ │ ├── a00365.html
│ │ │ │ │ ├── a00366.html
│ │ │ │ │ ├── a00367.html
│ │ │ │ │ ├── a00368.html
│ │ │ │ │ ├── a00369.html
│ │ │ │ │ ├── a00370.html
│ │ │ │ │ ├── a00371.html
│ │ │ │ │ ├── a00372.html
│ │ │ │ │ ├── a00373.html
│ │ │ │ │ ├── a00374.html
│ │ │ │ │ ├── dir_033f5edb0915b828d2c46ed4804e5503.html
│ │ │ │ │ ├── dir_3a581ba30d25676e4b797b1f96d53b45.html
│ │ │ │ │ ├── dir_44e5e654415abd9ca6fdeaddaff8565e.html
│ │ │ │ │ ├── dir_4c6bd29c73fa4e5a2509e1c15f846751.html
│ │ │ │ │ ├── dir_5189610d3ba09ec39b766fb99b34cd93.html
│ │ │ │ │ ├── dir_6b66465792d005310484819a0eb0b0d3.html
│ │ │ │ │ ├── dir_9e5fe034a00e89334fd5186c3e7db156.html
│ │ │ │ │ ├── dir_a8bee7be44182a33f3820393ae0b105d.html
│ │ │ │ │ ├── dir_cef2d71d502cb69a9252bca2297d9549.html
│ │ │ │ │ ├── dir_d9496f0844b48bc7e53b5af8c99b9ab2.html
│ │ │ │ │ ├── dir_f35778ec600a1b9bbc4524e62e226aa2.html
│ │ │ │ │ ├── doxygen.css
│ │ │ │ │ ├── dynsections.js
│ │ │ │ │ ├── files.html
│ │ │ │ │ ├── index.html
│ │ │ │ │ ├── jquery.js
│ │ │ │ │ ├── modules.html
│ │ │ │ │ ├── search/
│ │ │ │ │ │ ├── all_0.html
│ │ │ │ │ │ ├── all_0.js
│ │ │ │ │ │ ├── all_1.html
│ │ │ │ │ │ ├── all_1.js
│ │ │ │ │ │ ├── all_10.html
│ │ │ │ │ │ ├── all_10.js
│ │ │ │ │ │ ├── all_11.html
│ │ │ │ │ │ ├── all_11.js
│ │ │ │ │ │ ├── all_12.html
│ │ │ │ │ │ ├── all_12.js
│ │ │ │ │ │ ├── all_13.html
│ │ │ │ │ │ ├── all_13.js
│ │ │ │ │ │ ├── all_14.html
│ │ │ │ │ │ ├── all_14.js
│ │ │ │ │ │ ├── all_15.html
│ │ │ │ │ │ ├── all_15.js
│ │ │ │ │ │ ├── all_16.html
│ │ │ │ │ │ ├── all_16.js
│ │ │ │ │ │ ├── all_2.html
│ │ │ │ │ │ ├── all_2.js
│ │ │ │ │ │ ├── all_3.html
│ │ │ │ │ │ ├── all_3.js
│ │ │ │ │ │ ├── all_4.html
│ │ │ │ │ │ ├── all_4.js
│ │ │ │ │ │ ├── all_5.html
│ │ │ │ │ │ ├── all_5.js
│ │ │ │ │ │ ├── all_6.html
│ │ │ │ │ │ ├── all_6.js
│ │ │ │ │ │ ├── all_7.html
│ │ │ │ │ │ ├── all_7.js
│ │ │ │ │ │ ├── all_8.html
│ │ │ │ │ │ ├── all_8.js
│ │ │ │ │ │ ├── all_9.html
│ │ │ │ │ │ ├── all_9.js
│ │ │ │ │ │ ├── all_a.html
│ │ │ │ │ │ ├── all_a.js
│ │ │ │ │ │ ├── all_b.html
│ │ │ │ │ │ ├── all_b.js
│ │ │ │ │ │ ├── all_c.html
│ │ │ │ │ │ ├── all_c.js
│ │ │ │ │ │ ├── all_d.html
│ │ │ │ │ │ ├── all_d.js
│ │ │ │ │ │ ├── all_e.html
│ │ │ │ │ │ ├── all_e.js
│ │ │ │ │ │ ├── all_f.html
│ │ │ │ │ │ ├── all_f.js
│ │ │ │ │ │ ├── files_0.html
│ │ │ │ │ │ ├── files_0.js
│ │ │ │ │ │ ├── files_1.html
│ │ │ │ │ │ ├── files_1.js
│ │ │ │ │ │ ├── files_10.html
│ │ │ │ │ │ ├── files_10.js
│ │ │ │ │ │ ├── files_11.html
│ │ │ │ │ │ ├── files_11.js
│ │ │ │ │ │ ├── files_12.html
│ │ │ │ │ │ ├── files_12.js
│ │ │ │ │ │ ├── files_13.html
│ │ │ │ │ │ ├── files_13.js
│ │ │ │ │ │ ├── files_14.html
│ │ │ │ │ │ ├── files_14.js
│ │ │ │ │ │ ├── files_2.html
│ │ │ │ │ │ ├── files_2.js
│ │ │ │ │ │ ├── files_3.html
│ │ │ │ │ │ ├── files_3.js
│ │ │ │ │ │ ├── files_4.html
│ │ │ │ │ │ ├── files_4.js
│ │ │ │ │ │ ├── files_5.html
│ │ │ │ │ │ ├── files_5.js
│ │ │ │ │ │ ├── files_6.html
│ │ │ │ │ │ ├── files_6.js
│ │ │ │ │ │ ├── files_7.html
│ │ │ │ │ │ ├── files_7.js
│ │ │ │ │ │ ├── files_8.html
│ │ │ │ │ │ ├── files_8.js
│ │ │ │ │ │ ├── files_9.html
│ │ │ │ │ │ ├── files_9.js
│ │ │ │ │ │ ├── files_a.html
│ │ │ │ │ │ ├── files_a.js
│ │ │ │ │ │ ├── files_b.html
│ │ │ │ │ │ ├── files_b.js
│ │ │ │ │ │ ├── files_c.html
│ │ │ │ │ │ ├── files_c.js
│ │ │ │ │ │ ├── files_d.html
│ │ │ │ │ │ ├── files_d.js
│ │ │ │ │ │ ├── files_e.html
│ │ │ │ │ │ ├── files_e.js
│ │ │ │ │ │ ├── files_f.html
│ │ │ │ │ │ ├── files_f.js
│ │ │ │ │ │ ├── functions_0.html
│ │ │ │ │ │ ├── functions_0.js
│ │ │ │ │ │ ├── functions_1.html
│ │ │ │ │ │ ├── functions_1.js
│ │ │ │ │ │ ├── functions_10.html
│ │ │ │ │ │ ├── functions_10.js
│ │ │ │ │ │ ├── functions_11.html
│ │ │ │ │ │ ├── functions_11.js
│ │ │ │ │ │ ├── functions_12.html
│ │ │ │ │ │ ├── functions_12.js
│ │ │ │ │ │ ├── functions_13.html
│ │ │ │ │ │ ├── functions_13.js
│ │ │ │ │ │ ├── functions_14.html
│ │ │ │ │ │ ├── functions_14.js
│ │ │ │ │ │ ├── functions_15.html
│ │ │ │ │ │ ├── functions_15.js
│ │ │ │ │ │ ├── functions_16.html
│ │ │ │ │ │ ├── functions_16.js
│ │ │ │ │ │ ├── functions_2.html
│ │ │ │ │ │ ├── functions_2.js
│ │ │ │ │ │ ├── functions_3.html
│ │ │ │ │ │ ├── functions_3.js
│ │ │ │ │ │ ├── functions_4.html
│ │ │ │ │ │ ├── functions_4.js
│ │ │ │ │ │ ├── functions_5.html
│ │ │ │ │ │ ├── functions_5.js
│ │ │ │ │ │ ├── functions_6.html
│ │ │ │ │ │ ├── functions_6.js
│ │ │ │ │ │ ├── functions_7.html
│ │ │ │ │ │ ├── functions_7.js
│ │ │ │ │ │ ├── functions_8.html
│ │ │ │ │ │ ├── functions_8.js
│ │ │ │ │ │ ├── functions_9.html
│ │ │ │ │ │ ├── functions_9.js
│ │ │ │ │ │ ├── functions_a.html
│ │ │ │ │ │ ├── functions_a.js
│ │ │ │ │ │ ├── functions_b.html
│ │ │ │ │ │ ├── functions_b.js
│ │ │ │ │ │ ├── functions_c.html
│ │ │ │ │ │ ├── functions_c.js
│ │ │ │ │ │ ├── functions_d.html
│ │ │ │ │ │ ├── functions_d.js
│ │ │ │ │ │ ├── functions_e.html
│ │ │ │ │ │ ├── functions_e.js
│ │ │ │ │ │ ├── functions_f.html
│ │ │ │ │ │ ├── functions_f.js
│ │ │ │ │ │ ├── groups_0.html
│ │ │ │ │ │ ├── groups_0.js
│ │ │ │ │ │ ├── groups_1.html
│ │ │ │ │ │ ├── groups_1.js
│ │ │ │ │ │ ├── groups_2.html
│ │ │ │ │ │ ├── groups_2.js
│ │ │ │ │ │ ├── groups_3.html
│ │ │ │ │ │ ├── groups_3.js
│ │ │ │ │ │ ├── groups_4.html
│ │ │ │ │ │ ├── groups_4.js
│ │ │ │ │ │ ├── groups_5.html
│ │ │ │ │ │ ├── groups_5.js
│ │ │ │ │ │ ├── groups_6.html
│ │ │ │ │ │ ├── groups_6.js
│ │ │ │ │ │ ├── groups_7.html
│ │ │ │ │ │ ├── groups_7.js
│ │ │ │ │ │ ├── groups_8.html
│ │ │ │ │ │ ├── groups_8.js
│ │ │ │ │ │ ├── groups_9.html
│ │ │ │ │ │ ├── groups_9.js
│ │ │ │ │ │ ├── nomatches.html
│ │ │ │ │ │ ├── pages_0.html
│ │ │ │ │ │ ├── pages_0.js
│ │ │ │ │ │ ├── search.css
│ │ │ │ │ │ ├── search.js
│ │ │ │ │ │ ├── searchdata.js
│ │ │ │ │ │ ├── typedefs_0.html
│ │ │ │ │ │ ├── typedefs_0.js
│ │ │ │ │ │ ├── typedefs_1.html
│ │ │ │ │ │ ├── typedefs_1.js
│ │ │ │ │ │ ├── typedefs_2.html
│ │ │ │ │ │ ├── typedefs_2.js
│ │ │ │ │ │ ├── typedefs_3.html
│ │ │ │ │ │ ├── typedefs_3.js
│ │ │ │ │ │ ├── typedefs_4.html
│ │ │ │ │ │ ├── typedefs_4.js
│ │ │ │ │ │ ├── typedefs_5.html
│ │ │ │ │ │ ├── typedefs_5.js
│ │ │ │ │ │ ├── typedefs_6.html
│ │ │ │ │ │ ├── typedefs_6.js
│ │ │ │ │ │ ├── typedefs_7.html
│ │ │ │ │ │ ├── typedefs_7.js
│ │ │ │ │ │ ├── typedefs_8.html
│ │ │ │ │ │ ├── typedefs_8.js
│ │ │ │ │ │ ├── typedefs_9.html
│ │ │ │ │ │ ├── typedefs_9.js
│ │ │ │ │ │ ├── typedefs_a.html
│ │ │ │ │ │ ├── typedefs_a.js
│ │ │ │ │ │ ├── typedefs_b.html
│ │ │ │ │ │ ├── typedefs_b.js
│ │ │ │ │ │ ├── typedefs_c.html
│ │ │ │ │ │ ├── typedefs_c.js
│ │ │ │ │ │ ├── typedefs_d.html
│ │ │ │ │ │ └── typedefs_d.js
│ │ │ │ │ └── tabs.css
│ │ │ │ ├── man.doxy
│ │ │ │ └── theme/
│ │ │ │ └── doxygen.css
│ │ │ ├── glm/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── common.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── _features.hpp
│ │ │ │ │ ├── _fixes.hpp
│ │ │ │ │ ├── _noise.hpp
│ │ │ │ │ ├── _swizzle.hpp
│ │ │ │ │ ├── _swizzle_func.hpp
│ │ │ │ │ ├── _vectorize.hpp
│ │ │ │ │ ├── compute_common.hpp
│ │ │ │ │ ├── compute_vector_relational.hpp
│ │ │ │ │ ├── func_common.inl
│ │ │ │ │ ├── func_common_simd.inl
│ │ │ │ │ ├── func_exponential.inl
│ │ │ │ │ ├── func_exponential_simd.inl
│ │ │ │ │ ├── func_geometric.inl
│ │ │ │ │ ├── func_geometric_simd.inl
│ │ │ │ │ ├── func_integer.inl
│ │ │ │ │ ├── func_integer_simd.inl
│ │ │ │ │ ├── func_matrix.inl
│ │ │ │ │ ├── func_matrix_simd.inl
│ │ │ │ │ ├── func_packing.inl
│ │ │ │ │ ├── func_packing_simd.inl
│ │ │ │ │ ├── func_trigonometric.inl
│ │ │ │ │ ├── func_trigonometric_simd.inl
│ │ │ │ │ ├── func_vector_relational.inl
│ │ │ │ │ ├── func_vector_relational_simd.inl
│ │ │ │ │ ├── glm.cpp
│ │ │ │ │ ├── qualifier.hpp
│ │ │ │ │ ├── setup.hpp
│ │ │ │ │ ├── type_float.hpp
│ │ │ │ │ ├── type_half.hpp
│ │ │ │ │ ├── type_half.inl
│ │ │ │ │ ├── type_mat2x2.hpp
│ │ │ │ │ ├── type_mat2x2.inl
│ │ │ │ │ ├── type_mat2x3.hpp
│ │ │ │ │ ├── type_mat2x3.inl
│ │ │ │ │ ├── type_mat2x4.hpp
│ │ │ │ │ ├── type_mat2x4.inl
│ │ │ │ │ ├── type_mat3x2.hpp
│ │ │ │ │ ├── type_mat3x2.inl
│ │ │ │ │ ├── type_mat3x3.hpp
│ │ │ │ │ ├── type_mat3x3.inl
│ │ │ │ │ ├── type_mat3x4.hpp
│ │ │ │ │ ├── type_mat3x4.inl
│ │ │ │ │ ├── type_mat4x2.hpp
│ │ │ │ │ ├── type_mat4x2.inl
│ │ │ │ │ ├── type_mat4x3.hpp
│ │ │ │ │ ├── type_mat4x3.inl
│ │ │ │ │ ├── type_mat4x4.hpp
│ │ │ │ │ ├── type_mat4x4.inl
│ │ │ │ │ ├── type_mat4x4_simd.inl
│ │ │ │ │ ├── type_quat.hpp
│ │ │ │ │ ├── type_quat.inl
│ │ │ │ │ ├── type_quat_simd.inl
│ │ │ │ │ ├── type_vec1.hpp
│ │ │ │ │ ├── type_vec1.inl
│ │ │ │ │ ├── type_vec2.hpp
│ │ │ │ │ ├── type_vec2.inl
│ │ │ │ │ ├── type_vec3.hpp
│ │ │ │ │ ├── type_vec3.inl
│ │ │ │ │ ├── type_vec4.hpp
│ │ │ │ │ ├── type_vec4.inl
│ │ │ │ │ └── type_vec4_simd.inl
│ │ │ │ ├── exponential.hpp
│ │ │ │ ├── ext/
│ │ │ │ │ ├── _matrix_vectorize.hpp
│ │ │ │ │ ├── matrix_clip_space.hpp
│ │ │ │ │ ├── matrix_clip_space.inl
│ │ │ │ │ ├── matrix_common.hpp
│ │ │ │ │ ├── matrix_common.inl
│ │ │ │ │ ├── matrix_double2x2.hpp
│ │ │ │ │ ├── matrix_double2x2_precision.hpp
│ │ │ │ │ ├── matrix_double2x3.hpp
│ │ │ │ │ ├── matrix_double2x3_precision.hpp
│ │ │ │ │ ├── matrix_double2x4.hpp
│ │ │ │ │ ├── matrix_double2x4_precision.hpp
│ │ │ │ │ ├── matrix_double3x2.hpp
│ │ │ │ │ ├── matrix_double3x2_precision.hpp
│ │ │ │ │ ├── matrix_double3x3.hpp
│ │ │ │ │ ├── matrix_double3x3_precision.hpp
│ │ │ │ │ ├── matrix_double3x4.hpp
│ │ │ │ │ ├── matrix_double3x4_precision.hpp
│ │ │ │ │ ├── matrix_double4x2.hpp
│ │ │ │ │ ├── matrix_double4x2_precision.hpp
│ │ │ │ │ ├── matrix_double4x3.hpp
│ │ │ │ │ ├── matrix_double4x3_precision.hpp
│ │ │ │ │ ├── matrix_double4x4.hpp
│ │ │ │ │ ├── matrix_double4x4_precision.hpp
│ │ │ │ │ ├── matrix_float2x2.hpp
│ │ │ │ │ ├── matrix_float2x2_precision.hpp
│ │ │ │ │ ├── matrix_float2x3.hpp
│ │ │ │ │ ├── matrix_float2x3_precision.hpp
│ │ │ │ │ ├── matrix_float2x4.hpp
│ │ │ │ │ ├── matrix_float2x4_precision.hpp
│ │ │ │ │ ├── matrix_float3x2.hpp
│ │ │ │ │ ├── matrix_float3x2_precision.hpp
│ │ │ │ │ ├── matrix_float3x3.hpp
│ │ │ │ │ ├── matrix_float3x3_precision.hpp
│ │ │ │ │ ├── matrix_float3x4.hpp
│ │ │ │ │ ├── matrix_float3x4_precision.hpp
│ │ │ │ │ ├── matrix_float4x2.hpp
│ │ │ │ │ ├── matrix_float4x2_precision.hpp
│ │ │ │ │ ├── matrix_float4x3.hpp
│ │ │ │ │ ├── matrix_float4x3_precision.hpp
│ │ │ │ │ ├── matrix_float4x4.hpp
│ │ │ │ │ ├── matrix_float4x4_precision.hpp
│ │ │ │ │ ├── matrix_int2x2.hpp
│ │ │ │ │ ├── matrix_int2x2_sized.hpp
│ │ │ │ │ ├── matrix_int2x3.hpp
│ │ │ │ │ ├── matrix_int2x3_sized.hpp
│ │ │ │ │ ├── matrix_int2x4.hpp
│ │ │ │ │ ├── matrix_int2x4_sized.hpp
│ │ │ │ │ ├── matrix_int3x2.hpp
│ │ │ │ │ ├── matrix_int3x2_sized.hpp
│ │ │ │ │ ├── matrix_int3x3.hpp
│ │ │ │ │ ├── matrix_int3x3_sized.hpp
│ │ │ │ │ ├── matrix_int3x4.hpp
│ │ │ │ │ ├── matrix_int3x4_sized.hpp
│ │ │ │ │ ├── matrix_int4x2.hpp
│ │ │ │ │ ├── matrix_int4x2_sized.hpp
│ │ │ │ │ ├── matrix_int4x3.hpp
│ │ │ │ │ ├── matrix_int4x3_sized.hpp
│ │ │ │ │ ├── matrix_int4x4.hpp
│ │ │ │ │ ├── matrix_int4x4_sized.hpp
│ │ │ │ │ ├── matrix_integer.hpp
│ │ │ │ │ ├── matrix_integer.inl
│ │ │ │ │ ├── matrix_projection.hpp
│ │ │ │ │ ├── matrix_projection.inl
│ │ │ │ │ ├── matrix_relational.hpp
│ │ │ │ │ ├── matrix_relational.inl
│ │ │ │ │ ├── matrix_transform.hpp
│ │ │ │ │ ├── matrix_transform.inl
│ │ │ │ │ ├── matrix_uint2x2.hpp
│ │ │ │ │ ├── matrix_uint2x2_sized.hpp
│ │ │ │ │ ├── matrix_uint2x3.hpp
│ │ │ │ │ ├── matrix_uint2x3_sized.hpp
│ │ │ │ │ ├── matrix_uint2x4.hpp
│ │ │ │ │ ├── matrix_uint2x4_sized.hpp
│ │ │ │ │ ├── matrix_uint3x2.hpp
│ │ │ │ │ ├── matrix_uint3x2_sized.hpp
│ │ │ │ │ ├── matrix_uint3x3.hpp
│ │ │ │ │ ├── matrix_uint3x3_sized.hpp
│ │ │ │ │ ├── matrix_uint3x4.hpp
│ │ │ │ │ ├── matrix_uint3x4_sized.hpp
│ │ │ │ │ ├── matrix_uint4x2.hpp
│ │ │ │ │ ├── matrix_uint4x2_sized.hpp
│ │ │ │ │ ├── matrix_uint4x3.hpp
│ │ │ │ │ ├── matrix_uint4x3_sized.hpp
│ │ │ │ │ ├── matrix_uint4x4.hpp
│ │ │ │ │ ├── matrix_uint4x4_sized.hpp
│ │ │ │ │ ├── quaternion_common.hpp
│ │ │ │ │ ├── quaternion_common.inl
│ │ │ │ │ ├── quaternion_common_simd.inl
│ │ │ │ │ ├── quaternion_double.hpp
│ │ │ │ │ ├── quaternion_double_precision.hpp
│ │ │ │ │ ├── quaternion_exponential.hpp
│ │ │ │ │ ├── quaternion_exponential.inl
│ │ │ │ │ ├── quaternion_float.hpp
│ │ │ │ │ ├── quaternion_float_precision.hpp
│ │ │ │ │ ├── quaternion_geometric.hpp
│ │ │ │ │ ├── quaternion_geometric.inl
│ │ │ │ │ ├── quaternion_relational.hpp
│ │ │ │ │ ├── quaternion_relational.inl
│ │ │ │ │ ├── quaternion_transform.hpp
│ │ │ │ │ ├── quaternion_transform.inl
│ │ │ │ │ ├── quaternion_trigonometric.hpp
│ │ │ │ │ ├── quaternion_trigonometric.inl
│ │ │ │ │ ├── scalar_common.hpp
│ │ │ │ │ ├── scalar_common.inl
│ │ │ │ │ ├── scalar_constants.hpp
│ │ │ │ │ ├── scalar_constants.inl
│ │ │ │ │ ├── scalar_int_sized.hpp
│ │ │ │ │ ├── scalar_integer.hpp
│ │ │ │ │ ├── scalar_integer.inl
│ │ │ │ │ ├── scalar_packing.hpp
│ │ │ │ │ ├── scalar_packing.inl
│ │ │ │ │ ├── scalar_reciprocal.hpp
│ │ │ │ │ ├── scalar_reciprocal.inl
│ │ │ │ │ ├── scalar_relational.hpp
│ │ │ │ │ ├── scalar_relational.inl
│ │ │ │ │ ├── scalar_uint_sized.hpp
│ │ │ │ │ ├── scalar_ulp.hpp
│ │ │ │ │ ├── scalar_ulp.inl
│ │ │ │ │ ├── vector_bool1.hpp
│ │ │ │ │ ├── vector_bool1_precision.hpp
│ │ │ │ │ ├── vector_bool2.hpp
│ │ │ │ │ ├── vector_bool2_precision.hpp
│ │ │ │ │ ├── vector_bool3.hpp
│ │ │ │ │ ├── vector_bool3_precision.hpp
│ │ │ │ │ ├── vector_bool4.hpp
│ │ │ │ │ ├── vector_bool4_precision.hpp
│ │ │ │ │ ├── vector_common.hpp
│ │ │ │ │ ├── vector_common.inl
│ │ │ │ │ ├── vector_double1.hpp
│ │ │ │ │ ├── vector_double1_precision.hpp
│ │ │ │ │ ├── vector_double2.hpp
│ │ │ │ │ ├── vector_double2_precision.hpp
│ │ │ │ │ ├── vector_double3.hpp
│ │ │ │ │ ├── vector_double3_precision.hpp
│ │ │ │ │ ├── vector_double4.hpp
│ │ │ │ │ ├── vector_double4_precision.hpp
│ │ │ │ │ ├── vector_float1.hpp
│ │ │ │ │ ├── vector_float1_precision.hpp
│ │ │ │ │ ├── vector_float2.hpp
│ │ │ │ │ ├── vector_float2_precision.hpp
│ │ │ │ │ ├── vector_float3.hpp
│ │ │ │ │ ├── vector_float3_precision.hpp
│ │ │ │ │ ├── vector_float4.hpp
│ │ │ │ │ ├── vector_float4_precision.hpp
│ │ │ │ │ ├── vector_int1.hpp
│ │ │ │ │ ├── vector_int1_sized.hpp
│ │ │ │ │ ├── vector_int2.hpp
│ │ │ │ │ ├── vector_int2_sized.hpp
│ │ │ │ │ ├── vector_int3.hpp
│ │ │ │ │ ├── vector_int3_sized.hpp
│ │ │ │ │ ├── vector_int4.hpp
│ │ │ │ │ ├── vector_int4_sized.hpp
│ │ │ │ │ ├── vector_integer.hpp
│ │ │ │ │ ├── vector_integer.inl
│ │ │ │ │ ├── vector_packing.hpp
│ │ │ │ │ ├── vector_packing.inl
│ │ │ │ │ ├── vector_reciprocal.hpp
│ │ │ │ │ ├── vector_reciprocal.inl
│ │ │ │ │ ├── vector_relational.hpp
│ │ │ │ │ ├── vector_relational.inl
│ │ │ │ │ ├── vector_uint1.hpp
│ │ │ │ │ ├── vector_uint1_sized.hpp
│ │ │ │ │ ├── vector_uint2.hpp
│ │ │ │ │ ├── vector_uint2_sized.hpp
│ │ │ │ │ ├── vector_uint3.hpp
│ │ │ │ │ ├── vector_uint3_sized.hpp
│ │ │ │ │ ├── vector_uint4.hpp
│ │ │ │ │ ├── vector_uint4_sized.hpp
│ │ │ │ │ ├── vector_ulp.hpp
│ │ │ │ │ └── vector_ulp.inl
│ │ │ │ ├── ext.hpp
│ │ │ │ ├── fwd.hpp
│ │ │ │ ├── geometric.hpp
│ │ │ │ ├── glm.hpp
│ │ │ │ ├── gtc/
│ │ │ │ │ ├── bitfield.hpp
│ │ │ │ │ ├── bitfield.inl
│ │ │ │ │ ├── color_space.hpp
│ │ │ │ │ ├── color_space.inl
│ │ │ │ │ ├── constants.hpp
│ │ │ │ │ ├── constants.inl
│ │ │ │ │ ├── epsilon.hpp
│ │ │ │ │ ├── epsilon.inl
│ │ │ │ │ ├── integer.hpp
│ │ │ │ │ ├── integer.inl
│ │ │ │ │ ├── matrix_access.hpp
│ │ │ │ │ ├── matrix_access.inl
│ │ │ │ │ ├── matrix_integer.hpp
│ │ │ │ │ ├── matrix_inverse.hpp
│ │ │ │ │ ├── matrix_inverse.inl
│ │ │ │ │ ├── matrix_transform.hpp
│ │ │ │ │ ├── matrix_transform.inl
│ │ │ │ │ ├── noise.hpp
│ │ │ │ │ ├── noise.inl
│ │ │ │ │ ├── packing.hpp
│ │ │ │ │ ├── packing.inl
│ │ │ │ │ ├── quaternion.hpp
│ │ │ │ │ ├── quaternion.inl
│ │ │ │ │ ├── quaternion_simd.inl
│ │ │ │ │ ├── random.hpp
│ │ │ │ │ ├── random.inl
│ │ │ │ │ ├── reciprocal.hpp
│ │ │ │ │ ├── round.hpp
│ │ │ │ │ ├── round.inl
│ │ │ │ │ ├── type_aligned.hpp
│ │ │ │ │ ├── type_precision.hpp
│ │ │ │ │ ├── type_precision.inl
│ │ │ │ │ ├── type_ptr.hpp
│ │ │ │ │ ├── type_ptr.inl
│ │ │ │ │ ├── ulp.hpp
│ │ │ │ │ ├── ulp.inl
│ │ │ │ │ └── vec1.hpp
│ │ │ │ ├── gtx/
│ │ │ │ │ ├── associated_min_max.hpp
│ │ │ │ │ ├── associated_min_max.inl
│ │ │ │ │ ├── bit.hpp
│ │ │ │ │ ├── bit.inl
│ │ │ │ │ ├── closest_point.hpp
│ │ │ │ │ ├── closest_point.inl
│ │ │ │ │ ├── color_encoding.hpp
│ │ │ │ │ ├── color_encoding.inl
│ │ │ │ │ ├── color_space.hpp
│ │ │ │ │ ├── color_space.inl
│ │ │ │ │ ├── color_space_YCoCg.hpp
│ │ │ │ │ ├── color_space_YCoCg.inl
│ │ │ │ │ ├── common.hpp
│ │ │ │ │ ├── common.inl
│ │ │ │ │ ├── compatibility.hpp
│ │ │ │ │ ├── compatibility.inl
│ │ │ │ │ ├── component_wise.hpp
│ │ │ │ │ ├── component_wise.inl
│ │ │ │ │ ├── dual_quaternion.hpp
│ │ │ │ │ ├── dual_quaternion.inl
│ │ │ │ │ ├── easing.hpp
│ │ │ │ │ ├── easing.inl
│ │ │ │ │ ├── euler_angles.hpp
│ │ │ │ │ ├── euler_angles.inl
│ │ │ │ │ ├── extend.hpp
│ │ │ │ │ ├── extend.inl
│ │ │ │ │ ├── extended_min_max.hpp
│ │ │ │ │ ├── extended_min_max.inl
│ │ │ │ │ ├── exterior_product.hpp
│ │ │ │ │ ├── exterior_product.inl
│ │ │ │ │ ├── fast_exponential.hpp
│ │ │ │ │ ├── fast_exponential.inl
│ │ │ │ │ ├── fast_square_root.hpp
│ │ │ │ │ ├── fast_square_root.inl
│ │ │ │ │ ├── fast_trigonometry.hpp
│ │ │ │ │ ├── fast_trigonometry.inl
│ │ │ │ │ ├── float_notmalize.inl
│ │ │ │ │ ├── functions.hpp
│ │ │ │ │ ├── functions.inl
│ │ │ │ │ ├── gradient_paint.hpp
│ │ │ │ │ ├── gradient_paint.inl
│ │ │ │ │ ├── handed_coordinate_space.hpp
│ │ │ │ │ ├── handed_coordinate_space.inl
│ │ │ │ │ ├── hash.hpp
│ │ │ │ │ ├── hash.inl
│ │ │ │ │ ├── integer.hpp
│ │ │ │ │ ├── integer.inl
│ │ │ │ │ ├── intersect.hpp
│ │ │ │ │ ├── intersect.inl
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ ├── io.inl
│ │ │ │ │ ├── log_base.hpp
│ │ │ │ │ ├── log_base.inl
│ │ │ │ │ ├── matrix_cross_product.hpp
│ │ │ │ │ ├── matrix_cross_product.inl
│ │ │ │ │ ├── matrix_decompose.hpp
│ │ │ │ │ ├── matrix_decompose.inl
│ │ │ │ │ ├── matrix_factorisation.hpp
│ │ │ │ │ ├── matrix_factorisation.inl
│ │ │ │ │ ├── matrix_interpolation.hpp
│ │ │ │ │ ├── matrix_interpolation.inl
│ │ │ │ │ ├── matrix_major_storage.hpp
│ │ │ │ │ ├── matrix_major_storage.inl
│ │ │ │ │ ├── matrix_operation.hpp
│ │ │ │ │ ├── matrix_operation.inl
│ │ │ │ │ ├── matrix_query.hpp
│ │ │ │ │ ├── matrix_query.inl
│ │ │ │ │ ├── matrix_transform_2d.hpp
│ │ │ │ │ ├── matrix_transform_2d.inl
│ │ │ │ │ ├── mixed_product.hpp
│ │ │ │ │ ├── mixed_product.inl
│ │ │ │ │ ├── norm.hpp
│ │ │ │ │ ├── norm.inl
│ │ │ │ │ ├── normal.hpp
│ │ │ │ │ ├── normal.inl
│ │ │ │ │ ├── normalize_dot.hpp
│ │ │ │ │ ├── normalize_dot.inl
│ │ │ │ │ ├── number_precision.hpp
│ │ │ │ │ ├── number_precision.inl
│ │ │ │ │ ├── optimum_pow.hpp
│ │ │ │ │ ├── optimum_pow.inl
│ │ │ │ │ ├── orthonormalize.hpp
│ │ │ │ │ ├── orthonormalize.inl
│ │ │ │ │ ├── pca.hpp
│ │ │ │ │ ├── pca.inl
│ │ │ │ │ ├── perpendicular.hpp
│ │ │ │ │ ├── perpendicular.inl
│ │ │ │ │ ├── polar_coordinates.hpp
│ │ │ │ │ ├── polar_coordinates.inl
│ │ │ │ │ ├── projection.hpp
│ │ │ │ │ ├── projection.inl
│ │ │ │ │ ├── quaternion.hpp
│ │ │ │ │ ├── quaternion.inl
│ │ │ │ │ ├── range.hpp
│ │ │ │ │ ├── raw_data.hpp
│ │ │ │ │ ├── raw_data.inl
│ │ │ │ │ ├── rotate_normalized_axis.hpp
│ │ │ │ │ ├── rotate_normalized_axis.inl
│ │ │ │ │ ├── rotate_vector.hpp
│ │ │ │ │ ├── rotate_vector.inl
│ │ │ │ │ ├── scalar_multiplication.hpp
│ │ │ │ │ ├── scalar_relational.hpp
│ │ │ │ │ ├── scalar_relational.inl
│ │ │ │ │ ├── spline.hpp
│ │ │ │ │ ├── spline.inl
│ │ │ │ │ ├── std_based_type.hpp
│ │ │ │ │ ├── std_based_type.inl
│ │ │ │ │ ├── string_cast.hpp
│ │ │ │ │ ├── string_cast.inl
│ │ │ │ │ ├── texture.hpp
│ │ │ │ │ ├── texture.inl
│ │ │ │ │ ├── transform.hpp
│ │ │ │ │ ├── transform.inl
│ │ │ │ │ ├── transform2.hpp
│ │ │ │ │ ├── transform2.inl
│ │ │ │ │ ├── type_aligned.hpp
│ │ │ │ │ ├── type_aligned.inl
│ │ │ │ │ ├── type_trait.hpp
│ │ │ │ │ ├── type_trait.inl
│ │ │ │ │ ├── vec_swizzle.hpp
│ │ │ │ │ ├── vector_angle.hpp
│ │ │ │ │ ├── vector_angle.inl
│ │ │ │ │ ├── vector_query.hpp
│ │ │ │ │ ├── vector_query.inl
│ │ │ │ │ ├── wrap.hpp
│ │ │ │ │ └── wrap.inl
│ │ │ │ ├── integer.hpp
│ │ │ │ ├── mat2x2.hpp
│ │ │ │ ├── mat2x3.hpp
│ │ │ │ ├── mat2x4.hpp
│ │ │ │ ├── mat3x2.hpp
│ │ │ │ ├── mat3x3.hpp
│ │ │ │ ├── mat3x4.hpp
│ │ │ │ ├── mat4x2.hpp
│ │ │ │ ├── mat4x3.hpp
│ │ │ │ ├── mat4x4.hpp
│ │ │ │ ├── matrix.hpp
│ │ │ │ ├── packing.hpp
│ │ │ │ ├── simd/
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── exponential.h
│ │ │ │ │ ├── geometric.h
│ │ │ │ │ ├── integer.h
│ │ │ │ │ ├── matrix.h
│ │ │ │ │ ├── neon.h
│ │ │ │ │ ├── packing.h
│ │ │ │ │ ├── platform.h
│ │ │ │ │ ├── trigonometric.h
│ │ │ │ │ └── vector_relational.h
│ │ │ │ ├── trigonometric.hpp
│ │ │ │ ├── vec2.hpp
│ │ │ │ ├── vec3.hpp
│ │ │ │ ├── vec4.hpp
│ │ │ │ └── vector_relational.hpp
│ │ │ ├── manual.md
│ │ │ ├── readme.md
│ │ │ ├── test/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── bug/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── bug_ms_vec_static.cpp
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── test_find_glm.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── core_cpp_constexpr.cpp
│ │ │ │ │ ├── core_cpp_defaulted_ctor.cpp
│ │ │ │ │ ├── core_force_aligned_gentypes.cpp
│ │ │ │ │ ├── core_force_arch_unknown.cpp
│ │ │ │ │ ├── core_force_compiler_unknown.cpp
│ │ │ │ │ ├── core_force_ctor_init.cpp
│ │ │ │ │ ├── core_force_cxx03.cpp
│ │ │ │ │ ├── core_force_cxx98.cpp
│ │ │ │ │ ├── core_force_cxx_unknown.cpp
│ │ │ │ │ ├── core_force_depth_zero_to_one.cpp
│ │ │ │ │ ├── core_force_explicit_ctor.cpp
│ │ │ │ │ ├── core_force_inline.cpp
│ │ │ │ │ ├── core_force_left_handed.cpp
│ │ │ │ │ ├── core_force_platform_unknown.cpp
│ │ │ │ │ ├── core_force_pure.cpp
│ │ │ │ │ ├── core_force_quat_xyzw.cpp
│ │ │ │ │ ├── core_force_size_t_length.cpp
│ │ │ │ │ ├── core_force_unrestricted_gentype.cpp
│ │ │ │ │ ├── core_force_xyzw_only.cpp
│ │ │ │ │ ├── core_func_common.cpp
│ │ │ │ │ ├── core_func_exponential.cpp
│ │ │ │ │ ├── core_func_geometric.cpp
│ │ │ │ │ ├── core_func_integer.cpp
│ │ │ │ │ ├── core_func_integer_bit_count.cpp
│ │ │ │ │ ├── core_func_integer_find_lsb.cpp
│ │ │ │ │ ├── core_func_integer_find_msb.cpp
│ │ │ │ │ ├── core_func_matrix.cpp
│ │ │ │ │ ├── core_func_noise.cpp
│ │ │ │ │ ├── core_func_packing.cpp
│ │ │ │ │ ├── core_func_swizzle.cpp
│ │ │ │ │ ├── core_func_trigonometric.cpp
│ │ │ │ │ ├── core_func_vector_relational.cpp
│ │ │ │ │ ├── core_setup_force_cxx98.cpp
│ │ │ │ │ ├── core_setup_force_size_t_length.cpp
│ │ │ │ │ ├── core_setup_message.cpp
│ │ │ │ │ ├── core_setup_platform_unknown.cpp
│ │ │ │ │ ├── core_setup_precision.cpp
│ │ │ │ │ ├── core_type_aligned.cpp
│ │ │ │ │ ├── core_type_cast.cpp
│ │ │ │ │ ├── core_type_ctor.cpp
│ │ │ │ │ ├── core_type_int.cpp
│ │ │ │ │ ├── core_type_length.cpp
│ │ │ │ │ ├── core_type_mat2x2.cpp
│ │ │ │ │ ├── core_type_mat2x3.cpp
│ │ │ │ │ ├── core_type_mat2x4.cpp
│ │ │ │ │ ├── core_type_mat3x2.cpp
│ │ │ │ │ ├── core_type_mat3x3.cpp
│ │ │ │ │ ├── core_type_mat3x4.cpp
│ │ │ │ │ ├── core_type_mat4x2.cpp
│ │ │ │ │ ├── core_type_mat4x3.cpp
│ │ │ │ │ ├── core_type_mat4x4.cpp
│ │ │ │ │ ├── core_type_vec1.cpp
│ │ │ │ │ ├── core_type_vec2.cpp
│ │ │ │ │ ├── core_type_vec3.cpp
│ │ │ │ │ └── core_type_vec4.cpp
│ │ │ │ ├── ext/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── ext_matrix_clip_space.cpp
│ │ │ │ │ ├── ext_matrix_common.cpp
│ │ │ │ │ ├── ext_matrix_int2x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int2x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int2x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_integer.cpp
│ │ │ │ │ ├── ext_matrix_projection.cpp
│ │ │ │ │ ├── ext_matrix_relational.cpp
│ │ │ │ │ ├── ext_matrix_transform.cpp
│ │ │ │ │ ├── ext_matrix_uint2x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint2x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint2x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x4_sized.cpp
│ │ │ │ │ ├── ext_quaternion_common.cpp
│ │ │ │ │ ├── ext_quaternion_exponential.cpp
│ │ │ │ │ ├── ext_quaternion_geometric.cpp
│ │ │ │ │ ├── ext_quaternion_relational.cpp
│ │ │ │ │ ├── ext_quaternion_transform.cpp
│ │ │ │ │ ├── ext_quaternion_trigonometric.cpp
│ │ │ │ │ ├── ext_quaternion_type.cpp
│ │ │ │ │ ├── ext_scalar_common.cpp
│ │ │ │ │ ├── ext_scalar_constants.cpp
│ │ │ │ │ ├── ext_scalar_int_sized.cpp
│ │ │ │ │ ├── ext_scalar_integer.cpp
│ │ │ │ │ ├── ext_scalar_packing.cpp
│ │ │ │ │ ├── ext_scalar_reciprocal.cpp
│ │ │ │ │ ├── ext_scalar_relational.cpp
│ │ │ │ │ ├── ext_scalar_uint_sized.cpp
│ │ │ │ │ ├── ext_scalar_ulp.cpp
│ │ │ │ │ ├── ext_vec1.cpp
│ │ │ │ │ ├── ext_vector_bool1.cpp
│ │ │ │ │ ├── ext_vector_common.cpp
│ │ │ │ │ ├── ext_vector_iec559.cpp
│ │ │ │ │ ├── ext_vector_int1_sized.cpp
│ │ │ │ │ ├── ext_vector_int2_sized.cpp
│ │ │ │ │ ├── ext_vector_int3_sized.cpp
│ │ │ │ │ ├── ext_vector_int4_sized.cpp
│ │ │ │ │ ├── ext_vector_integer.cpp
│ │ │ │ │ ├── ext_vector_integer_sized.cpp
│ │ │ │ │ ├── ext_vector_packing.cpp
│ │ │ │ │ ├── ext_vector_reciprocal.cpp
│ │ │ │ │ ├── ext_vector_relational.cpp
│ │ │ │ │ ├── ext_vector_uint1_sized.cpp
│ │ │ │ │ ├── ext_vector_uint2_sized.cpp
│ │ │ │ │ ├── ext_vector_uint3_sized.cpp
│ │ │ │ │ ├── ext_vector_uint4_sized.cpp
│ │ │ │ │ └── ext_vector_ulp.cpp
│ │ │ │ ├── glm.cppcheck
│ │ │ │ ├── gtc/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── gtc_bitfield.cpp
│ │ │ │ │ ├── gtc_color_space.cpp
│ │ │ │ │ ├── gtc_constants.cpp
│ │ │ │ │ ├── gtc_epsilon.cpp
│ │ │ │ │ ├── gtc_integer.cpp
│ │ │ │ │ ├── gtc_matrix_access.cpp
│ │ │ │ │ ├── gtc_matrix_integer.cpp
│ │ │ │ │ ├── gtc_matrix_inverse.cpp
│ │ │ │ │ ├── gtc_matrix_transform.cpp
│ │ │ │ │ ├── gtc_noise.cpp
│ │ │ │ │ ├── gtc_packing.cpp
│ │ │ │ │ ├── gtc_quaternion.cpp
│ │ │ │ │ ├── gtc_random.cpp
│ │ │ │ │ ├── gtc_reciprocal.cpp
│ │ │ │ │ ├── gtc_round.cpp
│ │ │ │ │ ├── gtc_type_aligned.cpp
│ │ │ │ │ ├── gtc_type_precision.cpp
│ │ │ │ │ ├── gtc_type_ptr.cpp
│ │ │ │ │ ├── gtc_ulp.cpp
│ │ │ │ │ ├── gtc_user_defined_types.cpp
│ │ │ │ │ └── gtc_vec1.cpp
│ │ │ │ ├── gtx/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── gtx.cpp
│ │ │ │ │ ├── gtx_associated_min_max.cpp
│ │ │ │ │ ├── gtx_closest_point.cpp
│ │ │ │ │ ├── gtx_color_encoding.cpp
│ │ │ │ │ ├── gtx_color_space.cpp
│ │ │ │ │ ├── gtx_color_space_YCoCg.cpp
│ │ │ │ │ ├── gtx_common.cpp
│ │ │ │ │ ├── gtx_compatibility.cpp
│ │ │ │ │ ├── gtx_component_wise.cpp
│ │ │ │ │ ├── gtx_dual_quaternion.cpp
│ │ │ │ │ ├── gtx_easing.cpp
│ │ │ │ │ ├── gtx_euler_angle.cpp
│ │ │ │ │ ├── gtx_extend.cpp
│ │ │ │ │ ├── gtx_extended_min_max.cpp
│ │ │ │ │ ├── gtx_extented_min_max.cpp
│ │ │ │ │ ├── gtx_exterior_product.cpp
│ │ │ │ │ ├── gtx_fast_exponential.cpp
│ │ │ │ │ ├── gtx_fast_square_root.cpp
│ │ │ │ │ ├── gtx_fast_trigonometry.cpp
│ │ │ │ │ ├── gtx_functions.cpp
│ │ │ │ │ ├── gtx_gradient_paint.cpp
│ │ │ │ │ ├── gtx_handed_coordinate_space.cpp
│ │ │ │ │ ├── gtx_hash.cpp
│ │ │ │ │ ├── gtx_int_10_10_10_2.cpp
│ │ │ │ │ ├── gtx_integer.cpp
│ │ │ │ │ ├── gtx_intersect.cpp
│ │ │ │ │ ├── gtx_io.cpp
│ │ │ │ │ ├── gtx_load.cpp
│ │ │ │ │ ├── gtx_log_base.cpp
│ │ │ │ │ ├── gtx_matrix_cross_product.cpp
│ │ │ │ │ ├── gtx_matrix_decompose.cpp
│ │ │ │ │ ├── gtx_matrix_factorisation.cpp
│ │ │ │ │ ├── gtx_matrix_interpolation.cpp
│ │ │ │ │ ├── gtx_matrix_major_storage.cpp
│ │ │ │ │ ├── gtx_matrix_operation.cpp
│ │ │ │ │ ├── gtx_matrix_query.cpp
│ │ │ │ │ ├── gtx_matrix_transform_2d.cpp
│ │ │ │ │ ├── gtx_mixed_product.cpp
│ │ │ │ │ ├── gtx_norm.cpp
│ │ │ │ │ ├── gtx_normal.cpp
│ │ │ │ │ ├── gtx_normalize_dot.cpp
│ │ │ │ │ ├── gtx_number_precision.cpp
│ │ │ │ │ ├── gtx_optimum_pow.cpp
│ │ │ │ │ ├── gtx_orthonormalize.cpp
│ │ │ │ │ ├── gtx_pca.cpp
│ │ │ │ │ ├── gtx_perpendicular.cpp
│ │ │ │ │ ├── gtx_polar_coordinates.cpp
│ │ │ │ │ ├── gtx_projection.cpp
│ │ │ │ │ ├── gtx_quaternion.cpp
│ │ │ │ │ ├── gtx_random.cpp
│ │ │ │ │ ├── gtx_range.cpp
│ │ │ │ │ ├── gtx_rotate_normalized_axis.cpp
│ │ │ │ │ ├── gtx_rotate_vector.cpp
│ │ │ │ │ ├── gtx_scalar_multiplication.cpp
│ │ │ │ │ ├── gtx_scalar_relational.cpp
│ │ │ │ │ ├── gtx_simd_mat4.cpp
│ │ │ │ │ ├── gtx_simd_vec4.cpp
│ │ │ │ │ ├── gtx_spline.cpp
│ │ │ │ │ ├── gtx_string_cast.cpp
│ │ │ │ │ ├── gtx_texture.cpp
│ │ │ │ │ ├── gtx_type_aligned.cpp
│ │ │ │ │ ├── gtx_type_trait.cpp
│ │ │ │ │ ├── gtx_vec_swizzle.cpp
│ │ │ │ │ ├── gtx_vector_angle.cpp
│ │ │ │ │ ├── gtx_vector_query.cpp
│ │ │ │ │ └── gtx_wrap.cpp
│ │ │ │ └── perf/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── perf_matrix_div.cpp
│ │ │ │ ├── perf_matrix_inverse.cpp
│ │ │ │ ├── perf_matrix_mul.cpp
│ │ │ │ ├── perf_matrix_mul_vector.cpp
│ │ │ │ ├── perf_matrix_transpose.cpp
│ │ │ │ └── perf_vector_mul_matrix.cpp
│ │ │ └── util/
│ │ │ ├── autoexp.txt
│ │ │ └── glm.natvis
│ │ └── stbi_image_write.h
│ └── simple-knn/
│ ├── dist/
│ │ └── simple_knn-0.0.0-py3.8-linux-x86_64.egg
│ ├── ext.cpp
│ ├── setup.py
│ ├── simple_knn/
│ │ └── .gitkeep
│ ├── simple_knn.cu
│ ├── simple_knn.egg-info/
│ │ ├── PKG-INFO
│ │ ├── SOURCES.txt
│ │ ├── dependency_links.txt
│ │ └── top_level.txt
│ ├── simple_knn.h
│ ├── spatial.cu
│ └── spatial.h
├── train.py
└── utils/
├── camera_utils.py
├── general_utils.py
├── graphics_utils.py
├── image_utils.py
├── loss_utils.py
├── sh_utils.py
└── system_utils.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# 默认忽略的文件
.idea
/shelf/
/workspace.xml
/output
================================================
FILE: .gitmodules
================================================
[submodule "submodules/simple-knn"]
path = submodules/simple-knn
url = https://gitlab.inria.fr/bkerbl/simple-knn.git
[submodule "submodules/diff-gaussian-rasterization-abs"]
path = submodules/diff-gaussian-rasterization-abs
================================================
FILE: LICENSE.md
================================================
Gaussian-Splatting License
===========================
**Inria** and **the Max Planck Institut for Informatik (MPII)** hold all the ownership rights on the *Software* named **gaussian-splatting**.
The *Software* is in the process of being registered with the Agence pour la Protection des
Programmes (APP).
The *Software* is still being developed by the *Licensor*.
*Licensor*'s goal is to allow the research community to use, test and evaluate
the *Software*.
## 1. Definitions
*Licensee* means any person or entity that uses the *Software* and distributes
its *Work*.
*Licensor* means the owners of the *Software*, i.e Inria and MPII
*Software* means the original work of authorship made available under this
License ie gaussian-splatting.
*Work* means the *Software* and any additions to or derivative works of the
*Software* that are made available under this License.
## 2. Purpose
This license is intended to define the rights granted to the *Licensee* by
Licensors under the *Software*.
## 3. Rights granted
For the above reasons Licensors have decided to distribute the *Software*.
Licensors grant non-exclusive rights to use the *Software* for research purposes
to research users (both academic and industrial), free of charge, without right
to sublicense.. The *Software* may be used "non-commercially", i.e., for research
and/or evaluation purposes only.
Subject to the terms and conditions of this License, you are granted a
non-exclusive, royalty-free, license to reproduce, prepare derivative works of,
publicly display, publicly perform and distribute its *Work* and any resulting
derivative works in any form.
## 4. Limitations
**4.1 Redistribution.** You may reproduce or distribute the *Work* only if (a) you do
so under this License, (b) you include a complete copy of this License with
your distribution, and (c) you retain without modification any copyright,
patent, trademark, or attribution notices that are present in the *Work*.
**4.2 Derivative Works.** You may specify that additional or different terms apply
to the use, reproduction, and distribution of your derivative works of the *Work*
("Your Terms") only if (a) Your Terms provide that the use limitation in
Section 2 applies to your derivative works, and (b) you identify the specific
derivative works that are subject to Your Terms. Notwithstanding Your Terms,
this License (including the redistribution requirements in Section 3.1) will
continue to apply to the *Work* itself.
**4.3** Any other use without of prior consent of Licensors is prohibited. Research
users explicitly acknowledge having received from Licensors all information
allowing to appreciate the adequacy between of the *Software* and their needs and
to undertake all necessary precautions for its execution and use.
**4.4** The *Software* is provided both as a compiled library file and as source
code. In case of using the *Software* for a publication or other results obtained
through the use of the *Software*, users are strongly encouraged to cite the
corresponding publications as explained in the documentation of the *Software*.
## 5. Disclaimer
THE USER CANNOT USE, EXPLOIT OR DISTRIBUTE THE *SOFTWARE* FOR COMMERCIAL PURPOSES
WITHOUT PRIOR AND EXPLICIT CONSENT OF LICENSORS. YOU MUST CONTACT INRIA FOR ANY
UNAUTHORIZED USE: stip-sophia.transfert@inria.fr . ANY SUCH ACTION WILL
CONSTITUTE A FORGERY. THIS *SOFTWARE* IS PROVIDED "AS IS" WITHOUT ANY WARRANTIES
OF ANY NATURE AND ANY EXPRESS OR IMPLIED WARRANTIES, WITH REGARDS TO COMMERCIAL
USE, PROFESSIONNAL USE, LEGAL OR NOT, OR OTHER, OR COMMERCIALISATION OR
ADAPTATION. UNLESS EXPLICITLY PROVIDED BY LAW, IN NO EVENT, SHALL INRIA OR THE
AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING FROM, OUT OF OR
IN CONNECTION WITH THE *SOFTWARE* OR THE USE OR OTHER DEALINGS IN THE *SOFTWARE*.
================================================
FILE: README.md
================================================
- <p align="center">
<h1 align="center">AbsGS: Recovering Fine Details for 3D Gaussian Splatting</h1>
<p align="center">
<a href="https://github.com/TY424">Zongxin Ye</a><sup>+</sup>
·
<a href="https://leo-frank.github.io">Wenyu Li</a><sup>+</sup>
·
<a href="https://github.com/Liu-SD">Sidun Liu</a>
·
<a href="https://github.com/qiaopTDUN">Peng Qiao</a>
·
<a >Yong Dou</a>
</p>
<h3 align="center"> <a href="https://arxiv.org/pdf/2404.10484.pdf">arXiv</a> | <a href="https://ty424.github.io/AbsGS.github.io/">Project Page</a> | <a href="https://github.com/TY424/AbsGS">Code</a> </h3>
<div align="center"></div>
</p>
<p align="center">
<a href="">
<img src="./README.assets/image-20240418110728875.png" alt="Logo" width="100%">
</a>
</p>
<p align="left">
This repository contains code for "AbsGS: Recovering Fine Details for 3D Gaussian Splatting" (ACM MM 2024).
<br>
<p align="left">
We reveal that the original adaptive density control strategy in 3D Gaussian Splatting (3D-GS) has the flaw of gradient collision which results in degradation, and propose homodirectional gradient as the guidance for densification. (a) Our method recovers fine details and achieves higher quality novel view synthesis results. SSIM, PSNR, LPIPS are inset. (b) Our proposed method yields more reasonable distribution of Gaussion points with comparable number of Gaussians and memory consumption with 3D-GS. (c) By adopting our method, the large Gaussians in over-reconstructed regions that lead to blur are eliminated.</p>
<br>
## Installation
The repository contains submodules, thus please check it out with
```shell
git clone git@github.com:TY424/AbsGS.git --recursive
# if you have an environment used for 3dgs, use it
# if not, create a new environment
conda env create --file environment.yml
conda activate Absgs
cd submodules/
python ./diff-gaussian-rasterization-abs/setup.py install
python ./simple-knn/setup.py install
```
## Training and Evaluation
```
# Train
python train.py
-s <path to COLMAP or NeRF Synthetic dataset>
-m <output path>
--eval # Train with train/test split
# Generate renderings
python render.py -s <path to COLMAP or NeRF Synthetic dataset> -m <output path>
# Compute error metrics on renderings
python metrics.py -m <path to trained model>
# This script specifies the routine used in our evaluation
python full_eval.py -m360 <mipnerf360 folder> -tat <tanks and temples folder> -db <deep blending folder>
```
## Some minor changes
Based on AbsGS, we have made some minor modifications to improve performance in large scenarios. None of these modifications were utilized in our paper.
### Initial pruning
We noticed that the visualization results of point clouds in COLMAP are inconsistent with those in the `.ply` file, as COLMAP filters them based on reprojection errors and track length during visualization. Therefore, we modified the `read_points3D_binary` function. In addition, pruning is performed initially based on the size of the radius to remove noise.
<img src="./README.assets/point.jpeg" alt="point" style="zoom:13%;" />
### Weight-based pruning
Taking inspiration from the pruning strategy based on ```max_radii2d``` in 3DGS, we conduct pruning based on the contribution (```max_weight```) of the Gaussian during rendering , where ```max_weight``` represents the maximum weight of the Gaussian participated in all rendering processes.
In fact, the pruning strategy based on max_radii2d does not work for 3DGS, and we haven't fixed this bug.
<img src="./README.assets/Sci-Art.jpeg" alt="Sci-Art" style="zoom: 15%;" />
>Sci-Art scene from UrbanScene3D dataset
>
>w/ prune: uses Initial pruning and weight-based pruning
## New Arguments
#### --percent_dense
Percentage of scene extent (0--1) a point must exceed to be splite, ```0.001``` by default.
#### --densify_grad_threshold
Limit that decides if points should be cloned based on 2D position gradient, ```0.0002``` by default.
#### --densify_grad_abs_threshold
Limit that decides if points should be splite based on homodirectional gradient, ```0.0004``` by default.
#### --use_reduce
Whether to periodically reduce opacity, ```True``` by default.
#### --opacity_reduce_interval
How frequently to reduce opacity, ```3_000``` by default.
#### --use_prune_weight
Whether to prune based on weights, ```False``` by default.
#### --min_weight
Gaussians with weights less than this threshold will be pruned, ```0.5``` by default.
#### --prune_until_iter
Iteration where pruning by weight stops, ```15_000``` by default.
# Citation
If you find our code or paper useful, please consider citing:
```bibtex
@misc{ye2024absgs,
title={AbsGS: Recovering Fine Details for 3D Gaussian Splatting},
author={Zongxin Ye and Wenyu Li and Sidun Liu and Peng Qiao and Yong Dou},
year={2024},
eprint={2404.10484},
archivePrefix={arXiv},
primaryClass={cs.CV}
}
@Article{kerbl3Dgaussians,
author = {Kerbl, Bernhard and Kopanas, Georgios and Leimk{\"u}hler, Thomas and Drettakis, George},
title = {3D Gaussian Splatting for Real-Time Radiance Field Rendering},
journal = {ACM Transactions on Graphics},
number = {4},
volume = {42},
month = {July},
year = {2023},
url = {https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/}
}
```
================================================
FILE: arguments/__init__.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
from argparse import ArgumentParser, Namespace
import sys
import os
class GroupParams:
pass
class ParamGroup:
def __init__(self, parser: ArgumentParser, name : str, fill_none = False):
group = parser.add_argument_group(name)
for key, value in vars(self).items():
shorthand = False
if key.startswith("_"):
shorthand = True
key = key[1:]
t = type(value)
value = value if not fill_none else None
if shorthand:
if t == bool:
group.add_argument("--" + key, ("-" + key[0:1]), default=value, action="store_true")
else:
group.add_argument("--" + key, ("-" + key[0:1]), default=value, type=t)
else:
if t == bool:
group.add_argument("--" + key, default=value, action="store_true")
else:
group.add_argument("--" + key, default=value, type=t)
def extract(self, args):
group = GroupParams()
for arg in vars(args).items():
if arg[0] in vars(self) or ("_" + arg[0]) in vars(self):
setattr(group, arg[0], arg[1])
return group
class ModelParams(ParamGroup):
def __init__(self, parser, sentinel=False):
self.sh_degree = 3
self._source_path = ""
self._model_path = ""
self._images = "images"
self._resolution = -1
self._white_background = False
self.data_device = "cuda"
self.eval = False
self.init_prune = False # For removing initial noises.
super().__init__(parser, "Loading Parameters", sentinel)
def extract(self, args):
g = super().extract(args)
g.source_path = os.path.abspath(g.source_path)
return g
class PipelineParams(ParamGroup):
def __init__(self, parser):
self.convert_SHs_python = False
self.compute_cov3D_python = False
self.debug = False
super().__init__(parser, "Pipeline Parameters")
class OptimizationParams(ParamGroup):
def __init__(self, parser):
self.iterations = 30_000
self.position_lr_init = 0.00016
self.position_lr_final = 0.0000016
self.position_lr_delay_mult = 0.01
self.position_lr_max_steps = 30_000
self.feature_lr = 0.0025
self.opacity_lr = 0.05
self.scaling_lr = 0.005
self.rotation_lr = 0.001
self.percent_dense = 0.001 # 0.01
self.lambda_dssim = 0.2
self.densification_interval = 100
self.opacity_reset_interval = 3000
self.densify_from_iter = 500
self.densify_until_iter = 15000
self.densify_grad_threshold = 0.0002
self.densify_grad_abs_threshold = 0.0004
self.use_reduce = True
self.opacity_reduce_interval = 500 # remove floater
self.use_prune_weight = False
self.prune_until_iter = 25000
self.min_weight = 0.7
self.random_background = False
super().__init__(parser, "Optimization Parameters")
def get_combined_args(parser : ArgumentParser):
cmdlne_string = sys.argv[1:]
cfgfile_string = "Namespace()"
args_cmdline = parser.parse_args(cmdlne_string)
try:
cfgfilepath = os.path.join(args_cmdline.model_path, "cfg_args")
print("Looking for config file in", cfgfilepath)
with open(cfgfilepath) as cfg_file:
print("Config file found: {}".format(cfgfilepath))
cfgfile_string = cfg_file.read()
except TypeError:
print("Config file not found at")
pass
args_cfgfile = eval(cfgfile_string)
merged_dict = vars(args_cfgfile).copy()
for k,v in vars(args_cmdline).items():
if v != None:
merged_dict[k] = v
return Namespace(**merged_dict)
================================================
FILE: convert.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import os
import logging
from argparse import ArgumentParser
import shutil
# This Python script is based on the shell converter script provided in the MipNerF 360 repository.
parser = ArgumentParser("Colmap converter")
parser.add_argument("--no_gpu", action='store_true')
parser.add_argument("--skip_matching", action='store_true')
parser.add_argument("--source_path", "-s", required=True, type=str)
parser.add_argument("--camera", default="OPENCV", type=str)
parser.add_argument("--colmap_executable", default="", type=str)
parser.add_argument("--resize", action="store_true")
parser.add_argument("--magick_executable", default="", type=str)
args = parser.parse_args()
colmap_command = '"{}"'.format(args.colmap_executable) if len(args.colmap_executable) > 0 else "colmap"
magick_command = '"{}"'.format(args.magick_executable) if len(args.magick_executable) > 0 else "magick"
use_gpu = 1 if not args.no_gpu else 0
if not args.skip_matching:
os.makedirs(args.source_path + "/distorted/sparse", exist_ok=True)
## Feature extraction
feat_extracton_cmd = colmap_command + " feature_extractor "\
"--database_path " + args.source_path + "/distorted/database.db \
--image_path " + args.source_path + "/input \
--ImageReader.single_camera 1 \
--ImageReader.camera_model " + args.camera + " \
--SiftExtraction.use_gpu " + str(use_gpu)
exit_code = os.system(feat_extracton_cmd)
if exit_code != 0:
logging.error(f"Feature extraction failed with code {exit_code}. Exiting.")
exit(exit_code)
## Feature matching
feat_matching_cmd = colmap_command + " exhaustive_matcher \
--database_path " + args.source_path + "/distorted/database.db \
--SiftMatching.use_gpu " + str(use_gpu)
exit_code = os.system(feat_matching_cmd)
if exit_code != 0:
logging.error(f"Feature matching failed with code {exit_code}. Exiting.")
exit(exit_code)
### Bundle adjustment
# The default Mapper tolerance is unnecessarily large,
# decreasing it speeds up bundle adjustment steps.
mapper_cmd = (colmap_command + " mapper \
--database_path " + args.source_path + "/distorted/database.db \
--image_path " + args.source_path + "/input \
--output_path " + args.source_path + "/distorted/sparse \
--Mapper.ba_global_function_tolerance=0.000001")
exit_code = os.system(mapper_cmd)
if exit_code != 0:
logging.error(f"Mapper failed with code {exit_code}. Exiting.")
exit(exit_code)
### Image undistortion
## We need to undistort our images into ideal pinhole intrinsics.
img_undist_cmd = (colmap_command + " image_undistorter \
--image_path " + args.source_path + "/input \
--input_path " + args.source_path + "/distorted/sparse/0 \
--output_path " + args.source_path + "\
--output_type COLMAP")
exit_code = os.system(img_undist_cmd)
if exit_code != 0:
logging.error(f"Mapper failed with code {exit_code}. Exiting.")
exit(exit_code)
files = os.listdir(args.source_path + "/sparse")
os.makedirs(args.source_path + "/sparse/0", exist_ok=True)
# Copy each file from the source directory to the destination directory
for file in files:
if file == '0':
continue
source_file = os.path.join(args.source_path, "sparse", file)
destination_file = os.path.join(args.source_path, "sparse", "0", file)
shutil.move(source_file, destination_file)
if(args.resize):
print("Copying and resizing...")
# Resize images.
os.makedirs(args.source_path + "/images_2", exist_ok=True)
os.makedirs(args.source_path + "/images_4", exist_ok=True)
os.makedirs(args.source_path + "/images_8", exist_ok=True)
# Get the list of files in the source directory
files = os.listdir(args.source_path + "/images")
# Copy each file from the source directory to the destination directory
for file in files:
source_file = os.path.join(args.source_path, "images", file)
destination_file = os.path.join(args.source_path, "images_2", file)
shutil.copy2(source_file, destination_file)
exit_code = os.system(magick_command + " mogrify -resize 50% " + destination_file)
if exit_code != 0:
logging.error(f"50% resize failed with code {exit_code}. Exiting.")
exit(exit_code)
destination_file = os.path.join(args.source_path, "images_4", file)
shutil.copy2(source_file, destination_file)
exit_code = os.system(magick_command + " mogrify -resize 25% " + destination_file)
if exit_code != 0:
logging.error(f"25% resize failed with code {exit_code}. Exiting.")
exit(exit_code)
destination_file = os.path.join(args.source_path, "images_8", file)
shutil.copy2(source_file, destination_file)
exit_code = os.system(magick_command + " mogrify -resize 12.5% " + destination_file)
if exit_code != 0:
logging.error(f"12.5% resize failed with code {exit_code}. Exiting.")
exit(exit_code)
print("Done.")
================================================
FILE: environment.yml
================================================
name: Absgs
channels:
- pytorch
- conda-forge
- defaults
dependencies:
- cudatoolkit=11.6
- plyfile
- python=3.7.13
- pip=22.3.1
- pytorch=1.12.1
- torchaudio=0.12.1
- torchvision=0.13.1
- tqdm
- pip:
- submodules/diff-gaussian-rasterization-abs
- submodules/simple-knn
================================================
FILE: full_eval.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import os
from argparse import ArgumentParser
# mipnerf360_outdoor_scenes = ["bicycle", "flowers", "garden", "stump", "treehill"]
# mipnerf360_indoor_scenes = ["room", "counter", "kitchen", "bonsai"]
# tanks_and_temples_scenes = ["truck", "train"]
# deep_blending_scenes = ["drjohnson", "playroom"]
mipnerf360_outdoor_scenes = ["bicycle"]
mipnerf360_indoor_scenes = []
tanks_and_temples_scenes = []
deep_blending_scenes = []
parser = ArgumentParser(description="Full evaluation script parameters")
parser.add_argument("--skip_training", action="store_true")
parser.add_argument("--skip_rendering", action="store_true")
parser.add_argument("--skip_metrics", action="store_true")
parser.add_argument("--output_path", default="./eval")
args, _ = parser.parse_known_args()
all_scenes = []
all_scenes.extend(mipnerf360_outdoor_scenes)
all_scenes.extend(mipnerf360_indoor_scenes)
all_scenes.extend(tanks_and_temples_scenes)
all_scenes.extend(deep_blending_scenes)
if not args.skip_training or not args.skip_rendering:
parser.add_argument('--mipnerf360', "-m360", required=True, type=str)
parser.add_argument("--tanksandtemples", "-tat", required=True, type=str)
parser.add_argument("--deepblending", "-db", required=True, type=str)
args = parser.parse_args()
if not args.skip_training:
common_args = " --quiet --eval --test_iterations -1 "
for scene in mipnerf360_outdoor_scenes:
source = args.mipnerf360 + "/" + scene
print("python train.py -s " + source + " -i images_4 -m " + args.output_path + "/" + scene + common_args)
os.system("python train.py -s " + source + " -i images_4 -m " + args.output_path + "/" + scene + common_args)
for scene in mipnerf360_indoor_scenes:
source = args.mipnerf360 + "/" + scene
os.system("python train.py -s " + source + " -i images_2 -m " + args.output_path + "/" + scene + common_args)
for scene in tanks_and_temples_scenes:
source = args.tanksandtemples + "/" + scene
os.system("python train.py -s " + source + " -m " + args.output_path + "/" + scene + common_args)
for scene in deep_blending_scenes:
source = args.deepblending + "/" + scene
os.system("python train.py -s " + source + " -m " + args.output_path + "/" + scene + common_args)
if not args.skip_rendering:
all_sources = []
for scene in mipnerf360_outdoor_scenes:
all_sources.append(args.mipnerf360 + "/" + scene)
for scene in mipnerf360_indoor_scenes:
all_sources.append(args.mipnerf360 + "/" + scene)
for scene in tanks_and_temples_scenes:
all_sources.append(args.tanksandtemples + "/" + scene)
for scene in deep_blending_scenes:
all_sources.append(args.deepblending + "/" + scene)
common_args = " --quiet --eval --skip_train"
for scene, source in zip(all_scenes, all_sources):
os.system("python render.py --iteration 7000 -s " + source + " -m " + args.output_path + "/" + scene + common_args)
os.system("python render.py --iteration 30000 -s " + source + " -m " + args.output_path + "/" + scene + common_args)
if not args.skip_metrics:
scenes_string = ""
for scene in all_scenes:
scenes_string += "\"" + args.output_path + "/" + scene + "\" "
os.system("python metrics.py -m " + scenes_string)
================================================
FILE: gaussian_renderer/__init__.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import torch
import math
# from diff_gaussian_rasterization import GaussianRasterizationSettings, GaussianRasterizer
from diff_gaussian_rasterization_abs import GaussianRasterizationSettings, GaussianRasterizer
from scene.gaussian_model import GaussianModel
from utils.sh_utils import eval_sh
def render(viewpoint_camera, pc : GaussianModel, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, override_color = None):
"""
Render the scene.
Background tensor (bg_color) must be on GPU!
"""
# Create zero tensor. We will use it to make pytorch return gradients of the 2D (screen-space) means
screenspace_points = torch.zeros((pc.get_xyz.shape[0], 4), dtype=pc.get_xyz.dtype, requires_grad=True, device="cuda") + 0
try:
screenspace_points.retain_grad()
except:
pass
# Set up rasterization configuration
tanfovx = math.tan(viewpoint_camera.FoVx * 0.5)
tanfovy = math.tan(viewpoint_camera.FoVy * 0.5)
raster_settings = GaussianRasterizationSettings(
image_height=int(viewpoint_camera.image_height),
image_width=int(viewpoint_camera.image_width),
tanfovx=tanfovx,
tanfovy=tanfovy,
bg=bg_color,
scale_modifier=scaling_modifier,
viewmatrix=viewpoint_camera.world_view_transform,
projmatrix=viewpoint_camera.full_proj_transform,
sh_degree=pc.active_sh_degree,
campos=viewpoint_camera.camera_center,
prefiltered=False,
debug=pipe.debug
)
rasterizer = GaussianRasterizer(raster_settings=raster_settings)
means3D = pc.get_xyz
means2D = screenspace_points
opacity = pc.get_opacity
# If precomputed 3d covariance is provided, use it. If not, then it will be computed from
# scaling / rotation by the rasterizer.
scales = None
rotations = None
cov3D_precomp = None
if pipe.compute_cov3D_python:
cov3D_precomp = pc.get_covariance(scaling_modifier)
else:
scales = pc.get_scaling
rotations = pc.get_rotation
# If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors
# from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer.
shs = None
colors_precomp = None
if override_color is None:
if pipe.convert_SHs_python:
shs_view = pc.get_features.transpose(1, 2).view(-1, 3, (pc.max_sh_degree+1)**2)
dir_pp = (pc.get_xyz - viewpoint_camera.camera_center.repeat(pc.get_features.shape[0], 1))
dir_pp_normalized = dir_pp/dir_pp.norm(dim=1, keepdim=True)
sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized)
colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0)
else:
shs = pc.get_features
else:
colors_precomp = override_color
# Rasterize visible Gaussians to image, obtain their radii (on screen).
gs_w = None
rendered_image, radii, gs_w = rasterizer(
means3D = means3D,
means2D = means2D,
shs = shs,
colors_precomp = colors_precomp,
opacities = opacity,
scales = scales,
rotations = rotations,
cov3D_precomp = cov3D_precomp)
# Those Gaussians that were frustum culled or had a radius of 0 were not visible.
# They will be excluded from value updates used in the splitting criteria.
return {"render": rendered_image,
"viewspace_points": screenspace_points,
"visibility_filter" : radii > 0,
"radii": radii,
"gs_w": gs_w
}
================================================
FILE: gaussian_renderer/network_gui.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import torch
import traceback
import socket
import json
from scene.cameras import MiniCam
host = "127.0.0.1"
port = 6009
conn = None
addr = None
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def init(wish_host, wish_port):
global host, port, listener
host = wish_host
port = wish_port
listener.bind((host, port))
listener.listen()
listener.settimeout(0)
def try_connect():
global conn, addr, listener
try:
conn, addr = listener.accept()
print(f"\nConnected by {addr}")
conn.settimeout(None)
except Exception as inst:
pass
def read():
global conn
messageLength = conn.recv(4)
messageLength = int.from_bytes(messageLength, 'little')
message = conn.recv(messageLength)
return json.loads(message.decode("utf-8"))
def send(message_bytes, verify):
global conn
if message_bytes != None:
conn.sendall(message_bytes)
conn.sendall(len(verify).to_bytes(4, 'little'))
conn.sendall(bytes(verify, 'ascii'))
def receive():
message = read()
width = message["resolution_x"]
height = message["resolution_y"]
if width != 0 and height != 0:
try:
do_training = bool(message["train"])
fovy = message["fov_y"]
fovx = message["fov_x"]
znear = message["z_near"]
zfar = message["z_far"]
do_shs_python = bool(message["shs_python"])
do_rot_scale_python = bool(message["rot_scale_python"])
keep_alive = bool(message["keep_alive"])
scaling_modifier = message["scaling_modifier"]
world_view_transform = torch.reshape(torch.tensor(message["view_matrix"]), (4, 4)).cuda()
world_view_transform[:,1] = -world_view_transform[:,1]
world_view_transform[:,2] = -world_view_transform[:,2]
full_proj_transform = torch.reshape(torch.tensor(message["view_projection_matrix"]), (4, 4)).cuda()
full_proj_transform[:,1] = -full_proj_transform[:,1]
custom_cam = MiniCam(width, height, fovy, fovx, znear, zfar, world_view_transform, full_proj_transform)
except Exception as e:
print("")
traceback.print_exc()
raise e
return custom_cam, do_training, do_shs_python, do_rot_scale_python, keep_alive, scaling_modifier
else:
return None, None, None, None, None, None
================================================
FILE: lpipsPyTorch/__init__.py
================================================
import torch
from .modules.lpips import LPIPS
def lpips(x: torch.Tensor,
y: torch.Tensor,
net_type: str = 'alex',
version: str = '0.1'):
r"""Function that measures
Learned Perceptual Image Patch Similarity (LPIPS).
Arguments:
x, y (torch.Tensor): the input tensors to compare.
net_type (str): the network type to compare the features:
'alex' | 'squeeze' | 'vgg'. Default: 'alex'.
version (str): the version of LPIPS. Default: 0.1.
"""
device = x.device
criterion = LPIPS(net_type, version).to(device)
return criterion(x, y)
================================================
FILE: lpipsPyTorch/modules/lpips.py
================================================
import torch
import torch.nn as nn
from .networks import get_network, LinLayers
from .utils import get_state_dict
class LPIPS(nn.Module):
r"""Creates a criterion that measures
Learned Perceptual Image Patch Similarity (LPIPS).
Arguments:
net_type (str): the network type to compare the features:
'alex' | 'squeeze' | 'vgg'. Default: 'alex'.
version (str): the version of LPIPS. Default: 0.1.
"""
def __init__(self, net_type: str = 'alex', version: str = '0.1'):
assert version in ['0.1'], 'v0.1 is only supported now'
super(LPIPS, self).__init__()
# pretrained network
self.net = get_network(net_type)
# linear layers
self.lin = LinLayers(self.net.n_channels_list)
self.lin.load_state_dict(get_state_dict(net_type, version))
def forward(self, x: torch.Tensor, y: torch.Tensor):
feat_x, feat_y = self.net(x), self.net(y)
diff = [(fx - fy) ** 2 for fx, fy in zip(feat_x, feat_y)]
res = [l(d).mean((2, 3), True) for d, l in zip(diff, self.lin)]
return torch.sum(torch.cat(res, 0), 0, True)
================================================
FILE: lpipsPyTorch/modules/networks.py
================================================
from typing import Sequence
from itertools import chain
import torch
import torch.nn as nn
from torchvision import models
from .utils import normalize_activation
def get_network(net_type: str):
if net_type == 'alex':
return AlexNet()
elif net_type == 'squeeze':
return SqueezeNet()
elif net_type == 'vgg':
return VGG16()
else:
raise NotImplementedError('choose net_type from [alex, squeeze, vgg].')
class LinLayers(nn.ModuleList):
def __init__(self, n_channels_list: Sequence[int]):
super(LinLayers, self).__init__([
nn.Sequential(
nn.Identity(),
nn.Conv2d(nc, 1, 1, 1, 0, bias=False)
) for nc in n_channels_list
])
for param in self.parameters():
param.requires_grad = False
class BaseNet(nn.Module):
def __init__(self):
super(BaseNet, self).__init__()
# register buffer
self.register_buffer(
'mean', torch.Tensor([-.030, -.088, -.188])[None, :, None, None])
self.register_buffer(
'std', torch.Tensor([.458, .448, .450])[None, :, None, None])
def set_requires_grad(self, state: bool):
for param in chain(self.parameters(), self.buffers()):
param.requires_grad = state
def z_score(self, x: torch.Tensor):
return (x - self.mean) / self.std
def forward(self, x: torch.Tensor):
x = self.z_score(x)
output = []
for i, (_, layer) in enumerate(self.layers._modules.items(), 1):
x = layer(x)
if i in self.target_layers:
output.append(normalize_activation(x))
if len(output) == len(self.target_layers):
break
return output
class SqueezeNet(BaseNet):
def __init__(self):
super(SqueezeNet, self).__init__()
self.layers = models.squeezenet1_1(True).features
self.target_layers = [2, 5, 8, 10, 11, 12, 13]
self.n_channels_list = [64, 128, 256, 384, 384, 512, 512]
self.set_requires_grad(False)
class AlexNet(BaseNet):
def __init__(self):
super(AlexNet, self).__init__()
self.layers = models.alexnet(True).features
self.target_layers = [2, 5, 8, 10, 12]
self.n_channels_list = [64, 192, 384, 256, 256]
self.set_requires_grad(False)
class VGG16(BaseNet):
def __init__(self):
super(VGG16, self).__init__()
self.layers = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1).features
self.target_layers = [4, 9, 16, 23, 30]
self.n_channels_list = [64, 128, 256, 512, 512]
self.set_requires_grad(False)
================================================
FILE: lpipsPyTorch/modules/utils.py
================================================
from collections import OrderedDict
import torch
def normalize_activation(x, eps=1e-10):
norm_factor = torch.sqrt(torch.sum(x ** 2, dim=1, keepdim=True))
return x / (norm_factor + eps)
def get_state_dict(net_type: str = 'alex', version: str = '0.1'):
# build url
url = 'https://raw.githubusercontent.com/richzhang/PerceptualSimilarity/' \
+ f'master/lpips/weights/v{version}/{net_type}.pth'
# download
old_state_dict = torch.hub.load_state_dict_from_url(
url, progress=True,
map_location=None if torch.cuda.is_available() else torch.device('cpu')
)
# rename keys
new_state_dict = OrderedDict()
for key, val in old_state_dict.items():
new_key = key
new_key = new_key.replace('lin', '')
new_key = new_key.replace('model.', '')
new_state_dict[new_key] = val
return new_state_dict
================================================
FILE: metrics.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
from pathlib import Path
import os
from PIL import Image
import torch
import torchvision.transforms.functional as tf
from utils.loss_utils import ssim
from lpipsPyTorch import lpips
import json
from tqdm import tqdm
from utils.image_utils import psnr
from argparse import ArgumentParser
def readImages(renders_dir, gt_dir):
renders = []
gts = []
image_names = []
for fname in os.listdir(renders_dir):
render = Image.open(renders_dir / fname)
gt = Image.open(gt_dir / fname)
renders.append(tf.to_tensor(render).unsqueeze(0)[:, :3, :, :].cuda())
gts.append(tf.to_tensor(gt).unsqueeze(0)[:, :3, :, :].cuda())
image_names.append(fname)
return renders, gts, image_names
def evaluate(model_paths):
full_dict = {}
per_view_dict = {}
full_dict_polytopeonly = {}
per_view_dict_polytopeonly = {}
print("")
for scene_dir in model_paths:
try:
print("Scene:", scene_dir)
full_dict[scene_dir] = {}
per_view_dict[scene_dir] = {}
full_dict_polytopeonly[scene_dir] = {}
per_view_dict_polytopeonly[scene_dir] = {}
test_dir = Path(scene_dir) / "test"
for method in os.listdir(test_dir):
print("Method:", method)
full_dict[scene_dir][method] = {}
per_view_dict[scene_dir][method] = {}
full_dict_polytopeonly[scene_dir][method] = {}
per_view_dict_polytopeonly[scene_dir][method] = {}
method_dir = test_dir / method
gt_dir = method_dir/ "gt"
renders_dir = method_dir / "renders"
renders, gts, image_names = readImages(renders_dir, gt_dir)
ssims = []
psnrs = []
lpipss = []
for idx in tqdm(range(len(renders)), desc="Metric evaluation progress"):
ssims.append(ssim(renders[idx], gts[idx]))
psnrs.append(psnr(renders[idx], gts[idx]))
lpipss.append(lpips(renders[idx], gts[idx], net_type='vgg'))
print(" SSIM : {:>12.7f}".format(torch.tensor(ssims).mean(), ".5"))
print(" PSNR : {:>12.7f}".format(torch.tensor(psnrs).mean(), ".5"))
print(" LPIPS: {:>12.7f}".format(torch.tensor(lpipss).mean(), ".5"))
print("")
full_dict[scene_dir][method].update({"SSIM": torch.tensor(ssims).mean().item(),
"PSNR": torch.tensor(psnrs).mean().item(),
"LPIPS": torch.tensor(lpipss).mean().item()})
per_view_dict[scene_dir][method].update({"SSIM": {name: ssim for ssim, name in zip(torch.tensor(ssims).tolist(), image_names)},
"PSNR": {name: psnr for psnr, name in zip(torch.tensor(psnrs).tolist(), image_names)},
"LPIPS": {name: lp for lp, name in zip(torch.tensor(lpipss).tolist(), image_names)}})
with open(scene_dir + "/results.json", 'w') as fp:
json.dump(full_dict[scene_dir], fp, indent=True)
with open(scene_dir + "/per_view.json", 'w') as fp:
json.dump(per_view_dict[scene_dir], fp, indent=True)
except:
print("Unable to compute metrics for model", scene_dir)
if __name__ == "__main__":
device = torch.device("cuda:0")
torch.cuda.set_device(device)
# Set up command line argument parser
parser = ArgumentParser(description="Training script parameters")
parser.add_argument('--model_paths', '-m', required=True, nargs="+", type=str, default=[])
args = parser.parse_args()
evaluate(args.model_paths)
================================================
FILE: render.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import torch
from scene import Scene
import os
from tqdm import tqdm
from os import makedirs
from gaussian_renderer import render
import torchvision
from utils.general_utils import safe_state
from argparse import ArgumentParser
from arguments import ModelParams, PipelineParams, get_combined_args
from gaussian_renderer import GaussianModel
def render_set(model_path, name, iteration, views, gaussians, pipeline, background):
render_path = os.path.join(model_path, name, "ours_{}".format(iteration), "renders")
gts_path = os.path.join(model_path, name, "ours_{}".format(iteration), "gt")
makedirs(render_path, exist_ok=True)
makedirs(gts_path, exist_ok=True)
for idx, view in enumerate(tqdm(views, desc="Rendering progress")):
rendering = render(view, gaussians, pipeline, background)["render"]
gt = view.original_image[0:3, :, :]
torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png"))
torchvision.utils.save_image(gt, os.path.join(gts_path, '{0:05d}'.format(idx) + ".png"))
def render_sets(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool):
with torch.no_grad():
gaussians = GaussianModel(dataset.sh_degree)
scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False)
bg_color = [1,1,1] if dataset.white_background else [0, 0, 0]
background = torch.tensor(bg_color, dtype=torch.float32, device="cuda")
if not skip_train:
render_set(dataset.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background)
if not skip_test:
render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background)
if __name__ == "__main__":
# Set up command line argument parser
parser = ArgumentParser(description="Testing script parameters")
model = ModelParams(parser, sentinel=True)
pipeline = PipelineParams(parser)
parser.add_argument("--iteration", default=-1, type=int)
parser.add_argument("--skip_train", action="store_true")
parser.add_argument("--skip_test", action="store_true")
parser.add_argument("--quiet", action="store_true")
args = get_combined_args(parser)
print("Rendering " + args.model_path)
# Initialize system state (RNG)
safe_state(args.quiet)
render_sets(model.extract(args), args.iteration, pipeline.extract(args), args.skip_train, args.skip_test)
================================================
FILE: scene/__init__.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import os
import random
import json
from utils.system_utils import searchForMaxIteration
from scene.dataset_readers import sceneLoadTypeCallbacks
from scene.gaussian_model import GaussianModel
from arguments import ModelParams
from utils.camera_utils import cameraList_from_camInfos, camera_to_JSON
class Scene:
gaussians : GaussianModel
def __init__(self, args : ModelParams, gaussians : GaussianModel, load_iteration=None, shuffle=True, resolution_scales=[1.0]):
"""b
:param path: Path to colmap scene main folder.
"""
self.model_path = args.model_path
self.loaded_iter = None
self.gaussians = gaussians
if load_iteration:
if load_iteration == -1:
self.loaded_iter = searchForMaxIteration(os.path.join(self.model_path, "point_cloud"))
else:
self.loaded_iter = load_iteration
print("Loading trained model at iteration {}".format(self.loaded_iter))
self.train_cameras = {}
self.test_cameras = {}
if os.path.exists(os.path.join(args.source_path, "sparse")):
scene_info = sceneLoadTypeCallbacks["Colmap"](args.source_path, args.images, args.eval)
elif os.path.exists(os.path.join(args.source_path, "transforms_train.json")):
print("Found transforms_train.json file, assuming Blender data set!")
scene_info = sceneLoadTypeCallbacks["Blender"](args.source_path, args.white_background, args.eval)
else:
assert False, "Could not recognize scene type!"
if not self.loaded_iter:
with open(scene_info.ply_path, 'rb') as src_file, open(os.path.join(self.model_path, "input.ply") , 'wb') as dest_file:
dest_file.write(src_file.read())
json_cams = []
camlist = []
if scene_info.test_cameras:
camlist.extend(scene_info.test_cameras)
if scene_info.train_cameras:
camlist.extend(scene_info.train_cameras)
for id, cam in enumerate(camlist):
json_cams.append(camera_to_JSON(id, cam))
with open(os.path.join(self.model_path, "cameras.json"), 'w') as file:
json.dump(json_cams, file)
if shuffle:
random.shuffle(scene_info.train_cameras) # Multi-res consistent random shuffling
random.shuffle(scene_info.test_cameras) # Multi-res consistent random shuffling
self.cameras_extent = scene_info.nerf_normalization["radius"]
for resolution_scale in resolution_scales:
print("Loading Training Cameras")
self.train_cameras[resolution_scale] = cameraList_from_camInfos(scene_info.train_cameras, resolution_scale, args)
print("Loading Test Cameras")
self.test_cameras[resolution_scale] = cameraList_from_camInfos(scene_info.test_cameras, resolution_scale, args)
if self.loaded_iter:
self.gaussians.load_ply(os.path.join(self.model_path,
"point_cloud",
"iteration_" + str(self.loaded_iter),
"point_cloud.ply"))
else:
self.gaussians.create_from_pcd(scene_info.point_cloud, self.cameras_extent)
def save(self, iteration):
point_cloud_path = os.path.join(self.model_path, "point_cloud/iteration_{}".format(iteration))
self.gaussians.save_ply(os.path.join(point_cloud_path, "point_cloud.ply"))
def getTrainCameras(self, scale=1.0):
return self.train_cameras[scale]
def getTestCameras(self, scale=1.0):
return self.test_cameras[scale]
================================================
FILE: scene/cameras.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import torch
from torch import nn
import numpy as np
from utils.graphics_utils import getWorld2View2, getProjectionMatrix
class Camera(nn.Module):
def __init__(self, colmap_id, R, T, FoVx, FoVy, image, gt_alpha_mask,
image_name, uid,
trans=np.array([0.0, 0.0, 0.0]), scale=1.0, data_device = "cuda"
):
super(Camera, self).__init__()
self.uid = uid
self.colmap_id = colmap_id
self.R = R
self.T = T
self.FoVx = FoVx
self.FoVy = FoVy
self.image_name = image_name
try:
self.data_device = torch.device(data_device)
except Exception as e:
print(e)
print(f"[Warning] Custom device {data_device} failed, fallback to default cuda device" )
self.data_device = torch.device("cuda")
self.original_image = image.clamp(0.0, 1.0)
self.image_width = self.original_image.shape[2]
self.image_height = self.original_image.shape[1]
if gt_alpha_mask is not None:
self.original_image *= gt_alpha_mask
else:
self.original_image *= torch.ones((1, self.image_height, self.image_width))
self.zfar = 100.0
self.znear = 0.01
self.trans = trans
self.scale = scale
self.world_view_transform = torch.tensor(getWorld2View2(R, T, trans, scale)).transpose(0, 1).cuda()
self.projection_matrix = getProjectionMatrix(znear=self.znear, zfar=self.zfar, fovX=self.FoVx, fovY=self.FoVy).transpose(0,1).cuda()
self.full_proj_transform = (self.world_view_transform.unsqueeze(0).bmm(self.projection_matrix.unsqueeze(0))).squeeze(0)
self.camera_center = self.world_view_transform.inverse()[3, :3]
class MiniCam:
def __init__(self, width, height, fovy, fovx, znear, zfar, world_view_transform, full_proj_transform):
self.image_width = width
self.image_height = height
self.FoVy = fovy
self.FoVx = fovx
self.znear = znear
self.zfar = zfar
self.world_view_transform = world_view_transform
self.full_proj_transform = full_proj_transform
view_inv = torch.inverse(self.world_view_transform)
self.camera_center = view_inv[3][:3]
================================================
FILE: scene/colmap_loader.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import numpy as np
import collections
import struct
CameraModel = collections.namedtuple(
"CameraModel", ["model_id", "model_name", "num_params"])
Camera = collections.namedtuple(
"Camera", ["id", "model", "width", "height", "params"])
BaseImage = collections.namedtuple(
"Image", ["id", "qvec", "tvec", "camera_id", "name", "xys", "point3D_ids"])
Point3D = collections.namedtuple(
"Point3D", ["id", "xyz", "rgb", "error", "image_ids", "point2D_idxs"])
CAMERA_MODELS = {
CameraModel(model_id=0, model_name="SIMPLE_PINHOLE", num_params=3),
CameraModel(model_id=1, model_name="PINHOLE", num_params=4),
CameraModel(model_id=2, model_name="SIMPLE_RADIAL", num_params=4),
CameraModel(model_id=3, model_name="RADIAL", num_params=5),
CameraModel(model_id=4, model_name="OPENCV", num_params=8),
CameraModel(model_id=5, model_name="OPENCV_FISHEYE", num_params=8),
CameraModel(model_id=6, model_name="FULL_OPENCV", num_params=12),
CameraModel(model_id=7, model_name="FOV", num_params=5),
CameraModel(model_id=8, model_name="SIMPLE_RADIAL_FISHEYE", num_params=4),
CameraModel(model_id=9, model_name="RADIAL_FISHEYE", num_params=5),
CameraModel(model_id=10, model_name="THIN_PRISM_FISHEYE", num_params=12)
}
CAMERA_MODEL_IDS = dict([(camera_model.model_id, camera_model)
for camera_model in CAMERA_MODELS])
CAMERA_MODEL_NAMES = dict([(camera_model.model_name, camera_model)
for camera_model in CAMERA_MODELS])
def qvec2rotmat(qvec):
return np.array([
[1 - 2 * qvec[2]**2 - 2 * qvec[3]**2,
2 * qvec[1] * qvec[2] - 2 * qvec[0] * qvec[3],
2 * qvec[3] * qvec[1] + 2 * qvec[0] * qvec[2]],
[2 * qvec[1] * qvec[2] + 2 * qvec[0] * qvec[3],
1 - 2 * qvec[1]**2 - 2 * qvec[3]**2,
2 * qvec[2] * qvec[3] - 2 * qvec[0] * qvec[1]],
[2 * qvec[3] * qvec[1] - 2 * qvec[0] * qvec[2],
2 * qvec[2] * qvec[3] + 2 * qvec[0] * qvec[1],
1 - 2 * qvec[1]**2 - 2 * qvec[2]**2]])
def rotmat2qvec(R):
Rxx, Ryx, Rzx, Rxy, Ryy, Rzy, Rxz, Ryz, Rzz = R.flat
K = np.array([
[Rxx - Ryy - Rzz, 0, 0, 0],
[Ryx + Rxy, Ryy - Rxx - Rzz, 0, 0],
[Rzx + Rxz, Rzy + Ryz, Rzz - Rxx - Ryy, 0],
[Ryz - Rzy, Rzx - Rxz, Rxy - Ryx, Rxx + Ryy + Rzz]]) / 3.0
eigvals, eigvecs = np.linalg.eigh(K)
qvec = eigvecs[[3, 0, 1, 2], np.argmax(eigvals)]
if qvec[0] < 0:
qvec *= -1
return qvec
class Image(BaseImage):
def qvec2rotmat(self):
return qvec2rotmat(self.qvec)
def read_next_bytes(fid, num_bytes, format_char_sequence, endian_character="<"):
"""Read and unpack the next bytes from a binary file.
:param fid:
:param num_bytes: Sum of combination of {2, 4, 8}, e.g. 2, 6, 16, 30, etc.
:param format_char_sequence: List of {c, e, f, d, h, H, i, I, l, L, q, Q}.
:param endian_character: Any of {@, =, <, >, !}
:return: Tuple of read and unpacked values.
"""
data = fid.read(num_bytes)
return struct.unpack(endian_character + format_char_sequence, data)
def read_points3D_text_3DGS(path):
"""
see: src/base/reconstruction.cc
void Reconstruction::ReadPoints3DText(const std::string& path)
void Reconstruction::WritePoints3DText(const std::string& path)
"""
xyzs = None
rgbs = None
errors = None
num_points = 0
with open(path, "r") as fid:
while True:
line = fid.readline()
if not line:
break
line = line.strip()
if len(line) > 0 and line[0] != "#":
num_points += 1
xyzs = np.empty((num_points, 3))
rgbs = np.empty((num_points, 3))
errors = np.empty((num_points, 1))
count = 0
with open(path, "r") as fid:
while True:
line = fid.readline()
if not line:
break
line = line.strip()
if len(line) > 0 and line[0] != "#":
elems = line.split()
xyz = np.array(tuple(map(float, elems[1:4])))
rgb = np.array(tuple(map(int, elems[4:7])))
error = np.array(float(elems[7]))
xyzs[count] = xyz
rgbs[count] = rgb
errors[count] = error
count += 1
return xyzs, rgbs, errors
def read_points3D_text(path, max_err=2, min_track_length=3):
"""
see: src/base/reconstruction.cc
void Reconstruction::ReadPoints3DText(const std::string& path)
void Reconstruction::WritePoints3DText(const std::string& path)
The colmap visualization filters out points with err greater than 2.0 and track length less than 3
see: src/ui/model_viewer_widget.cc
void ModelViewerWidget::UploadPointData(const bool selection_mode)
"""
xyzs = None
rgbs = None
errors = None
num_points = 0
with open(path, "r") as fid:
while True:
line = fid.readline()
if not line:
break
line = line.strip()
if len(line) > 0 and line[0] != "#":
num_points += 1
xyzs = np.empty((num_points, 3))
rgbs = np.empty((num_points, 3))
errors = np.empty((num_points, 1))
count = 0
with open(path, "r") as fid:
while True:
line = fid.readline()
if not line:
break
line = line.strip()
if len(line) > 0 and line[0] != "#":
elems = line.split()
xyz = np.array(tuple(map(float, elems[1:4])))
rgb = np.array(tuple(map(int, elems[4:7])))
error = np.array(float(elems[7]))
track_length = int(len(elems[8:]) / 2)
if error > max_err or track_length < min_track_length:
continue
xyzs[count] = xyz
rgbs[count] = rgb
errors[count] = error
count += 1
xyzs = np.delete(xyzs,np.arange(count,num_points),axis=0)
rgbs = np.delete(rgbs, np.arange(count, num_points), axis=0)
errors = np.delete(errors, np.arange(count, num_points), axis=0)
return xyzs, rgbs, errors
def read_points3D_binary_3DGS(path_to_model_file):
"""
see: src/base/reconstruction.cc
void Reconstruction::ReadPoints3DBinary(const std::string& path)
void Reconstruction::WritePoints3DBinary(const std::string& path)
"""
with open(path_to_model_file, "rb") as fid:
num_points = read_next_bytes(fid, 8, "Q")[0]
xyzs = np.empty((num_points, 3))
rgbs = np.empty((num_points, 3))
errors = np.empty((num_points, 1))
for p_id in range(num_points):
binary_point_line_properties = read_next_bytes(
fid, num_bytes=43, format_char_sequence="QdddBBBd")
xyz = np.array(binary_point_line_properties[1:4])
rgb = np.array(binary_point_line_properties[4:7])
error = np.array(binary_point_line_properties[7])
track_length = read_next_bytes(
fid, num_bytes=8, format_char_sequence="Q")[0]
track_elems = read_next_bytes(
fid, num_bytes=8*track_length,
format_char_sequence="ii"*track_length)
xyzs[p_id] = xyz
rgbs[p_id] = rgb
errors[p_id] = error
return xyzs, rgbs, errors
def read_points3D_binary(path_to_model_file,max_err=2,min_track_length=3):
"""
see: src/base/reconstruction.cc
void Reconstruction::ReadPoints3DBinary(const std::string& path)
void Reconstruction::WritePoints3DBinary(const std::string& path)
The colmap visualization filters out points with err greater than 2.0 and track length less than 3
see: src/ui/model_viewer_widget.cc
void ModelViewerWidget::UploadPointData(const bool selection_mode)
"""
with open(path_to_model_file, "rb") as fid:
num_points = read_next_bytes(fid, 8, "Q")[0]
xyzs = np.empty((num_points, 3))
rgbs = np.empty((num_points, 3))
errors = np.empty((num_points, 1))
count = 0
for p_id in range(num_points):
binary_point_line_properties = read_next_bytes(
fid, num_bytes=43, format_char_sequence="QdddBBBd")
xyz = np.array(binary_point_line_properties[1:4])
rgb = np.array(binary_point_line_properties[4:7])
error = np.array(binary_point_line_properties[7])
track_length = read_next_bytes(
fid, num_bytes=8, format_char_sequence="Q")[0]
track_elems = read_next_bytes(
fid, num_bytes=8*track_length,
format_char_sequence="ii"*track_length)
if error > max_err or track_length < min_track_length:
continue
xyzs[count] = xyz
rgbs[count] = rgb
errors[count] = error
count +=1
xyzs = np.delete(xyzs,np.arange(count,num_points),axis=0)
rgbs = np.delete(rgbs, np.arange(count, num_points), axis=0)
errors = np.delete(errors, np.arange(count, num_points), axis=0)
return xyzs, rgbs, errors
def read_intrinsics_text(path):
"""
Taken from https://github.com/colmap/colmap/blob/dev/scripts/python/read_write_model.py
"""
cameras = {}
with open(path, "r") as fid:
while True:
line = fid.readline()
if not line:
break
line = line.strip()
if len(line) > 0 and line[0] != "#":
elems = line.split()
camera_id = int(elems[0])
model = elems[1]
assert model == "PINHOLE", "While the loader support other types, the rest of the code assumes PINHOLE"
width = int(elems[2])
height = int(elems[3])
params = np.array(tuple(map(float, elems[4:])))
cameras[camera_id] = Camera(id=camera_id, model=model,
width=width, height=height,
params=params)
return cameras
def read_extrinsics_binary(path_to_model_file):
"""
see: src/base/reconstruction.cc
void Reconstruction::ReadImagesBinary(const std::string& path)
void Reconstruction::WriteImagesBinary(const std::string& path)
"""
images = {}
with open(path_to_model_file, "rb") as fid:
num_reg_images = read_next_bytes(fid, 8, "Q")[0]
for _ in range(num_reg_images):
binary_image_properties = read_next_bytes(
fid, num_bytes=64, format_char_sequence="idddddddi")
image_id = binary_image_properties[0]
qvec = np.array(binary_image_properties[1:5])
tvec = np.array(binary_image_properties[5:8])
camera_id = binary_image_properties[8]
image_name = ""
current_char = read_next_bytes(fid, 1, "c")[0]
while current_char != b"\x00": # look for the ASCII 0 entry
image_name += current_char.decode("utf-8")
current_char = read_next_bytes(fid, 1, "c")[0]
num_points2D = read_next_bytes(fid, num_bytes=8,
format_char_sequence="Q")[0]
x_y_id_s = read_next_bytes(fid, num_bytes=24*num_points2D,
format_char_sequence="ddq"*num_points2D)
xys = np.column_stack([tuple(map(float, x_y_id_s[0::3])),
tuple(map(float, x_y_id_s[1::3]))])
point3D_ids = np.array(tuple(map(int, x_y_id_s[2::3])))
images[image_id] = Image(
id=image_id, qvec=qvec, tvec=tvec,
camera_id=camera_id, name=image_name,
xys=xys, point3D_ids=point3D_ids)
return images
def read_intrinsics_binary(path_to_model_file):
"""
see: src/base/reconstruction.cc
void Reconstruction::WriteCamerasBinary(const std::string& path)
void Reconstruction::ReadCamerasBinary(const std::string& path)
"""
cameras = {}
with open(path_to_model_file, "rb") as fid:
num_cameras = read_next_bytes(fid, 8, "Q")[0]
for _ in range(num_cameras):
camera_properties = read_next_bytes(
fid, num_bytes=24, format_char_sequence="iiQQ")
camera_id = camera_properties[0]
model_id = camera_properties[1]
model_name = CAMERA_MODEL_IDS[camera_properties[1]].model_name
width = camera_properties[2]
height = camera_properties[3]
num_params = CAMERA_MODEL_IDS[model_id].num_params
params = read_next_bytes(fid, num_bytes=8*num_params,
format_char_sequence="d"*num_params)
cameras[camera_id] = Camera(id=camera_id,
model=model_name,
width=width,
height=height,
params=np.array(params))
assert len(cameras) == num_cameras
return cameras
def read_extrinsics_text(path):
"""
Taken from https://github.com/colmap/colmap/blob/dev/scripts/python/read_write_model.py
"""
images = {}
with open(path, "r") as fid:
while True:
line = fid.readline()
if not line:
break
line = line.strip()
if len(line) > 0 and line[0] != "#":
elems = line.split()
image_id = int(elems[0])
qvec = np.array(tuple(map(float, elems[1:5])))
tvec = np.array(tuple(map(float, elems[5:8])))
camera_id = int(elems[8])
image_name = elems[9]
elems = fid.readline().split()
xys = np.column_stack([tuple(map(float, elems[0::3])),
tuple(map(float, elems[1::3]))])
point3D_ids = np.array(tuple(map(int, elems[2::3])))
images[image_id] = Image(
id=image_id, qvec=qvec, tvec=tvec,
camera_id=camera_id, name=image_name,
xys=xys, point3D_ids=point3D_ids)
return images
def read_colmap_bin_array(path):
"""
Taken from https://github.com/colmap/colmap/blob/dev/scripts/python/read_dense.py
:param path: path to the colmap binary file.
:return: nd array with the floating point values in the value
"""
with open(path, "rb") as fid:
width, height, channels = np.genfromtxt(fid, delimiter="&", max_rows=1,
usecols=(0, 1, 2), dtype=int)
fid.seek(0)
num_delimiter = 0
byte = fid.read(1)
while True:
if byte == b"&":
num_delimiter += 1
if num_delimiter >= 3:
break
byte = fid.read(1)
array = np.fromfile(fid, np.float32)
array = array.reshape((width, height, channels), order="F")
return np.transpose(array, (1, 0, 2)).squeeze()
================================================
FILE: scene/dataset_readers.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import os
import sys
from PIL import Image
from typing import NamedTuple
from scene.colmap_loader import read_extrinsics_text, read_intrinsics_text, qvec2rotmat, \
read_extrinsics_binary, read_intrinsics_binary, read_points3D_binary, read_points3D_text
from utils.graphics_utils import getWorld2View2, focal2fov, fov2focal
import numpy as np
import json
from pathlib import Path
from plyfile import PlyData, PlyElement
from utils.sh_utils import SH2RGB
from scene.gaussian_model import BasicPointCloud
class CameraInfo(NamedTuple):
uid: int
R: np.array
T: np.array
FovY: np.array
FovX: np.array
image: np.array
image_path: str
image_name: str
width: int
height: int
class SceneInfo(NamedTuple):
point_cloud: BasicPointCloud
train_cameras: list
test_cameras: list
nerf_normalization: dict
ply_path: str
def getNerfppNorm(cam_info):
def get_center_and_diag(cam_centers):
cam_centers = np.hstack(cam_centers)
avg_cam_center = np.mean(cam_centers, axis=1, keepdims=True)
center = avg_cam_center
dist = np.linalg.norm(cam_centers - center, axis=0, keepdims=True)
diagonal = np.max(dist)
return center.flatten(), diagonal
cam_centers = []
for cam in cam_info:
W2C = getWorld2View2(cam.R, cam.T)
C2W = np.linalg.inv(W2C)
cam_centers.append(C2W[:3, 3:4])
center, diagonal = get_center_and_diag(cam_centers)
radius = diagonal * 1.1
translate = -center
return {"translate": translate, "radius": radius}
def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder):
cam_infos = []
for idx, key in enumerate(cam_extrinsics):
sys.stdout.write('\r')
# the exact output you're looking for:
sys.stdout.write("Reading camera {}/{}".format(idx+1, len(cam_extrinsics)))
sys.stdout.flush()
extr = cam_extrinsics[key]
intr = cam_intrinsics[extr.camera_id]
height = intr.height
width = intr.width
uid = intr.id
R = np.transpose(qvec2rotmat(extr.qvec))
T = np.array(extr.tvec)
if intr.model == "SIMPLE_PINHOLE" or intr.model == "SIMPLE_RADIAL":
if intr.model == "SIMPLE_RADIAL":
print("Warning: Camera model SIMPLE_RADIA is simplified to SIMPLE_PINHOLE.")
focal_length_x = intr.params[0]
FovY = focal2fov(focal_length_x, height)
FovX = focal2fov(focal_length_x, width)
elif intr.model == "PINHOLE":
focal_length_x = intr.params[0]
focal_length_y = intr.params[1]
FovY = focal2fov(focal_length_y, height)
FovX = focal2fov(focal_length_x, width)
else:
assert False, "Colmap camera model not handled: only undistorted datasets (PINHOLE or SIMPLE_PINHOLE cameras) supported!"
image_path = os.path.join(images_folder, os.path.basename(extr.name))
image_name = os.path.basename(image_path).split(".")[0]
image = None
cam_info = CameraInfo(uid=uid, R=R, T=T, FovY=FovY, FovX=FovX, image=image,
image_path=image_path, image_name=image_name, width=width, height=height)
cam_infos.append(cam_info)
sys.stdout.write('\n')
return cam_infos
def fetchPly(path):
plydata = PlyData.read(path)
vertices = plydata['vertex']
positions = np.vstack([vertices['x'], vertices['y'], vertices['z']]).T
colors = np.vstack([vertices['red'], vertices['green'], vertices['blue']]).T / 255.0
normals = np.vstack([vertices['nx'], vertices['ny'], vertices['nz']]).T
return BasicPointCloud(points=positions, colors=colors, normals=normals)
def storePly(path, xyz, rgb):
# Define the dtype for the structured array
dtype = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')]
normals = np.zeros_like(xyz)
elements = np.empty(xyz.shape[0], dtype=dtype)
attributes = np.concatenate((xyz, normals, rgb), axis=1)
elements[:] = list(map(tuple, attributes))
# Create the PlyData object and write to file
vertex_element = PlyElement.describe(elements, 'vertex')
ply_data = PlyData([vertex_element])
ply_data.write(path)
def readColmapSceneInfo(path, images, eval, llffhold=8):
try:
cameras_extrinsic_file = os.path.join(path, "sparse/0", "images.bin")
cameras_intrinsic_file = os.path.join(path, "sparse/0", "cameras.bin")
cam_extrinsics = read_extrinsics_binary(cameras_extrinsic_file)
cam_intrinsics = read_intrinsics_binary(cameras_intrinsic_file)
except:
cameras_extrinsic_file = os.path.join(path, "sparse/0", "images.txt")
cameras_intrinsic_file = os.path.join(path, "sparse/0", "cameras.txt")
cam_extrinsics = read_extrinsics_text(cameras_extrinsic_file)
cam_intrinsics = read_intrinsics_text(cameras_intrinsic_file)
reading_dir = "images" if images == None else images
cam_infos_unsorted = readColmapCameras(cam_extrinsics=cam_extrinsics, cam_intrinsics=cam_intrinsics, images_folder=os.path.join(path, reading_dir))
cam_infos = sorted(cam_infos_unsorted.copy(), key = lambda x : x.image_name)
if eval:
train_cam_infos = [c for idx, c in enumerate(cam_infos) if idx % llffhold != 0]
test_cam_infos = [c for idx, c in enumerate(cam_infos) if idx % llffhold == 0]
else:
train_cam_infos = cam_infos
test_cam_infos = []
nerf_normalization = getNerfppNorm(train_cam_infos)
ply_path = os.path.join(path, "sparse/0/points3D.ply")
bin_path = os.path.join(path, "sparse/0/points3D.bin")
txt_path = os.path.join(path, "sparse/0/points3D.txt")
if not os.path.exists(ply_path):
print("Converting point3d.bin to .ply, will happen only the first time you open the scene.")
try:
xyz, rgb, _ = read_points3D_binary(bin_path, max_err=2, min_track_length=3)
# xyz, rgb, _ = read_points3D_binary_3DGS(bin_path)
except:
xyz, rgb, _ = read_points3D_text(txt_path, max_err=2, min_track_length=3)
# xyz, rgb, _ = read_points3D_text_3DGS(bin_path)
storePly(ply_path, xyz, rgb)
try:
pcd = fetchPly(ply_path)
except:
pcd = None
scene_info = SceneInfo(point_cloud=pcd,
train_cameras=train_cam_infos,
test_cameras=test_cam_infos,
nerf_normalization=nerf_normalization,
ply_path=ply_path)
return scene_info
def readCamerasFromTransforms(path, transformsfile, white_background, extension=".png"):
cam_infos = []
with open(os.path.join(path, transformsfile)) as json_file:
contents = json.load(json_file)
fovx = contents["camera_angle_x"]
frames = contents["frames"]
for idx, frame in enumerate(frames):
cam_name = os.path.join(path, frame["file_path"] + extension)
# NeRF 'transform_matrix' is a camera-to-world transform
c2w = np.array(frame["transform_matrix"])
# change from OpenGL/Blender camera axes (Y up, Z back) to COLMAP (Y down, Z forward)
c2w[:3, 1:3] *= -1
# get the world-to-camera transform and set R, T
w2c = np.linalg.inv(c2w)
R = np.transpose(w2c[:3,:3]) # R is stored transposed due to 'glm' in CUDA code
T = w2c[:3, 3]
image_path = os.path.join(path, cam_name)
image_name = Path(cam_name).stem
image = Image.open(image_path)
im_data = np.array(image.convert("RGBA"))
bg = np.array([1,1,1]) if white_background else np.array([0, 0, 0])
norm_data = im_data / 255.0
arr = norm_data[:,:,:3] * norm_data[:, :, 3:4] + bg * (1 - norm_data[:, :, 3:4])
image = Image.fromarray(np.array(arr*255.0, dtype=np.byte), "RGB")
fovy = focal2fov(fov2focal(fovx, image.size[0]), image.size[1])
FovY = fovy
FovX = fovx
cam_infos.append(CameraInfo(uid=idx, R=R, T=T, FovY=FovY, FovX=FovX, image=image,
image_path=image_path, image_name=image_name, width=image.size[0], height=image.size[1]))
return cam_infos
def readNerfSyntheticInfo(path, white_background, eval, extension=".png"):
print("Reading Training Transforms")
train_cam_infos = readCamerasFromTransforms(path, "transforms_train.json", white_background, extension)
print("Reading Test Transforms")
test_cam_infos = readCamerasFromTransforms(path, "transforms_test.json", white_background, extension)
if not eval:
train_cam_infos.extend(test_cam_infos)
test_cam_infos = []
nerf_normalization = getNerfppNorm(train_cam_infos)
ply_path = os.path.join(path, "points3d.ply")
if not os.path.exists(ply_path):
# Since this data set has no colmap data, we start with random points
num_pts = 100_000
print(f"Generating random point cloud ({num_pts})...")
# We create random points inside the bounds of the synthetic Blender scenes
xyz = np.random.random((num_pts, 3)) * 2.6 - 1.3
shs = np.random.random((num_pts, 3)) / 255.0
pcd = BasicPointCloud(points=xyz, colors=SH2RGB(shs), normals=np.zeros((num_pts, 3)))
storePly(ply_path, xyz, SH2RGB(shs) * 255)
try:
pcd = fetchPly(ply_path)
except:
pcd = None
scene_info = SceneInfo(point_cloud=pcd,
train_cameras=train_cam_infos,
test_cameras=test_cam_infos,
nerf_normalization=nerf_normalization,
ply_path=ply_path)
return scene_info
sceneLoadTypeCallbacks = {
"Colmap": readColmapSceneInfo,
"Blender": readNerfSyntheticInfo
}
================================================
FILE: scene/gaussian_model.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
import torch
import numpy as np
from utils.general_utils import inverse_sigmoid, get_expon_lr_func, build_rotation
from torch import nn
import os
from utils.system_utils import mkdir_p
from plyfile import PlyData, PlyElement
from utils.sh_utils import RGB2SH
from simple_knn._C import distCUDA2
from utils.graphics_utils import BasicPointCloud
from utils.general_utils import strip_symmetric, build_scaling_rotation
class GaussianModel:
def setup_functions(self):
def build_covariance_from_scaling_rotation(scaling, scaling_modifier, rotation):
L = build_scaling_rotation(scaling_modifier * scaling, rotation)
actual_covariance = L @ L.transpose(1, 2)
symm = strip_symmetric(actual_covariance)
return symm
self.scaling_activation = torch.exp
self.scaling_inverse_activation = torch.log
self.covariance_activation = build_covariance_from_scaling_rotation
self.opacity_activation = torch.sigmoid
self.inverse_opacity_activation = inverse_sigmoid
self.rotation_activation = torch.nn.functional.normalize
def __init__(self, sh_degree : int):
self.active_sh_degree = 0
self.max_sh_degree = sh_degree
self._xyz = torch.empty(0)
self._features_dc = torch.empty(0)
self._features_rest = torch.empty(0)
self._scaling = torch.empty(0)
self._rotation = torch.empty(0)
self._opacity = torch.empty(0)
self.max_radii2D = torch.empty(0)
self.max_weight = torch.empty(0)
self.xyz_gradient_accum = torch.empty(0)
self.xyz_gradient_accum_abs = torch.empty(0)
self.denom = torch.empty(0)
self.optimizer = None
self.percent_dense = 0
self.spatial_lr_scale = 0
self.setup_functions()
def capture(self):
return (
self.active_sh_degree,
self._xyz,
self._features_dc,
self._features_rest,
self._scaling,
self._rotation,
self._opacity,
self.max_radii2D,
self.max_weight,
self.xyz_gradient_accum,
self.xyz_gradient_accum_abs,
self.denom,
self.optimizer.state_dict(),
self.spatial_lr_scale,
)
def restore(self, model_args, training_args):
(self.active_sh_degree,
self._xyz,
self._features_dc,
self._features_rest,
self._scaling,
self._rotation,
self._opacity,
self.max_radii2D,
self.max_weight,
xyz_gradient_accum,
xyz_gradient_accum_abs,
denom,
opt_dict,
self.spatial_lr_scale) = model_args
self.training_setup(training_args)
self.xyz_gradient_accum = xyz_gradient_accum
self.xyz_gradient_accum_abs = xyz_gradient_accum_abs
self.denom = denom
self.optimizer.load_state_dict(opt_dict)
def capture_for_3DGS(self):
return (
self.active_sh_degree,
self._xyz,
self._features_dc,
self._features_rest,
self._scaling,
self._rotation,
self._opacity,
self.max_radii2D,
self.xyz_gradient_accum,
self.denom,
self.optimizer.state_dict(),
self.spatial_lr_scale,
)
def restore_from_3DGS(self, model_args, training_args):
(self.active_sh_degree,
self._xyz,
self._features_dc,
self._features_rest,
self._scaling,
self._rotation,
self._opacity,
self.max_radii2D,
xyz_gradient_accum,
denom,
opt_dict,
self.spatial_lr_scale) = model_args
self.training_setup(training_args)
self.xyz_gradient_accum = xyz_gradient_accum
self.xyz_gradient_accum_abs = torch.zeros((self.xyz_gradient_accum.shape[0],2),device="cuda")
self.max_weight = torch.zeros_like(self.max_radii2D)
self.denom = denom
self.optimizer.load_state_dict(opt_dict)
@property
def get_scaling(self):
return self.scaling_activation(self._scaling)
@property
def get_rotation(self):
return self.rotation_activation(self._rotation)
@property
def get_xyz(self):
return self._xyz
@property
def get_features(self):
features_dc = self._features_dc
features_rest = self._features_rest
return torch.cat((features_dc, features_rest), dim=1)
@property
def get_opacity(self):
return self.opacity_activation(self._opacity)
def get_covariance(self, scaling_modifier = 1):
return self.covariance_activation(self.get_scaling, scaling_modifier, self._rotation)
def oneupSHdegree(self):
if self.active_sh_degree < self.max_sh_degree:
self.active_sh_degree += 1
def create_from_pcd(self, pcd : BasicPointCloud, spatial_lr_scale : float):
self.spatial_lr_scale = spatial_lr_scale
fused_point_cloud = torch.tensor(np.asarray(pcd.points)).float().cuda()
fused_color = RGB2SH(torch.tensor(np.asarray(pcd.colors)).float().cuda())
features = torch.zeros((fused_color.shape[0], 3, (self.max_sh_degree + 1) ** 2)).float().cuda()
features[:, :3, 0 ] = fused_color
features[:, 3:, 1:] = 0.0
print("Number of points at initialisation : ", fused_point_cloud.shape[0])
dist2 = torch.clamp_min(distCUDA2(torch.from_numpy(np.asarray(pcd.points)).float().cuda()), 0.0000001)
scales = torch.log(torch.sqrt(dist2))[...,None].repeat(1, 3)
rots = torch.zeros((fused_point_cloud.shape[0], 4), device="cuda")
rots[:, 0] = 1
opacities = inverse_sigmoid(0.1 * torch.ones((fused_point_cloud.shape[0], 1), dtype=torch.float, device="cuda"))
self._xyz = nn.Parameter(fused_point_cloud.requires_grad_(True))
self._features_dc = nn.Parameter(features[:,:,0:1].transpose(1, 2).contiguous().requires_grad_(True))
self._features_rest = nn.Parameter(features[:,:,1:].transpose(1, 2).contiguous().requires_grad_(True))
self._scaling = nn.Parameter(scales.requires_grad_(True))
self._rotation = nn.Parameter(rots.requires_grad_(True))
self._opacity = nn.Parameter(opacities.requires_grad_(True))
self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
self.max_weight = torch.zeros((self.get_xyz.shape[0]), device="cuda")
def training_setup(self, training_args):
self.percent_dense = training_args.percent_dense
self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.xyz_gradient_accum_abs = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
l = [
{'params': [self._xyz], 'lr': training_args.position_lr_init * self.spatial_lr_scale, "name": "xyz"},
{'params': [self._features_dc], 'lr': training_args.feature_lr, "name": "f_dc"},
{'params': [self._features_rest], 'lr': training_args.feature_lr / 20.0, "name": "f_rest"},
{'params': [self._opacity], 'lr': training_args.opacity_lr, "name": "opacity"},
{'params': [self._scaling], 'lr': training_args.scaling_lr, "name": "scaling"},
{'params': [self._rotation], 'lr': training_args.rotation_lr, "name": "rotation"}
]
self.optimizer = torch.optim.Adam(l, lr=0.0, eps=1e-15)
self.xyz_scheduler_args = get_expon_lr_func(lr_init=training_args.position_lr_init*self.spatial_lr_scale,
lr_final=training_args.position_lr_final*self.spatial_lr_scale,
lr_delay_mult=training_args.position_lr_delay_mult,
max_steps=training_args.position_lr_max_steps)
def update_learning_rate(self, iteration):
''' Learning rate scheduling per step '''
for param_group in self.optimizer.param_groups:
if param_group["name"] == "xyz":
lr = self.xyz_scheduler_args(iteration)
param_group['lr'] = lr
return lr
def construct_list_of_attributes(self):
l = ['x', 'y', 'z', 'nx', 'ny', 'nz']
# All channels except the 3 DC
for i in range(self._features_dc.shape[1]*self._features_dc.shape[2]):
l.append('f_dc_{}'.format(i))
for i in range(self._features_rest.shape[1]*self._features_rest.shape[2]):
l.append('f_rest_{}'.format(i))
l.append('opacity')
for i in range(self._scaling.shape[1]):
l.append('scale_{}'.format(i))
for i in range(self._rotation.shape[1]):
l.append('rot_{}'.format(i))
return l
def save_ply(self, path):
mkdir_p(os.path.dirname(path))
xyz = self._xyz.detach().cpu().numpy()
normals = np.zeros_like(xyz)
f_dc = self._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
f_rest = self._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
opacities = self._opacity.detach().cpu().numpy()
scale = self._scaling.detach().cpu().numpy()
rotation = self._rotation.detach().cpu().numpy()
dtype_full = [(attribute, 'f4') for attribute in self.construct_list_of_attributes()]
elements = np.empty(xyz.shape[0], dtype=dtype_full)
attributes = np.concatenate((xyz, normals, f_dc, f_rest, opacities, scale, rotation), axis=1)
elements[:] = list(map(tuple, attributes))
el = PlyElement.describe(elements, 'vertex')
PlyData([el]).write(path)
def reset_opacity(self):
opacities_new = inverse_sigmoid(torch.min(self.get_opacity, torch.ones_like(self.get_opacity)*0.01))
optimizable_tensors = self.replace_tensor_to_optimizer(opacities_new, "opacity")
self._opacity = optimizable_tensors["opacity"]
def reduce_opacity(self):
opacities_new = inverse_sigmoid(torch.min(self.get_opacity, torch.ones_like(self.get_opacity)*0.8))
optimizable_tensors = self.replace_tensor_to_optimizer(opacities_new, "opacity")
self._opacity = optimizable_tensors["opacity"]
def load_ply(self, path):
plydata = PlyData.read(path)
xyz = np.stack((np.asarray(plydata.elements[0]["x"]),
np.asarray(plydata.elements[0]["y"]),
np.asarray(plydata.elements[0]["z"])), axis=1)
opacities = np.asarray(plydata.elements[0]["opacity"])[..., np.newaxis]
features_dc = np.zeros((xyz.shape[0], 3, 1))
features_dc[:, 0, 0] = np.asarray(plydata.elements[0]["f_dc_0"])
features_dc[:, 1, 0] = np.asarray(plydata.elements[0]["f_dc_1"])
features_dc[:, 2, 0] = np.asarray(plydata.elements[0]["f_dc_2"])
extra_f_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("f_rest_")]
extra_f_names = sorted(extra_f_names, key = lambda x: int(x.split('_')[-1]))
assert len(extra_f_names)==3*(self.max_sh_degree + 1) ** 2 - 3
features_extra = np.zeros((xyz.shape[0], len(extra_f_names)))
for idx, attr_name in enumerate(extra_f_names):
features_extra[:, idx] = np.asarray(plydata.elements[0][attr_name])
# Reshape (P,F*SH_coeffs) to (P, F, SH_coeffs except DC)
features_extra = features_extra.reshape((features_extra.shape[0], 3, (self.max_sh_degree + 1) ** 2 - 1))
scale_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("scale_")]
scale_names = sorted(scale_names, key = lambda x: int(x.split('_')[-1]))
scales = np.zeros((xyz.shape[0], len(scale_names)))
for idx, attr_name in enumerate(scale_names):
scales[:, idx] = np.asarray(plydata.elements[0][attr_name])
rot_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("rot")]
rot_names = sorted(rot_names, key = lambda x: int(x.split('_')[-1]))
rots = np.zeros((xyz.shape[0], len(rot_names)))
for idx, attr_name in enumerate(rot_names):
rots[:, idx] = np.asarray(plydata.elements[0][attr_name])
self._xyz = nn.Parameter(torch.tensor(xyz, dtype=torch.float, device="cuda").requires_grad_(True))
self._features_dc = nn.Parameter(torch.tensor(features_dc, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True))
self._features_rest = nn.Parameter(torch.tensor(features_extra, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True))
self._opacity = nn.Parameter(torch.tensor(opacities, dtype=torch.float, device="cuda").requires_grad_(True))
self._scaling = nn.Parameter(torch.tensor(scales, dtype=torch.float, device="cuda").requires_grad_(True))
self._rotation = nn.Parameter(torch.tensor(rots, dtype=torch.float, device="cuda").requires_grad_(True))
self.active_sh_degree = self.max_sh_degree
def replace_tensor_to_optimizer(self, tensor, name):
optimizable_tensors = {}
for group in self.optimizer.param_groups:
if group["name"] == name:
stored_state = self.optimizer.state.get(group['params'][0], None)
stored_state["exp_avg"] = torch.zeros_like(tensor)
stored_state["exp_avg_sq"] = torch.zeros_like(tensor)
del self.optimizer.state[group['params'][0]]
group["params"][0] = nn.Parameter(tensor.requires_grad_(True))
self.optimizer.state[group['params'][0]] = stored_state
optimizable_tensors[group["name"]] = group["params"][0]
return optimizable_tensors
def _prune_optimizer(self, mask):
optimizable_tensors = {}
for group in self.optimizer.param_groups:
stored_state = self.optimizer.state.get(group['params'][0], None)
if stored_state is not None:
stored_state["exp_avg"] = stored_state["exp_avg"][mask]
stored_state["exp_avg_sq"] = stored_state["exp_avg_sq"][mask]
del self.optimizer.state[group['params'][0]]
group["params"][0] = nn.Parameter((group["params"][0][mask].requires_grad_(True)))
self.optimizer.state[group['params'][0]] = stored_state
optimizable_tensors[group["name"]] = group["params"][0]
else:
group["params"][0] = nn.Parameter(group["params"][0][mask].requires_grad_(True))
optimizable_tensors[group["name"]] = group["params"][0]
return optimizable_tensors
def prune_points(self, mask):
valid_points_mask = ~mask
optimizable_tensors = self._prune_optimizer(valid_points_mask)
self._xyz = optimizable_tensors["xyz"]
self._features_dc = optimizable_tensors["f_dc"]
self._features_rest = optimizable_tensors["f_rest"]
self._opacity = optimizable_tensors["opacity"]
self._scaling = optimizable_tensors["scaling"]
self._rotation = optimizable_tensors["rotation"]
self.xyz_gradient_accum = self.xyz_gradient_accum[valid_points_mask]
self.xyz_gradient_accum_abs = self.xyz_gradient_accum_abs[valid_points_mask]
self.denom = self.denom[valid_points_mask]
self.max_radii2D = self.max_radii2D[valid_points_mask]
self.max_weight = self.max_weight[valid_points_mask]
def initial_prune(self):
pts_mask_1 = torch.max(self.get_scaling, dim=1).values > torch.mean(self.get_scaling)
if len(self.get_scaling) < 500_0000:
pts_mask_2 = torch.max(self.get_scaling, dim=1).values > torch.quantile(
self.get_scaling,
0.999)
else:
pts_mask_2 = torch.max(self.get_scaling, dim=1).values > torch.mean(
self.get_scaling) * 4
selected_pts_mask = torch.logical_and(pts_mask_1, pts_mask_2)
print("Initial pruning based on radius, GS num: ", sum(selected_pts_mask))
self.prune_points(selected_pts_mask)
def cat_tensors_to_optimizer(self, tensors_dict):
optimizable_tensors = {}
for group in self.optimizer.param_groups:
assert len(group["params"]) == 1
extension_tensor = tensors_dict[group["name"]]
stored_state = self.optimizer.state.get(group['params'][0], None)
if stored_state is not None:
stored_state["exp_avg"] = torch.cat((stored_state["exp_avg"], torch.zeros_like(extension_tensor)), dim=0)
stored_state["exp_avg_sq"] = torch.cat((stored_state["exp_avg_sq"], torch.zeros_like(extension_tensor)), dim=0)
del self.optimizer.state[group['params'][0]]
group["params"][0] = nn.Parameter(torch.cat((group["params"][0], extension_tensor), dim=0).requires_grad_(True))
self.optimizer.state[group['params'][0]] = stored_state
optimizable_tensors[group["name"]] = group["params"][0]
else:
group["params"][0] = nn.Parameter(torch.cat((group["params"][0], extension_tensor), dim=0).requires_grad_(True))
optimizable_tensors[group["name"]] = group["params"][0]
return optimizable_tensors
def densification_postfix(self, new_xyz, new_features_dc, new_features_rest, new_opacities, new_scaling, new_rotation):
d = {"xyz": new_xyz,
"f_dc": new_features_dc,
"f_rest": new_features_rest,
"opacity": new_opacities,
"scaling" : new_scaling,
"rotation" : new_rotation}
optimizable_tensors = self.cat_tensors_to_optimizer(d)
self._xyz = optimizable_tensors["xyz"]
self._features_dc = optimizable_tensors["f_dc"]
self._features_rest = optimizable_tensors["f_rest"]
self._opacity = optimizable_tensors["opacity"]
self._scaling = optimizable_tensors["scaling"]
self._rotation = optimizable_tensors["rotation"]
self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.xyz_gradient_accum_abs = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda")
self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
max_weight = torch.zeros((new_xyz.shape[0]), device="cuda")
self.max_weight = torch.cat((self.max_weight,max_weight),dim=0)
def densify_and_split(self, grads, grad_threshold, scene_extent, N=2):
n_init_points = self.get_xyz.shape[0]
# Extract points that satisfy the gradient condition
padded_grad = torch.zeros((n_init_points), device="cuda")
padded_grad[:grads.shape[0]] = grads.squeeze()
selected_pts_mask = torch.where(padded_grad >= grad_threshold, True, False)
selected_pts_mask = torch.logical_and(selected_pts_mask,
torch.max(self.get_scaling, dim=1).values > self.percent_dense*scene_extent)
stds = self.get_scaling[selected_pts_mask].repeat(N,1)
means =torch.zeros((stds.size(0), 3),device="cuda")
samples = torch.normal(mean=means, std=stds)
rots = build_rotation(self._rotation[selected_pts_mask]).repeat(N,1,1)
new_xyz = torch.bmm(rots, samples.unsqueeze(-1)).squeeze(-1) + self.get_xyz[selected_pts_mask].repeat(N, 1)
new_scaling = self.scaling_inverse_activation(self.get_scaling[selected_pts_mask].repeat(N,1) / (0.8*N))
new_rotation = self._rotation[selected_pts_mask].repeat(N,1)
new_features_dc = self._features_dc[selected_pts_mask].repeat(N,1,1)
new_features_rest = self._features_rest[selected_pts_mask].repeat(N,1,1)
new_opacity = self._opacity[selected_pts_mask].repeat(N,1)
# print("split:", new_xyz.shape[0])
self.densification_postfix(new_xyz, new_features_dc, new_features_rest, new_opacity, new_scaling, new_rotation)
prune_filter = torch.cat((selected_pts_mask, torch.zeros(N * selected_pts_mask.sum(), device="cuda", dtype=bool)))
self.prune_points(prune_filter)
def densify_and_clone(self, grads, grad_threshold, scene_extent):
# Extract points that satisfy the gradient condition
selected_pts_mask = torch.where(torch.norm(grads, dim=-1) >= grad_threshold, True, False)
selected_pts_mask = torch.logical_and(selected_pts_mask,
torch.max(self.get_scaling, dim=1).values <= self.percent_dense*scene_extent)
new_xyz = self._xyz[selected_pts_mask]
new_features_dc = self._features_dc[selected_pts_mask]
new_features_rest = self._features_rest[selected_pts_mask]
new_opacities = self._opacity[selected_pts_mask]
new_scaling = self._scaling[selected_pts_mask]
new_rotation = self._rotation[selected_pts_mask]
# print("clone:", new_xyz.shape[0])
self.densification_postfix(new_xyz, new_features_dc, new_features_rest, new_opacities, new_scaling, new_rotation)
def densify_and_prune(self, max_grad, max_grad_abs, min_opacity, extent, max_screen_size):
grads = self.xyz_gradient_accum / self.denom
grads[grads.isnan()] = 0.0
grads_abs = self.xyz_gradient_accum_abs / self.denom
grads_abs[grads_abs.isnan()] = 0.0
self.densify_and_clone(grads, max_grad, extent)
self.densify_and_split(grads_abs, max_grad_abs, extent)
prune_mask = (self.get_opacity < min_opacity).squeeze()
if max_screen_size:
big_points_vs = self.max_radii2D > max_screen_size
big_points_ws = self.get_scaling.max(dim=1).values > 0.1 * extent
prune_mask = torch.logical_or(torch.logical_or(prune_mask, big_points_vs), big_points_ws)
self.prune_points(prune_mask)
torch.cuda.empty_cache()
def add_densification_stats(self, viewspace_point_tensor, update_filter):
self.xyz_gradient_accum[update_filter] += torch.norm(viewspace_point_tensor.grad[update_filter,:2], dim=-1, keepdim=True)
self.xyz_gradient_accum_abs[update_filter] += torch.norm(viewspace_point_tensor.grad[update_filter, 2:], dim=-1,
keepdim=True)
self.denom[update_filter] += 1
================================================
FILE: submodules/diff-gaussian-rasterization-abs/.gitignore
================================================
build/
diff_gaussian_rasterization_abs.egg-info/
dist/
cmake-build-debug/
================================================
FILE: submodules/diff-gaussian-rasterization-abs/.gitmodules
================================================
[submodule "third_party/glm"]
path = third_party/glm
url = https://github.com/g-truc/glm.git
================================================
FILE: submodules/diff-gaussian-rasterization-abs/CMakeLists.txt
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
cmake_minimum_required(VERSION 3.20)
project(DiffRast LANGUAGES CUDA CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CUDA_STANDARD 17)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
add_library(CudaRasterizer
cuda_rasterizer/backward.h
cuda_rasterizer/backward.cu
cuda_rasterizer/forward.h
cuda_rasterizer/forward.cu
cuda_rasterizer/auxiliary.h
cuda_rasterizer/rasterizer_impl.cu
cuda_rasterizer/rasterizer_impl.h
cuda_rasterizer/rasterizer.h
)
set_target_properties(CudaRasterizer PROPERTIES CUDA_ARCHITECTURES "70;75;86")
target_include_directories(CudaRasterizer PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/cuda_rasterizer)
target_include_directories(CudaRasterizer PRIVATE third_party/glm ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
================================================
FILE: submodules/diff-gaussian-rasterization-abs/LICENSE.md
================================================
Gaussian-Splatting License
===========================
**Inria** and **the Max Planck Institut for Informatik (MPII)** hold all the ownership rights on the *Software* named **gaussian-splatting**.
The *Software* is in the process of being registered with the Agence pour la Protection des
Programmes (APP).
The *Software* is still being developed by the *Licensor*.
*Licensor*'s goal is to allow the research community to use, test and evaluate
the *Software*.
## 1. Definitions
*Licensee* means any person or entity that uses the *Software* and distributes
its *Work*.
*Licensor* means the owners of the *Software*, i.e Inria and MPII
*Software* means the original work of authorship made available under this
License ie gaussian-splatting.
*Work* means the *Software* and any additions to or derivative works of the
*Software* that are made available under this License.
## 2. Purpose
This license is intended to define the rights granted to the *Licensee* by
Licensors under the *Software*.
## 3. Rights granted
For the above reasons Licensors have decided to distribute the *Software*.
Licensors grant non-exclusive rights to use the *Software* for research purposes
to research users (both academic and industrial), free of charge, without right
to sublicense.. The *Software* may be used "non-commercially", i.e., for research
and/or evaluation purposes only.
Subject to the terms and conditions of this License, you are granted a
non-exclusive, royalty-free, license to reproduce, prepare derivative works of,
publicly display, publicly perform and distribute its *Work* and any resulting
derivative works in any form.
## 4. Limitations
**4.1 Redistribution.** You may reproduce or distribute the *Work* only if (a) you do
so under this License, (b) you include a complete copy of this License with
your distribution, and (c) you retain without modification any copyright,
patent, trademark, or attribution notices that are present in the *Work*.
**4.2 Derivative Works.** You may specify that additional or different terms apply
to the use, reproduction, and distribution of your derivative works of the *Work*
("Your Terms") only if (a) Your Terms provide that the use limitation in
Section 2 applies to your derivative works, and (b) you identify the specific
derivative works that are subject to Your Terms. Notwithstanding Your Terms,
this License (including the redistribution requirements in Section 3.1) will
continue to apply to the *Work* itself.
**4.3** Any other use without of prior consent of Licensors is prohibited. Research
users explicitly acknowledge having received from Licensors all information
allowing to appreciate the adequacy between of the *Software* and their needs and
to undertake all necessary precautions for its execution and use.
**4.4** The *Software* is provided both as a compiled library file and as source
code. In case of using the *Software* for a publication or other results obtained
through the use of the *Software*, users are strongly encouraged to cite the
corresponding publications as explained in the documentation of the *Software*.
## 5. Disclaimer
THE USER CANNOT USE, EXPLOIT OR DISTRIBUTE THE *SOFTWARE* FOR COMMERCIAL PURPOSES
WITHOUT PRIOR AND EXPLICIT CONSENT OF LICENSORS. YOU MUST CONTACT INRIA FOR ANY
UNAUTHORIZED USE: stip-sophia.transfert@inria.fr . ANY SUCH ACTION WILL
CONSTITUTE A FORGERY. THIS *SOFTWARE* IS PROVIDED "AS IS" WITHOUT ANY WARRANTIES
OF ANY NATURE AND ANY EXPRESS OR IMPLIED WARRANTIES, WITH REGARDS TO COMMERCIAL
USE, PROFESSIONNAL USE, LEGAL OR NOT, OR OTHER, OR COMMERCIALISATION OR
ADAPTATION. UNLESS EXPLICITLY PROVIDED BY LAW, IN NO EVENT, SHALL INRIA OR THE
AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING FROM, OUT OF OR
IN CONNECTION WITH THE *SOFTWARE* OR THE USE OR OTHER DEALINGS IN THE *SOFTWARE*.
================================================
FILE: submodules/diff-gaussian-rasterization-abs/README.md
================================================
# Differential Gaussian Rasterization
Used as the rasterization engine for the paper "AbsGS: Recovering Fine Details for 3D Gaussian Splatting". If you can make use of it in your own research, please be so kind to cite us.
<section class="section" id="BibTeX">
<div class="container is-max-desktop content">
<h2 class="title">BibTeX</h2>
<pre><code>@Article{ye2024absgs,
title={AbsGS: Recovering Fine Details for 3D Gaussian Splatting},
author={Zongxin Ye and Wenyu Li and Sidun Liu and Peng Qiao and Yong Dou},
year={2024},
eprint={2404.10484},
archivePrefix={arXiv},
primaryClass={cs.CV}
}</code></pre>
</div>
</section>
<section class="section" id="BibTeX">
<div class="container is-max-desktop content">
<h2 class="title">BibTeX</h2>
<pre><code>@Article{kerbl3Dgaussians,
author = {Kerbl, Bernhard and Kopanas, Georgios and Leimk{\"u}hler, Thomas and Drettakis, George},
title = {3D Gaussian Splatting for Real-Time Radiance Field Rendering},
journal = {ACM Transactions on Graphics},
number = {4},
volume = {42},
month = {July},
year = {2023},
url = {https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/}
}</code></pre>
</div>
</section>
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/auxiliary.h
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#ifndef CUDA_RASTERIZER_AUXILIARY_H_INCLUDED
#define CUDA_RASTERIZER_AUXILIARY_H_INCLUDED
#include "config.h"
#include "stdio.h"
#define BLOCK_SIZE (BLOCK_X * BLOCK_Y)
#define NUM_WARPS (BLOCK_SIZE/32)
// Spherical harmonics coefficients
__device__ const float SH_C0 = 0.28209479177387814f;
__device__ const float SH_C1 = 0.4886025119029199f;
__device__ const float SH_C2[] = {
1.0925484305920792f,
-1.0925484305920792f,
0.31539156525252005f,
-1.0925484305920792f,
0.5462742152960396f
};
__device__ const float SH_C3[] = {
-0.5900435899266435f,
2.890611442640554f,
-0.4570457994644658f,
0.3731763325901154f,
-0.4570457994644658f,
1.445305721320277f,
-0.5900435899266435f
};
__forceinline__ __device__ float ndc2Pix(float v, int S)
{
return ((v + 1.0) * S - 1.0) * 0.5;
}
__forceinline__ __device__ void getRect(const float2 p, int max_radius, uint2& rect_min, uint2& rect_max, dim3 grid)
{
rect_min = {
min(grid.x, max((int)0, (int)((p.x - max_radius) / BLOCK_X))),
min(grid.y, max((int)0, (int)((p.y - max_radius) / BLOCK_Y)))
};
rect_max = {
min(grid.x, max((int)0, (int)((p.x + max_radius + BLOCK_X - 1) / BLOCK_X))),
min(grid.y, max((int)0, (int)((p.y + max_radius + BLOCK_Y - 1) / BLOCK_Y)))
};
}
__forceinline__ __device__ float3 transformPoint4x3(const float3& p, const float* matrix)
{
float3 transformed = {
matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z + matrix[12],
matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z + matrix[13],
matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z + matrix[14],
};
return transformed;
}
__forceinline__ __device__ float4 transformPoint4x4(const float3& p, const float* matrix)
{
float4 transformed = {
matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z + matrix[12],
matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z + matrix[13],
matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z + matrix[14],
matrix[3] * p.x + matrix[7] * p.y + matrix[11] * p.z + matrix[15]
};
return transformed;
}
__forceinline__ __device__ float3 transformVec4x3(const float3& p, const float* matrix)
{
float3 transformed = {
matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z,
matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z,
matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z,
};
return transformed;
}
__forceinline__ __device__ float3 transformVec4x3Transpose(const float3& p, const float* matrix)
{
float3 transformed = {
matrix[0] * p.x + matrix[1] * p.y + matrix[2] * p.z,
matrix[4] * p.x + matrix[5] * p.y + matrix[6] * p.z,
matrix[8] * p.x + matrix[9] * p.y + matrix[10] * p.z,
};
return transformed;
}
__forceinline__ __device__ float dnormvdz(float3 v, float3 dv)
{
float sum2 = v.x * v.x + v.y * v.y + v.z * v.z;
float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2);
float dnormvdz = (-v.x * v.z * dv.x - v.y * v.z * dv.y + (sum2 - v.z * v.z) * dv.z) * invsum32;
return dnormvdz;
}
__forceinline__ __device__ float3 dnormvdv(float3 v, float3 dv)
{
float sum2 = v.x * v.x + v.y * v.y + v.z * v.z;
float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2);
float3 dnormvdv;
dnormvdv.x = ((+sum2 - v.x * v.x) * dv.x - v.y * v.x * dv.y - v.z * v.x * dv.z) * invsum32;
dnormvdv.y = (-v.x * v.y * dv.x + (sum2 - v.y * v.y) * dv.y - v.z * v.y * dv.z) * invsum32;
dnormvdv.z = (-v.x * v.z * dv.x - v.y * v.z * dv.y + (sum2 - v.z * v.z) * dv.z) * invsum32;
return dnormvdv;
}
__forceinline__ __device__ float4 dnormvdv(float4 v, float4 dv)
{
float sum2 = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2);
float4 vdv = { v.x * dv.x, v.y * dv.y, v.z * dv.z, v.w * dv.w };
float vdv_sum = vdv.x + vdv.y + vdv.z + vdv.w;
float4 dnormvdv;
dnormvdv.x = ((sum2 - v.x * v.x) * dv.x - v.x * (vdv_sum - vdv.x)) * invsum32;
dnormvdv.y = ((sum2 - v.y * v.y) * dv.y - v.y * (vdv_sum - vdv.y)) * invsum32;
dnormvdv.z = ((sum2 - v.z * v.z) * dv.z - v.z * (vdv_sum - vdv.z)) * invsum32;
dnormvdv.w = ((sum2 - v.w * v.w) * dv.w - v.w * (vdv_sum - vdv.w)) * invsum32;
return dnormvdv;
}
__forceinline__ __device__ float sigmoid(float x)
{
return 1.0f / (1.0f + expf(-x));
}
__forceinline__ __device__ bool in_frustum(int idx,
const float* orig_points,
const float* viewmatrix,
const float* projmatrix,
bool prefiltered,
float3& p_view)
{
float3 p_orig = { orig_points[3 * idx], orig_points[3 * idx + 1], orig_points[3 * idx + 2] };
// Bring points to screen space
float4 p_hom = transformPoint4x4(p_orig, projmatrix);
float p_w = 1.0f / (p_hom.w + 0.0000001f);
float3 p_proj = { p_hom.x * p_w, p_hom.y * p_w, p_hom.z * p_w };
p_view = transformPoint4x3(p_orig, viewmatrix);
if (p_view.z <= 0.2f)// || ((p_proj.x < -1.3 || p_proj.x > 1.3 || p_proj.y < -1.3 || p_proj.y > 1.3)))
{
if (prefiltered)
{
printf("Point is filtered although prefiltered is set. This shouldn't happen!");
__trap();
}
return false;
}
return true;
}
#define CHECK_CUDA(A, debug) \
A; if(debug) { \
auto ret = cudaDeviceSynchronize(); \
if (ret != cudaSuccess) { \
std::cerr << "\n[CUDA ERROR] in " << __FILE__ << "\nLine " << __LINE__ << ": " << cudaGetErrorString(ret); \
throw std::runtime_error(cudaGetErrorString(ret)); \
} \
}
#endif
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/backward.cu
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#include "backward.h"
#include "auxiliary.h"
#include <cooperative_groups.h>
#include <cooperative_groups/reduce.h>
namespace cg = cooperative_groups;
// Backward pass for conversion of spherical harmonics to RGB for
// each Gaussian.
__device__ void computeColorFromSH(int idx, int deg, int max_coeffs, const glm::vec3* means, glm::vec3 campos, const float* shs, const bool* clamped, const glm::vec3* dL_dcolor, glm::vec3* dL_dmeans, glm::vec3* dL_dshs)
{
// Compute intermediate values, as it is done during forward
glm::vec3 pos = means[idx];
glm::vec3 dir_orig = pos - campos;
glm::vec3 dir = dir_orig / glm::length(dir_orig);
glm::vec3* sh = ((glm::vec3*)shs) + idx * max_coeffs;
// Use PyTorch rule for clamping: if clamping was applied,
// gradient becomes 0.
glm::vec3 dL_dRGB = dL_dcolor[idx];
dL_dRGB.x *= clamped[3 * idx + 0] ? 0 : 1;
dL_dRGB.y *= clamped[3 * idx + 1] ? 0 : 1;
dL_dRGB.z *= clamped[3 * idx + 2] ? 0 : 1;
glm::vec3 dRGBdx(0, 0, 0);
glm::vec3 dRGBdy(0, 0, 0);
glm::vec3 dRGBdz(0, 0, 0);
float x = dir.x;
float y = dir.y;
float z = dir.z;
// Target location for this Gaussian to write SH gradients to
glm::vec3* dL_dsh = dL_dshs + idx * max_coeffs;
// No tricks here, just high school-level calculus.
float dRGBdsh0 = SH_C0;
dL_dsh[0] = dRGBdsh0 * dL_dRGB;
if (deg > 0)
{
float dRGBdsh1 = -SH_C1 * y;
float dRGBdsh2 = SH_C1 * z;
float dRGBdsh3 = -SH_C1 * x;
dL_dsh[1] = dRGBdsh1 * dL_dRGB;
dL_dsh[2] = dRGBdsh2 * dL_dRGB;
dL_dsh[3] = dRGBdsh3 * dL_dRGB;
dRGBdx = -SH_C1 * sh[3];
dRGBdy = -SH_C1 * sh[1];
dRGBdz = SH_C1 * sh[2];
if (deg > 1)
{
float xx = x * x, yy = y * y, zz = z * z;
float xy = x * y, yz = y * z, xz = x * z;
float dRGBdsh4 = SH_C2[0] * xy;
float dRGBdsh5 = SH_C2[1] * yz;
float dRGBdsh6 = SH_C2[2] * (2.f * zz - xx - yy);
float dRGBdsh7 = SH_C2[3] * xz;
float dRGBdsh8 = SH_C2[4] * (xx - yy);
dL_dsh[4] = dRGBdsh4 * dL_dRGB;
dL_dsh[5] = dRGBdsh5 * dL_dRGB;
dL_dsh[6] = dRGBdsh6 * dL_dRGB;
dL_dsh[7] = dRGBdsh7 * dL_dRGB;
dL_dsh[8] = dRGBdsh8 * dL_dRGB;
dRGBdx += SH_C2[0] * y * sh[4] + SH_C2[2] * 2.f * -x * sh[6] + SH_C2[3] * z * sh[7] + SH_C2[4] * 2.f * x * sh[8];
dRGBdy += SH_C2[0] * x * sh[4] + SH_C2[1] * z * sh[5] + SH_C2[2] * 2.f * -y * sh[6] + SH_C2[4] * 2.f * -y * sh[8];
dRGBdz += SH_C2[1] * y * sh[5] + SH_C2[2] * 2.f * 2.f * z * sh[6] + SH_C2[3] * x * sh[7];
if (deg > 2)
{
float dRGBdsh9 = SH_C3[0] * y * (3.f * xx - yy);
float dRGBdsh10 = SH_C3[1] * xy * z;
float dRGBdsh11 = SH_C3[2] * y * (4.f * zz - xx - yy);
float dRGBdsh12 = SH_C3[3] * z * (2.f * zz - 3.f * xx - 3.f * yy);
float dRGBdsh13 = SH_C3[4] * x * (4.f * zz - xx - yy);
float dRGBdsh14 = SH_C3[5] * z * (xx - yy);
float dRGBdsh15 = SH_C3[6] * x * (xx - 3.f * yy);
dL_dsh[9] = dRGBdsh9 * dL_dRGB;
dL_dsh[10] = dRGBdsh10 * dL_dRGB;
dL_dsh[11] = dRGBdsh11 * dL_dRGB;
dL_dsh[12] = dRGBdsh12 * dL_dRGB;
dL_dsh[13] = dRGBdsh13 * dL_dRGB;
dL_dsh[14] = dRGBdsh14 * dL_dRGB;
dL_dsh[15] = dRGBdsh15 * dL_dRGB;
dRGBdx += (
SH_C3[0] * sh[9] * 3.f * 2.f * xy +
SH_C3[1] * sh[10] * yz +
SH_C3[2] * sh[11] * -2.f * xy +
SH_C3[3] * sh[12] * -3.f * 2.f * xz +
SH_C3[4] * sh[13] * (-3.f * xx + 4.f * zz - yy) +
SH_C3[5] * sh[14] * 2.f * xz +
SH_C3[6] * sh[15] * 3.f * (xx - yy));
dRGBdy += (
SH_C3[0] * sh[9] * 3.f * (xx - yy) +
SH_C3[1] * sh[10] * xz +
SH_C3[2] * sh[11] * (-3.f * yy + 4.f * zz - xx) +
SH_C3[3] * sh[12] * -3.f * 2.f * yz +
SH_C3[4] * sh[13] * -2.f * xy +
SH_C3[5] * sh[14] * -2.f * yz +
SH_C3[6] * sh[15] * -3.f * 2.f * xy);
dRGBdz += (
SH_C3[1] * sh[10] * xy +
SH_C3[2] * sh[11] * 4.f * 2.f * yz +
SH_C3[3] * sh[12] * 3.f * (2.f * zz - xx - yy) +
SH_C3[4] * sh[13] * 4.f * 2.f * xz +
SH_C3[5] * sh[14] * (xx - yy));
}
}
}
// The view direction is an input to the computation. View direction
// is influenced by the Gaussian's mean, so SHs gradients
// must propagate back into 3D position.
glm::vec3 dL_ddir(glm::dot(dRGBdx, dL_dRGB), glm::dot(dRGBdy, dL_dRGB), glm::dot(dRGBdz, dL_dRGB));
// Account for normalization of direction
float3 dL_dmean = dnormvdv(float3{ dir_orig.x, dir_orig.y, dir_orig.z }, float3{ dL_ddir.x, dL_ddir.y, dL_ddir.z });
// Gradients of loss w.r.t. Gaussian means, but only the portion
// that is caused because the mean affects the view-dependent color.
// Additional mean gradient is accumulated in below methods.
dL_dmeans[idx] += glm::vec3(dL_dmean.x, dL_dmean.y, dL_dmean.z);
}
// Backward version of INVERSE 2D covariance matrix computation
// (due to length launched as separate kernel before other
// backward steps contained in preprocess)
__global__ void computeCov2DCUDA(int P,
const float3* means,
const int* radii,
const float* cov3Ds,
const float h_x, float h_y,
const float tan_fovx, float tan_fovy,
const float* view_matrix,
const float* dL_dconics,
float3* dL_dmeans,
float* dL_dcov)
{
auto idx = cg::this_grid().thread_rank();
if (idx >= P || !(radii[idx] > 0))
return;
// Reading location of 3D covariance for this Gaussian
const float* cov3D = cov3Ds + 6 * idx;
// Fetch gradients, recompute 2D covariance and relevant
// intermediate forward results needed in the backward.
float3 mean = means[idx];
float3 dL_dconic = { dL_dconics[4 * idx], dL_dconics[4 * idx + 1], dL_dconics[4 * idx + 3] };
float3 t = transformPoint4x3(mean, view_matrix);
const float limx = 1.3f * tan_fovx;
const float limy = 1.3f * tan_fovy;
const float txtz = t.x / t.z;
const float tytz = t.y / t.z;
t.x = min(limx, max(-limx, txtz)) * t.z;
t.y = min(limy, max(-limy, tytz)) * t.z;
const float x_grad_mul = txtz < -limx || txtz > limx ? 0 : 1;
const float y_grad_mul = tytz < -limy || tytz > limy ? 0 : 1;
glm::mat3 J = glm::mat3(h_x / t.z, 0.0f, -(h_x * t.x) / (t.z * t.z),
0.0f, h_y / t.z, -(h_y * t.y) / (t.z * t.z),
0, 0, 0);
glm::mat3 W = glm::mat3(
view_matrix[0], view_matrix[4], view_matrix[8],
view_matrix[1], view_matrix[5], view_matrix[9],
view_matrix[2], view_matrix[6], view_matrix[10]);
glm::mat3 Vrk = glm::mat3(
cov3D[0], cov3D[1], cov3D[2],
cov3D[1], cov3D[3], cov3D[4],
cov3D[2], cov3D[4], cov3D[5]);
glm::mat3 T = W * J;
glm::mat3 cov2D = glm::transpose(T) * glm::transpose(Vrk) * T;
// Use helper variables for 2D covariance entries. More compact.
float a = cov2D[0][0] += 0.3f;
float b = cov2D[0][1];
float c = cov2D[1][1] += 0.3f;
float denom = a * c - b * b;
float dL_da = 0, dL_db = 0, dL_dc = 0;
float denom2inv = 1.0f / ((denom * denom) + 0.0000001f);
if (denom2inv != 0)
{
// Gradients of loss w.r.t. entries of 2D covariance matrix,
// given gradients of loss w.r.t. conic matrix (inverse covariance matrix).
// e.g., dL / da = dL / d_conic_a * d_conic_a / d_a
dL_da = denom2inv * (-c * c * dL_dconic.x + 2 * b * c * dL_dconic.y + (denom - a * c) * dL_dconic.z);
dL_dc = denom2inv * (-a * a * dL_dconic.z + 2 * a * b * dL_dconic.y + (denom - a * c) * dL_dconic.x);
dL_db = denom2inv * 2 * (b * c * dL_dconic.x - (denom + 2 * b * b) * dL_dconic.y + a * b * dL_dconic.z);
// Gradients of loss L w.r.t. each 3D covariance matrix (Vrk) entry,
// given gradients w.r.t. 2D covariance matrix (diagonal).
// cov2D = transpose(T) * transpose(Vrk) * T;
dL_dcov[6 * idx + 0] = (T[0][0] * T[0][0] * dL_da + T[0][0] * T[1][0] * dL_db + T[1][0] * T[1][0] * dL_dc);
dL_dcov[6 * idx + 3] = (T[0][1] * T[0][1] * dL_da + T[0][1] * T[1][1] * dL_db + T[1][1] * T[1][1] * dL_dc);
dL_dcov[6 * idx + 5] = (T[0][2] * T[0][2] * dL_da + T[0][2] * T[1][2] * dL_db + T[1][2] * T[1][2] * dL_dc);
// Gradients of loss L w.r.t. each 3D covariance matrix (Vrk) entry,
// given gradients w.r.t. 2D covariance matrix (off-diagonal).
// Off-diagonal elements appear twice --> double the gradient.
// cov2D = transpose(T) * transpose(Vrk) * T;
dL_dcov[6 * idx + 1] = 2 * T[0][0] * T[0][1] * dL_da + (T[0][0] * T[1][1] + T[0][1] * T[1][0]) * dL_db + 2 * T[1][0] * T[1][1] * dL_dc;
dL_dcov[6 * idx + 2] = 2 * T[0][0] * T[0][2] * dL_da + (T[0][0] * T[1][2] + T[0][2] * T[1][0]) * dL_db + 2 * T[1][0] * T[1][2] * dL_dc;
dL_dcov[6 * idx + 4] = 2 * T[0][2] * T[0][1] * dL_da + (T[0][1] * T[1][2] + T[0][2] * T[1][1]) * dL_db + 2 * T[1][1] * T[1][2] * dL_dc;
}
else
{
for (int i = 0; i < 6; i++)
dL_dcov[6 * idx + i] = 0;
}
// Gradients of loss w.r.t. upper 2x3 portion of intermediate matrix T
// cov2D = transpose(T) * transpose(Vrk) * T;
float dL_dT00 = 2 * (T[0][0] * Vrk[0][0] + T[0][1] * Vrk[0][1] + T[0][2] * Vrk[0][2]) * dL_da +
(T[1][0] * Vrk[0][0] + T[1][1] * Vrk[0][1] + T[1][2] * Vrk[0][2]) * dL_db;
float dL_dT01 = 2 * (T[0][0] * Vrk[1][0] + T[0][1] * Vrk[1][1] + T[0][2] * Vrk[1][2]) * dL_da +
(T[1][0] * Vrk[1][0] + T[1][1] * Vrk[1][1] + T[1][2] * Vrk[1][2]) * dL_db;
float dL_dT02 = 2 * (T[0][0] * Vrk[2][0] + T[0][1] * Vrk[2][1] + T[0][2] * Vrk[2][2]) * dL_da +
(T[1][0] * Vrk[2][0] + T[1][1] * Vrk[2][1] + T[1][2] * Vrk[2][2]) * dL_db;
float dL_dT10 = 2 * (T[1][0] * Vrk[0][0] + T[1][1] * Vrk[0][1] + T[1][2] * Vrk[0][2]) * dL_dc +
(T[0][0] * Vrk[0][0] + T[0][1] * Vrk[0][1] + T[0][2] * Vrk[0][2]) * dL_db;
float dL_dT11 = 2 * (T[1][0] * Vrk[1][0] + T[1][1] * Vrk[1][1] + T[1][2] * Vrk[1][2]) * dL_dc +
(T[0][0] * Vrk[1][0] + T[0][1] * Vrk[1][1] + T[0][2] * Vrk[1][2]) * dL_db;
float dL_dT12 = 2 * (T[1][0] * Vrk[2][0] + T[1][1] * Vrk[2][1] + T[1][2] * Vrk[2][2]) * dL_dc +
(T[0][0] * Vrk[2][0] + T[0][1] * Vrk[2][1] + T[0][2] * Vrk[2][2]) * dL_db;
// Gradients of loss w.r.t. upper 3x2 non-zero entries of Jacobian matrix
// T = W * J
float dL_dJ00 = W[0][0] * dL_dT00 + W[0][1] * dL_dT01 + W[0][2] * dL_dT02;
float dL_dJ02 = W[2][0] * dL_dT00 + W[2][1] * dL_dT01 + W[2][2] * dL_dT02;
float dL_dJ11 = W[1][0] * dL_dT10 + W[1][1] * dL_dT11 + W[1][2] * dL_dT12;
float dL_dJ12 = W[2][0] * dL_dT10 + W[2][1] * dL_dT11 + W[2][2] * dL_dT12;
float tz = 1.f / t.z;
float tz2 = tz * tz;
float tz3 = tz2 * tz;
// Gradients of loss w.r.t. transformed Gaussian mean t
float dL_dtx = x_grad_mul * -h_x * tz2 * dL_dJ02;
float dL_dty = y_grad_mul * -h_y * tz2 * dL_dJ12;
float dL_dtz = -h_x * tz2 * dL_dJ00 - h_y * tz2 * dL_dJ11 + (2 * h_x * t.x) * tz3 * dL_dJ02 + (2 * h_y * t.y) * tz3 * dL_dJ12;
// Account for transformation of mean to t
// t = transformPoint4x3(mean, view_matrix);
float3 dL_dmean = transformVec4x3Transpose({ dL_dtx, dL_dty, dL_dtz }, view_matrix);
// Gradients of loss w.r.t. Gaussian means, but only the portion
// that is caused because the mean affects the covariance matrix.
// Additional mean gradient is accumulated in BACKWARD::preprocess.
dL_dmeans[idx] = dL_dmean;
}
// Backward pass for the conversion of scale and rotation to a
// 3D covariance matrix for each Gaussian.
__device__ void computeCov3D(int idx, const glm::vec3 scale, float mod, const glm::vec4 rot, const float* dL_dcov3Ds, glm::vec3* dL_dscales, glm::vec4* dL_drots)
{
// Recompute (intermediate) results for the 3D covariance computation.
glm::vec4 q = rot;// / glm::length(rot);
float r = q.x;
float x = q.y;
float y = q.z;
float z = q.w;
glm::mat3 R = glm::mat3(
1.f - 2.f * (y * y + z * z), 2.f * (x * y - r * z), 2.f * (x * z + r * y),
2.f * (x * y + r * z), 1.f - 2.f * (x * x + z * z), 2.f * (y * z - r * x),
2.f * (x * z - r * y), 2.f * (y * z + r * x), 1.f - 2.f * (x * x + y * y)
);
glm::mat3 S = glm::mat3(1.0f);
glm::vec3 s = mod * scale;
S[0][0] = s.x;
S[1][1] = s.y;
S[2][2] = s.z;
glm::mat3 M = S * R;
const float* dL_dcov3D = dL_dcov3Ds + 6 * idx;
glm::vec3 dunc(dL_dcov3D[0], dL_dcov3D[3], dL_dcov3D[5]);
glm::vec3 ounc = 0.5f * glm::vec3(dL_dcov3D[1], dL_dcov3D[2], dL_dcov3D[4]);
// Convert per-element covariance loss gradients to matrix form
glm::mat3 dL_dSigma = glm::mat3(
dL_dcov3D[0], 0.5f * dL_dcov3D[1], 0.5f * dL_dcov3D[2],
0.5f * dL_dcov3D[1], dL_dcov3D[3], 0.5f * dL_dcov3D[4],
0.5f * dL_dcov3D[2], 0.5f * dL_dcov3D[4], dL_dcov3D[5]
);
// Compute loss gradient w.r.t. matrix M
// dSigma_dM = 2 * M
glm::mat3 dL_dM = 2.0f * M * dL_dSigma;
glm::mat3 Rt = glm::transpose(R);
glm::mat3 dL_dMt = glm::transpose(dL_dM);
// Gradients of loss w.r.t. scale
glm::vec3* dL_dscale = dL_dscales + idx;
dL_dscale->x = glm::dot(Rt[0], dL_dMt[0]);
dL_dscale->y = glm::dot(Rt[1], dL_dMt[1]);
dL_dscale->z = glm::dot(Rt[2], dL_dMt[2]);
dL_dMt[0] *= s.x;
dL_dMt[1] *= s.y;
dL_dMt[2] *= s.z;
// Gradients of loss w.r.t. normalized quaternion
glm::vec4 dL_dq;
dL_dq.x = 2 * z * (dL_dMt[0][1] - dL_dMt[1][0]) + 2 * y * (dL_dMt[2][0] - dL_dMt[0][2]) + 2 * x * (dL_dMt[1][2] - dL_dMt[2][1]);
dL_dq.y = 2 * y * (dL_dMt[1][0] + dL_dMt[0][1]) + 2 * z * (dL_dMt[2][0] + dL_dMt[0][2]) + 2 * r * (dL_dMt[1][2] - dL_dMt[2][1]) - 4 * x * (dL_dMt[2][2] + dL_dMt[1][1]);
dL_dq.z = 2 * x * (dL_dMt[1][0] + dL_dMt[0][1]) + 2 * r * (dL_dMt[2][0] - dL_dMt[0][2]) + 2 * z * (dL_dMt[1][2] + dL_dMt[2][1]) - 4 * y * (dL_dMt[2][2] + dL_dMt[0][0]);
dL_dq.w = 2 * r * (dL_dMt[0][1] - dL_dMt[1][0]) + 2 * x * (dL_dMt[2][0] + dL_dMt[0][2]) + 2 * y * (dL_dMt[1][2] + dL_dMt[2][1]) - 4 * z * (dL_dMt[1][1] + dL_dMt[0][0]);
// Gradients of loss w.r.t. unnormalized quaternion
float4* dL_drot = (float4*)(dL_drots + idx);
*dL_drot = float4{ dL_dq.x, dL_dq.y, dL_dq.z, dL_dq.w };//dnormvdv(float4{ rot.x, rot.y, rot.z, rot.w }, float4{ dL_dq.x, dL_dq.y, dL_dq.z, dL_dq.w });
}
// Backward pass of the preprocessing steps, except
// for the covariance computation and inversion
// (those are handled by a previous kernel call)
template<int C>
__global__ void preprocessCUDA(
int P, int D, int M,
const float3* means,
const int* radii,
const float* shs,
const bool* clamped,
const glm::vec3* scales,
const glm::vec4* rotations,
const float scale_modifier,
const float* proj,
const glm::vec3* campos,
const float4* dL_dmean2D,
glm::vec3* dL_dmeans,
float* dL_dcolor,
float* dL_dcov3D,
float* dL_dsh,
glm::vec3* dL_dscale,
glm::vec4* dL_drot)
{
auto idx = cg::this_grid().thread_rank();
if (idx >= P || !(radii[idx] > 0))
return;
float3 m = means[idx];
// Taking care of gradients from the screenspace points
float4 m_hom = transformPoint4x4(m, proj);
float m_w = 1.0f / (m_hom.w + 0.0000001f);
// Compute loss gradient w.r.t. 3D means due to gradients of 2D means
// from rendering procedure
glm::vec3 dL_dmean;
float mul1 = (proj[0] * m.x + proj[4] * m.y + proj[8] * m.z + proj[12]) * m_w * m_w;
float mul2 = (proj[1] * m.x + proj[5] * m.y + proj[9] * m.z + proj[13]) * m_w * m_w;
dL_dmean.x = (proj[0] * m_w - proj[3] * mul1) * dL_dmean2D[idx].x + (proj[1] * m_w - proj[3] * mul2) * dL_dmean2D[idx].y;
dL_dmean.y = (proj[4] * m_w - proj[7] * mul1) * dL_dmean2D[idx].x + (proj[5] * m_w - proj[7] * mul2) * dL_dmean2D[idx].y;
dL_dmean.z = (proj[8] * m_w - proj[11] * mul1) * dL_dmean2D[idx].x + (proj[9] * m_w - proj[11] * mul2) * dL_dmean2D[idx].y;
// That's the second part of the mean gradient. Previous computation
// of cov2D and following SH conversion also affects it.
dL_dmeans[idx] += dL_dmean;
// Compute gradient updates due to computing colors from SHs
if (shs)
computeColorFromSH(idx, D, M, (glm::vec3*)means, *campos, shs, clamped, (glm::vec3*)dL_dcolor, (glm::vec3*)dL_dmeans, (glm::vec3*)dL_dsh);
// Compute gradient updates due to computing covariance from scale/rotation
if (scales)
computeCov3D(idx, scales[idx], scale_modifier, rotations[idx], dL_dcov3D, dL_dscale, dL_drot);
}
// Backward version of the rendering procedure.
template <uint32_t C>
__global__ void __launch_bounds__(BLOCK_X * BLOCK_Y)
renderCUDA(
const uint2* __restrict__ ranges,
const uint32_t* __restrict__ point_list,
int W, int H,
const float* __restrict__ bg_color,
const float2* __restrict__ points_xy_image,
const float4* __restrict__ conic_opacity,
const float* __restrict__ colors,
const float* __restrict__ final_Ts,
const uint32_t* __restrict__ n_contrib,
const float* __restrict__ dL_dpixels,
float4* __restrict__ dL_dmean2D,
float4* __restrict__ dL_dconic2D,
float* __restrict__ dL_dopacity,
float* __restrict__ dL_dcolors)
{
// We rasterize again. Compute necessary block info.
auto block = cg::this_thread_block();
const uint32_t horizontal_blocks = (W + BLOCK_X - 1) / BLOCK_X;
const uint2 pix_min = { block.group_index().x * BLOCK_X, block.group_index().y * BLOCK_Y };
const uint2 pix_max = { min(pix_min.x + BLOCK_X, W), min(pix_min.y + BLOCK_Y , H) };
const uint2 pix = { pix_min.x + block.thread_index().x, pix_min.y + block.thread_index().y };
const uint32_t pix_id = W * pix.y + pix.x;
const float2 pixf = { (float)pix.x, (float)pix.y };
const bool inside = pix.x < W&& pix.y < H;
const uint2 range = ranges[block.group_index().y * horizontal_blocks + block.group_index().x];
const int rounds = ((range.y - range.x + BLOCK_SIZE - 1) / BLOCK_SIZE);
bool done = !inside;
int toDo = range.y - range.x;
__shared__ int collected_id[BLOCK_SIZE];
__shared__ float2 collected_xy[BLOCK_SIZE];
__shared__ float4 collected_conic_opacity[BLOCK_SIZE];
__shared__ float collected_colors[C * BLOCK_SIZE];
// In the forward, we stored the final value for T, the
// product of all (1 - alpha) factors.
const float T_final = inside ? final_Ts[pix_id] : 0;
float T = T_final;
// We start from the back. The ID of the last contributing
// Gaussian is known from each pixel from the forward.
uint32_t contributor = toDo;
const int last_contributor = inside ? n_contrib[pix_id] : 0;
float accum_rec[C] = { 0 };
float dL_dpixel[C];
if (inside)
for (int i = 0; i < C; i++)
dL_dpixel[i] = dL_dpixels[i * H * W + pix_id];
float last_alpha = 0;
float last_color[C] = { 0 };
// Gradient of pixel coordinate w.r.t. normalized
// screen-space viewport corrdinates (-1 to 1)
const float ddelx_dx = 0.5 * W;
const float ddely_dy = 0.5 * H;
// Traverse all Gaussians
for (int i = 0; i < rounds; i++, toDo -= BLOCK_SIZE)
{
// Load auxiliary data into shared memory, start in the BACK
// and load them in revers order.
block.sync();
const int progress = i * BLOCK_SIZE + block.thread_rank();
if (range.x + progress < range.y)
{
const int coll_id = point_list[range.y - progress - 1];
collected_id[block.thread_rank()] = coll_id;
collected_xy[block.thread_rank()] = points_xy_image[coll_id];
collected_conic_opacity[block.thread_rank()] = conic_opacity[coll_id];
for (int i = 0; i < C; i++)
collected_colors[i * BLOCK_SIZE + block.thread_rank()] = colors[coll_id * C + i];
}
block.sync();
// Iterate over Gaussians
for (int j = 0; !done && j < min(BLOCK_SIZE, toDo); j++)
{
// Keep track of current Gaussian ID. Skip, if this one
// is behind the last contributor for this pixel.
contributor--;
if (contributor >= last_contributor)
continue;
// Compute blending values, as before.
const float2 xy = collected_xy[j];
const float2 d = { xy.x - pixf.x, xy.y - pixf.y };
const float4 con_o = collected_conic_opacity[j];
const float power = -0.5f * (con_o.x * d.x * d.x + con_o.z * d.y * d.y) - con_o.y * d.x * d.y;
if (power > 0.0f)
continue;
const float G = exp(power);
const float alpha = min(0.99f, con_o.w * G);
if (alpha < 1.0f / 255.0f)
continue;
T = T / (1.f - alpha);
const float dchannel_dcolor = alpha * T;
// Propagate gradients to per-Gaussian colors and keep
// gradients w.r.t. alpha (blending factor for a Gaussian/pixel
// pair).
float dL_dalpha = 0.0f;
const int global_id = collected_id[j];
for (int ch = 0; ch < C; ch++)
{
const float c = collected_colors[ch * BLOCK_SIZE + j];
// Update last color (to be used in the next iteration)
accum_rec[ch] = last_alpha * last_color[ch] + (1.f - last_alpha) * accum_rec[ch];
last_color[ch] = c;
const float dL_dchannel = dL_dpixel[ch];
dL_dalpha += (c - accum_rec[ch]) * dL_dchannel;
// Update the gradients w.r.t. color of the Gaussian.
// Atomic, since this pixel is just one of potentially
// many that were affected by this Gaussian.
atomicAdd(&(dL_dcolors[global_id * C + ch]), dchannel_dcolor * dL_dchannel);
}
dL_dalpha *= T;
// Update last alpha (to be used in the next iteration)
last_alpha = alpha;
// Account for fact that alpha also influences how much of
// the background color is added if nothing left to blend
float bg_dot_dpixel = 0;
for (int i = 0; i < C; i++)
bg_dot_dpixel += bg_color[i] * dL_dpixel[i];
dL_dalpha += (-T_final / (1.f - alpha)) * bg_dot_dpixel;
// Helpful reusable temporary variables
const float dL_dG = con_o.w * dL_dalpha;
const float gdx = G * d.x;
const float gdy = G * d.y;
const float dG_ddelx = -gdx * con_o.x - gdy * con_o.y;
const float dG_ddely = -gdy * con_o.z - gdx * con_o.y;
// Update gradients w.r.t. 2D mean position of the Gaussian
atomicAdd(&dL_dmean2D[global_id].x, dL_dG * dG_ddelx * ddelx_dx);
atomicAdd(&dL_dmean2D[global_id].y, dL_dG * dG_ddely * ddely_dy);
// Homodirectional Gradient
atomicAdd(&dL_dmean2D[global_id].z, fabs(dL_dG * dG_ddelx * ddelx_dx));
atomicAdd(&dL_dmean2D[global_id].w, fabs(dL_dG * dG_ddely * ddely_dy));
// Update gradients w.r.t. 2D covariance (2x2 matrix, symmetric)
atomicAdd(&dL_dconic2D[global_id].x, -0.5f * gdx * d.x * dL_dG);
atomicAdd(&dL_dconic2D[global_id].y, -0.5f * gdx * d.y * dL_dG);
atomicAdd(&dL_dconic2D[global_id].w, -0.5f * gdy * d.y * dL_dG);
// Update gradients w.r.t. opacity of the Gaussian
atomicAdd(&(dL_dopacity[global_id]), G * dL_dalpha);
}
}
}
void BACKWARD::preprocess(
int P, int D, int M,
const float3* means3D,
const int* radii,
const float* shs,
const bool* clamped,
const glm::vec3* scales,
const glm::vec4* rotations,
const float scale_modifier,
const float* cov3Ds,
const float* viewmatrix,
const float* projmatrix,
const float focal_x, float focal_y,
const float tan_fovx, float tan_fovy,
const glm::vec3* campos,
const float4* dL_dmean2D,
const float* dL_dconic,
glm::vec3* dL_dmean3D,
float* dL_dcolor,
float* dL_dcov3D,
float* dL_dsh,
glm::vec3* dL_dscale,
glm::vec4* dL_drot)
{
// Propagate gradients for the path of 2D conic matrix computation.
// Somewhat long, thus it is its own kernel rather than being part of
// "preprocess". When done, loss gradient w.r.t. 3D means has been
// modified and gradient w.r.t. 3D covariance matrix has been computed.
computeCov2DCUDA << <(P + 255) / 256, 256 >> > (
P,
means3D,
radii,
cov3Ds,
focal_x,
focal_y,
tan_fovx,
tan_fovy,
viewmatrix,
dL_dconic,
(float3*)dL_dmean3D,
dL_dcov3D);
// Propagate gradients for remaining steps: finish 3D mean gradients,
// propagate color gradients to SH (if desireD), propagate 3D covariance
// matrix gradients to scale and rotation.
preprocessCUDA<NUM_CHANNELS> << < (P + 255) / 256, 256 >> > (
P, D, M,
(float3*)means3D,
radii,
shs,
clamped,
(glm::vec3*)scales,
(glm::vec4*)rotations,
scale_modifier,
projmatrix,
campos,
(float4*)dL_dmean2D,
(glm::vec3*)dL_dmean3D,
dL_dcolor,
dL_dcov3D,
dL_dsh,
dL_dscale,
dL_drot);
}
void BACKWARD::render(
const dim3 grid, const dim3 block,
const uint2* ranges,
const uint32_t* point_list,
int W, int H,
const float* bg_color,
const float2* means2D,
const float4* conic_opacity,
const float* colors,
const float* final_Ts,
const uint32_t* n_contrib,
const float* dL_dpixels,
float4* dL_dmean2D,
float4* dL_dconic2D,
float* dL_dopacity,
float* dL_dcolors)
{
renderCUDA<NUM_CHANNELS> << <grid, block >> >(
ranges,
point_list,
W, H,
bg_color,
means2D,
conic_opacity,
colors,
final_Ts,
n_contrib,
dL_dpixels,
dL_dmean2D,
dL_dconic2D,
dL_dopacity,
dL_dcolors
);
}
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/backward.h
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#ifndef CUDA_RASTERIZER_BACKWARD_H_INCLUDED
#define CUDA_RASTERIZER_BACKWARD_H_INCLUDED
#include <cuda.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#define GLM_FORCE_CUDA
#include <glm/glm.hpp>
namespace BACKWARD
{
void render(
const dim3 grid, dim3 block,
const uint2* ranges,
const uint32_t* point_list,
int W, int H,
const float* bg_color,
const float2* means2D,
const float4* conic_opacity,
const float* colors,
const float* final_Ts,
const uint32_t* n_contrib,
const float* dL_dpixels,
float4* dL_dmean2D,
float4* dL_dconic2D,
float* dL_dopacity,
float* dL_dcolors);
void preprocess(
int P, int D, int M,
const float3* means,
const int* radii,
const float* shs,
const bool* clamped,
const glm::vec3* scales,
const glm::vec4* rotations,
const float scale_modifier,
const float* cov3Ds,
const float* view,
const float* proj,
const float focal_x, float focal_y,
const float tan_fovx, float tan_fovy,
const glm::vec3* campos,
const float4* dL_dmean2D,
const float* dL_dconics,
glm::vec3* dL_dmeans,
float* dL_dcolor,
float* dL_dcov3D,
float* dL_dsh,
glm::vec3* dL_dscale,
glm::vec4* dL_drot);
}
#endif
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/config.h
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#ifndef CUDA_RASTERIZER_CONFIG_H_INCLUDED
#define CUDA_RASTERIZER_CONFIG_H_INCLUDED
#define NUM_CHANNELS 3 // Default 3, RGB
#define BLOCK_X 16
#define BLOCK_Y 16
#endif
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/forward.cu
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#include "forward.h"
#include "auxiliary.h"
#include <cooperative_groups.h>
#include <cooperative_groups/reduce.h>
namespace cg = cooperative_groups;
// Forward method for converting the input spherical harmonics
// coefficients of each Gaussian to a simple RGB color.
__device__ glm::vec3 computeColorFromSH(int idx, int deg, int max_coeffs, const glm::vec3* means, glm::vec3 campos, const float* shs, bool* clamped)
{
// The implementation is loosely based on code for
// "Differentiable Point-Based Radiance Fields for
// Efficient View Synthesis" by Zhang et al. (2022)
glm::vec3 pos = means[idx];
glm::vec3 dir = pos - campos;
dir = dir / glm::length(dir);
glm::vec3* sh = ((glm::vec3*)shs) + idx * max_coeffs;
glm::vec3 result = SH_C0 * sh[0];
if (deg > 0)
{
float x = dir.x;
float y = dir.y;
float z = dir.z;
result = result - SH_C1 * y * sh[1] + SH_C1 * z * sh[2] - SH_C1 * x * sh[3];
if (deg > 1)
{
float xx = x * x, yy = y * y, zz = z * z;
float xy = x * y, yz = y * z, xz = x * z;
result = result +
SH_C2[0] * xy * sh[4] +
SH_C2[1] * yz * sh[5] +
SH_C2[2] * (2.0f * zz - xx - yy) * sh[6] +
SH_C2[3] * xz * sh[7] +
SH_C2[4] * (xx - yy) * sh[8];
if (deg > 2)
{
result = result +
SH_C3[0] * y * (3.0f * xx - yy) * sh[9] +
SH_C3[1] * xy * z * sh[10] +
SH_C3[2] * y * (4.0f * zz - xx - yy) * sh[11] +
SH_C3[3] * z * (2.0f * zz - 3.0f * xx - 3.0f * yy) * sh[12] +
SH_C3[4] * x * (4.0f * zz - xx - yy) * sh[13] +
SH_C3[5] * z * (xx - yy) * sh[14] +
SH_C3[6] * x * (xx - 3.0f * yy) * sh[15];
}
}
}
result += 0.5f;
// RGB colors are clamped to positive values. If values are
// clamped, we need to keep track of this for the backward pass.
clamped[3 * idx + 0] = (result.x < 0);
clamped[3 * idx + 1] = (result.y < 0);
clamped[3 * idx + 2] = (result.z < 0);
return glm::max(result, 0.0f);
}
// Forward version of 2D covariance matrix computation
__device__ float3 computeCov2D(const float3& mean, float focal_x, float focal_y, float tan_fovx, float tan_fovy, const float* cov3D, const float* viewmatrix)
{
// The following models the steps outlined by equations 29
// and 31 in "EWA Splatting" (Zwicker et al., 2002).
// Additionally considers aspect / scaling of viewport.
// Transposes used to account for row-/column-major conventions.
float3 t = transformPoint4x3(mean, viewmatrix);
const float limx = 1.3f * tan_fovx;
const float limy = 1.3f * tan_fovy;
const float txtz = t.x / t.z;
const float tytz = t.y / t.z;
t.x = min(limx, max(-limx, txtz)) * t.z;
t.y = min(limy, max(-limy, tytz)) * t.z;
glm::mat3 J = glm::mat3(
focal_x / t.z, 0.0f, -(focal_x * t.x) / (t.z * t.z),
0.0f, focal_y / t.z, -(focal_y * t.y) / (t.z * t.z),
0, 0, 0);
glm::mat3 W = glm::mat3(
viewmatrix[0], viewmatrix[4], viewmatrix[8],
viewmatrix[1], viewmatrix[5], viewmatrix[9],
viewmatrix[2], viewmatrix[6], viewmatrix[10]);
glm::mat3 T = W * J;
glm::mat3 Vrk = glm::mat3(
cov3D[0], cov3D[1], cov3D[2],
cov3D[1], cov3D[3], cov3D[4],
cov3D[2], cov3D[4], cov3D[5]);
glm::mat3 cov = glm::transpose(T) * glm::transpose(Vrk) * T;
// Apply low-pass filter: every Gaussian should be at least
// one pixel wide/high. Discard 3rd row and column.
cov[0][0] += 0.3f;
cov[1][1] += 0.3f;
return { float(cov[0][0]), float(cov[0][1]), float(cov[1][1]) };
}
// Forward method for converting scale and rotation properties of each
// Gaussian to a 3D covariance matrix in world space. Also takes care
// of quaternion normalization.
__device__ void computeCov3D(const glm::vec3 scale, float mod, const glm::vec4 rot, float* cov3D)
{
// Create scaling matrix
glm::mat3 S = glm::mat3(1.0f);
S[0][0] = mod * scale.x;
S[1][1] = mod * scale.y;
S[2][2] = mod * scale.z;
// Normalize quaternion to get valid rotation
glm::vec4 q = rot;// / glm::length(rot);
float r = q.x;
float x = q.y;
float y = q.z;
float z = q.w;
// Compute rotation matrix from quaternion
glm::mat3 R = glm::mat3(
1.f - 2.f * (y * y + z * z), 2.f * (x * y - r * z), 2.f * (x * z + r * y),
2.f * (x * y + r * z), 1.f - 2.f * (x * x + z * z), 2.f * (y * z - r * x),
2.f * (x * z - r * y), 2.f * (y * z + r * x), 1.f - 2.f * (x * x + y * y)
);
glm::mat3 M = S * R;
// Compute 3D world covariance matrix Sigma
glm::mat3 Sigma = glm::transpose(M) * M;
// Covariance is symmetric, only store upper right
cov3D[0] = Sigma[0][0];
cov3D[1] = Sigma[0][1];
cov3D[2] = Sigma[0][2];
cov3D[3] = Sigma[1][1];
cov3D[4] = Sigma[1][2];
cov3D[5] = Sigma[2][2];
}
// Perform initial steps for each Gaussian prior to rasterization.
template<int C>
__global__ void preprocessCUDA(int P, int D, int M,
const float* orig_points,
const glm::vec3* scales,
const float scale_modifier,
const glm::vec4* rotations,
const float* opacities,
const float* shs,
bool* clamped,
const float* cov3D_precomp,
const float* colors_precomp,
const float* viewmatrix,
const float* projmatrix,
const glm::vec3* cam_pos,
const int W, int H,
const float tan_fovx, float tan_fovy,
const float focal_x, float focal_y,
int* radii,
float2* points_xy_image,
float* depths,
float* cov3Ds,
float* rgb,
float4* conic_opacity,
const dim3 grid,
uint32_t* tiles_touched,
bool prefiltered)
{
auto idx = cg::this_grid().thread_rank();
if (idx >= P)
return;
// Initialize radius and touched tiles to 0. If this isn't changed,
// this Gaussian will not be processed further.
radii[idx] = 0;
tiles_touched[idx] = 0;
// Perform near culling, quit if outside.
float3 p_view;
if (!in_frustum(idx, orig_points, viewmatrix, projmatrix, prefiltered, p_view))
return;
// Transform point by projecting
float3 p_orig = { orig_points[3 * idx], orig_points[3 * idx + 1], orig_points[3 * idx + 2] };
float4 p_hom = transformPoint4x4(p_orig, projmatrix);
float p_w = 1.0f / (p_hom.w + 0.0000001f);
float3 p_proj = { p_hom.x * p_w, p_hom.y * p_w, p_hom.z * p_w };
// If 3D covariance matrix is precomputed, use it, otherwise compute
// from scaling and rotation parameters.
const float* cov3D;
if (cov3D_precomp != nullptr)
{
cov3D = cov3D_precomp + idx * 6;
}
else
{
computeCov3D(scales[idx], scale_modifier, rotations[idx], cov3Ds + idx * 6);
cov3D = cov3Ds + idx * 6;
}
// Compute 2D screen-space covariance matrix
float3 cov = computeCov2D(p_orig, focal_x, focal_y, tan_fovx, tan_fovy, cov3D, viewmatrix);
// Invert covariance (EWA algorithm)
float det = (cov.x * cov.z - cov.y * cov.y);
if (det == 0.0f)
return;
float det_inv = 1.f / det;
float3 conic = { cov.z * det_inv, -cov.y * det_inv, cov.x * det_inv };
// Compute extent in screen space (by finding eigenvalues of
// 2D covariance matrix). Use extent to compute a bounding rectangle
// of screen-space tiles that this Gaussian overlaps with. Quit if
// rectangle covers 0 tiles.
float mid = 0.5f * (cov.x + cov.z);
float lambda1 = mid + sqrt(max(0.1f, mid * mid - det));
float lambda2 = mid - sqrt(max(0.1f, mid * mid - det));
float my_radius = ceil(3.f * sqrt(max(lambda1, lambda2)));
float2 point_image = { ndc2Pix(p_proj.x, W), ndc2Pix(p_proj.y, H) };
uint2 rect_min, rect_max;
getRect(point_image, my_radius, rect_min, rect_max, grid);
if ((rect_max.x - rect_min.x) * (rect_max.y - rect_min.y) == 0)
return;
// If colors have been precomputed, use them, otherwise convert
// spherical harmonics coefficients to RGB color.
if (colors_precomp == nullptr)
{
glm::vec3 result = computeColorFromSH(idx, D, M, (glm::vec3*)orig_points, *cam_pos, shs, clamped);
rgb[idx * C + 0] = result.x;
rgb[idx * C + 1] = result.y;
rgb[idx * C + 2] = result.z;
}
// Store some useful helper data for the next steps.
depths[idx] = p_view.z;
radii[idx] = my_radius;
points_xy_image[idx] = point_image;
// Inverse 2D covariance and opacity neatly pack into one float4
conic_opacity[idx] = { conic.x, conic.y, conic.z, opacities[idx] };
tiles_touched[idx] = (rect_max.y - rect_min.y) * (rect_max.x - rect_min.x);
}
// Main rasterization method. Collaboratively works on one tile per
// block, each thread treats one pixel. Alternates between fetching
// and rasterizing data.
template <uint32_t CHANNELS>
__global__ void __launch_bounds__(BLOCK_X * BLOCK_Y)
renderCUDA(
const uint2* __restrict__ ranges,
const uint32_t* __restrict__ point_list,
int W, int H,
const float2* __restrict__ points_xy_image,
const float* __restrict__ features,
const float4* __restrict__ conic_opacity,
float* __restrict__ final_T,
uint32_t* __restrict__ n_contrib,
const float* __restrict__ bg_color,
float* __restrict__ out_color,
float* __restrict__ gs_w)
{
// Identify current tile and associated min/max pixel range.
auto block = cg::this_thread_block();
uint32_t horizontal_blocks = (W + BLOCK_X - 1) / BLOCK_X;
uint2 pix_min = { block.group_index().x * BLOCK_X, block.group_index().y * BLOCK_Y };
uint2 pix_max = { min(pix_min.x + BLOCK_X, W), min(pix_min.y + BLOCK_Y , H) };
uint2 pix = { pix_min.x + block.thread_index().x, pix_min.y + block.thread_index().y };
uint32_t pix_id = W * pix.y + pix.x;
float2 pixf = { (float)pix.x, (float)pix.y };
// Check if this thread is associated with a valid pixel or outside.
bool inside = pix.x < W&& pix.y < H;
// Done threads can help with fetching, but don't rasterize
bool done = !inside;
// Load start/end range of IDs to process in bit sorted list.
uint2 range = ranges[block.group_index().y * horizontal_blocks + block.group_index().x];
const int rounds = ((range.y - range.x + BLOCK_SIZE - 1) / BLOCK_SIZE);
int toDo = range.y - range.x;
// Allocate storage for batches of collectively fetched data.
__shared__ int collected_id[BLOCK_SIZE];
__shared__ float2 collected_xy[BLOCK_SIZE];
__shared__ float4 collected_conic_opacity[BLOCK_SIZE];
// Initialize helper variables
float T = 1.0f;
uint32_t contributor = 0;
uint32_t last_contributor = 0;
float C[CHANNELS] = { 0 };
// Iterate over batches until all done or range is complete
for (int i = 0; i < rounds; i++, toDo -= BLOCK_SIZE)
{
// End if entire block votes that it is done rasterizing
int num_done = __syncthreads_count(done);
if (num_done == BLOCK_SIZE)
break;
// Collectively fetch per-Gaussian data from global to shared
int progress = i * BLOCK_SIZE + block.thread_rank();
if (range.x + progress < range.y)
{
int coll_id = point_list[range.x + progress];
collected_id[block.thread_rank()] = coll_id;
collected_xy[block.thread_rank()] = points_xy_image[coll_id];
collected_conic_opacity[block.thread_rank()] = conic_opacity[coll_id];
}
block.sync();
// Iterate over current batch
for (int j = 0; !done && j < min(BLOCK_SIZE, toDo); j++)
{
// Keep track of current position in range
contributor++;
// Resample using conic matrix (cf. "Surface
// Splatting" by Zwicker et al., 2001)
float2 xy = collected_xy[j];
float2 d = { xy.x - pixf.x, xy.y - pixf.y };
float4 con_o = collected_conic_opacity[j];
float power = -0.5f * (con_o.x * d.x * d.x + con_o.z * d.y * d.y) - con_o.y * d.x * d.y;
if (power > 0.0f)
continue;
// Eq. (2) from 3D Gaussian splatting paper.
// Obtain alpha by multiplying with Gaussian opacity
// and its exponential falloff from mean.
// Avoid numerical instabilities (see paper appendix).
float alpha = min(0.99f, con_o.w * exp(power));
if (alpha < 1.0f / 255.0f)
continue;
float test_T = T * (1 - alpha);
if (test_T < 0.0001f)
{
done = true;
continue;
}
// Eq. (3) from 3D Gaussian splatting paper.
for (int ch = 0; ch < CHANNELS; ch++)
C[ch] += features[collected_id[j] * CHANNELS + ch] * alpha * T;
atomicAdd(&gs_w[collected_id[j]], alpha * T);
T = test_T;
// Keep track of last range entry to update this
// pixel.
last_contributor = contributor;
}
}
// All threads that treat valid pixel write out their final
// rendering data to the frame and auxiliary buffers.
if (inside)
{
final_T[pix_id] = T;
n_contrib[pix_id] = last_contributor;
for (int ch = 0; ch < CHANNELS; ch++)
out_color[ch * H * W + pix_id] = C[ch] + T * bg_color[ch];
}
}
void FORWARD::render(
const dim3 grid, dim3 block,
const uint2* ranges,
const uint32_t* point_list,
int W, int H,
const float2* means2D,
const float* colors,
const float4* conic_opacity,
float* final_T,
uint32_t* n_contrib,
const float* bg_color,
float* out_color,
float* gs_w)
{
renderCUDA<NUM_CHANNELS> << <grid, block >> > (
ranges,
point_list,
W, H,
means2D,
colors,
conic_opacity,
final_T,
n_contrib,
bg_color,
out_color,
gs_w);
}
void FORWARD::preprocess(int P, int D, int M,
const float* means3D,
const glm::vec3* scales,
const float scale_modifier,
const glm::vec4* rotations,
const float* opacities,
const float* shs,
bool* clamped,
const float* cov3D_precomp,
const float* colors_precomp,
const float* viewmatrix,
const float* projmatrix,
const glm::vec3* cam_pos,
const int W, int H,
const float focal_x, float focal_y,
const float tan_fovx, float tan_fovy,
int* radii,
float2* means2D,
float* depths,
float* cov3Ds,
float* rgb,
float4* conic_opacity,
const dim3 grid,
uint32_t* tiles_touched,
bool prefiltered)
{
preprocessCUDA<NUM_CHANNELS> << <(P + 255) / 256, 256 >> > (
P, D, M,
means3D,
scales,
scale_modifier,
rotations,
opacities,
shs,
clamped,
cov3D_precomp,
colors_precomp,
viewmatrix,
projmatrix,
cam_pos,
W, H,
tan_fovx, tan_fovy,
focal_x, focal_y,
radii,
means2D,
depths,
cov3Ds,
rgb,
conic_opacity,
grid,
tiles_touched,
prefiltered
);
}
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/forward.h
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#ifndef CUDA_RASTERIZER_FORWARD_H_INCLUDED
#define CUDA_RASTERIZER_FORWARD_H_INCLUDED
#include <cuda.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#define GLM_FORCE_CUDA
#include <glm/glm.hpp>
namespace FORWARD
{
// Perform initial steps for each Gaussian prior to rasterization.
void preprocess(int P, int D, int M,
const float* orig_points,
const glm::vec3* scales,
const float scale_modifier,
const glm::vec4* rotations,
const float* opacities,
const float* shs,
bool* clamped,
const float* cov3D_precomp,
const float* colors_precomp,
const float* viewmatrix,
const float* projmatrix,
const glm::vec3* cam_pos,
const int W, int H,
const float focal_x, float focal_y,
const float tan_fovx, float tan_fovy,
int* radii,
float2* points_xy_image,
float* depths,
float* cov3Ds,
float* colors,
float4* conic_opacity,
const dim3 grid,
uint32_t* tiles_touched,
bool prefiltered);
// Main rasterization method.
void render(
const dim3 grid, dim3 block,
const uint2* ranges,
const uint32_t* point_list,
int W, int H,
const float2* points_xy_image,
const float* features,
const float4* conic_opacity,
float* final_T,
uint32_t* n_contrib,
const float* bg_color,
float* out_color,
float* gs_w);
}
#endif
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/rasterizer.h
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#ifndef CUDA_RASTERIZER_H_INCLUDED
#define CUDA_RASTERIZER_H_INCLUDED
#include <vector>
#include <functional>
namespace CudaRasterizer
{
class Rasterizer
{
public:
static void markVisible(
int P,
float* means3D,
float* viewmatrix,
float* projmatrix,
bool* present);
static int forward(
std::function<char* (size_t)> geometryBuffer,
std::function<char* (size_t)> binningBuffer,
std::function<char* (size_t)> imageBuffer,
const int P, int D, int M,
const float* background,
const int width, int height,
const float* means3D,
const float* shs,
const float* colors_precomp,
const float* opacities,
const float* scales,
const float scale_modifier,
const float* rotations,
const float* cov3D_precomp,
const float* viewmatrix,
const float* projmatrix,
const float* cam_pos,
const float tan_fovx, float tan_fovy,
const bool prefiltered,
float* out_color,
float* gs_w,
int* radii = nullptr,
bool debug = false);
static void backward(
const int P, int D, int M, int R,
const float* background,
const int width, int height,
const float* means3D,
const float* shs,
const float* colors_precomp,
const float* scales,
const float scale_modifier,
const float* rotations,
const float* cov3D_precomp,
const float* viewmatrix,
const float* projmatrix,
const float* campos,
const float tan_fovx, float tan_fovy,
const int* radii,
char* geom_buffer,
char* binning_buffer,
char* image_buffer,
const float* dL_dpix,
float* dL_dmean2D,
float* dL_dconic,
float* dL_dopacity,
float* dL_dcolor,
float* dL_dmean3D,
float* dL_dcov3D,
float* dL_dsh,
float* dL_dscale,
float* dL_drot,
bool debug);
};
};
#endif
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/rasterizer_impl.cu
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#include "rasterizer_impl.h"
#include <iostream>
#include <fstream>
#include <algorithm>
#include <numeric>
#include <cuda.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <cub/cub.cuh>
#include <cub/device/device_radix_sort.cuh>
#define GLM_FORCE_CUDA
#include <glm/glm.hpp>
#include <cooperative_groups.h>
#include <cooperative_groups/reduce.h>
namespace cg = cooperative_groups;
#include "auxiliary.h"
#include "forward.h"
#include "backward.h"
// Helper function to find the next-highest bit of the MSB
// on the CPU.
uint32_t getHigherMsb(uint32_t n)
{
uint32_t msb = sizeof(n) * 4;
uint32_t step = msb;
while (step > 1)
{
step /= 2;
if (n >> msb)
msb += step;
else
msb -= step;
}
if (n >> msb)
msb++;
return msb;
}
// Wrapper method to call auxiliary coarse frustum containment test.
// Mark all Gaussians that pass it.
__global__ void checkFrustum(int P,
const float* orig_points,
const float* viewmatrix,
const float* projmatrix,
bool* present)
{
auto idx = cg::this_grid().thread_rank();
if (idx >= P)
return;
float3 p_view;
present[idx] = in_frustum(idx, orig_points, viewmatrix, projmatrix, false, p_view);
}
// Generates one key/value pair for all Gaussian / tile overlaps.
// Run once per Gaussian (1:N mapping).
__global__ void duplicateWithKeys(
int P,
const float2* points_xy,
const float* depths,
const uint32_t* offsets,
uint64_t* gaussian_keys_unsorted,
uint32_t* gaussian_values_unsorted,
int* radii,
dim3 grid)
{
auto idx = cg::this_grid().thread_rank();
if (idx >= P)
return;
// Generate no key/value pair for invisible Gaussians
if (radii[idx] > 0)
{
// Find this Gaussian's offset in buffer for writing keys/values.
uint32_t off = (idx == 0) ? 0 : offsets[idx - 1];
uint2 rect_min, rect_max;
getRect(points_xy[idx], radii[idx], rect_min, rect_max, grid);
// For each tile that the bounding rect overlaps, emit a
// key/value pair. The key is | tile ID | depth |,
// and the value is the ID of the Gaussian. Sorting the values
// with this key yields Gaussian IDs in a list, such that they
// are first sorted by tile and then by depth.
for (int y = rect_min.y; y < rect_max.y; y++)
{
for (int x = rect_min.x; x < rect_max.x; x++)
{
uint64_t key = y * grid.x + x;
key <<= 32;
key |= *((uint32_t*)&depths[idx]);
gaussian_keys_unsorted[off] = key;
gaussian_values_unsorted[off] = idx;
off++;
}
}
}
}
// Check keys to see if it is at the start/end of one tile's range in
// the full sorted list. If yes, write start/end of this tile.
// Run once per instanced (duplicated) Gaussian ID.
__global__ void identifyTileRanges(int L, uint64_t* point_list_keys, uint2* ranges)
{
auto idx = cg::this_grid().thread_rank();
if (idx >= L)
return;
// Read tile ID from key. Update start/end of tile range if at limit.
uint64_t key = point_list_keys[idx];
uint32_t currtile = key >> 32;
if (idx == 0)
ranges[currtile].x = 0;
else
{
uint32_t prevtile = point_list_keys[idx - 1] >> 32;
if (currtile != prevtile)
{
ranges[prevtile].y = idx;
ranges[currtile].x = idx;
}
}
if (idx == L - 1)
ranges[currtile].y = L;
}
// Mark Gaussians as visible/invisible, based on view frustum testing
void CudaRasterizer::Rasterizer::markVisible(
int P,
float* means3D,
float* viewmatrix,
float* projmatrix,
bool* present)
{
checkFrustum << <(P + 255) / 256, 256 >> > (
P,
means3D,
viewmatrix, projmatrix,
present);
}
CudaRasterizer::GeometryState CudaRasterizer::GeometryState::fromChunk(char*& chunk, size_t P)
{
GeometryState geom;
obtain(chunk, geom.depths, P, 128);
obtain(chunk, geom.clamped, P * 3, 128);
obtain(chunk, geom.internal_radii, P, 128);
obtain(chunk, geom.means2D, P, 128);
obtain(chunk, geom.cov3D, P * 6, 128);
obtain(chunk, geom.conic_opacity, P, 128);
obtain(chunk, geom.rgb, P * 3, 128);
obtain(chunk, geom.tiles_touched, P, 128);
cub::DeviceScan::InclusiveSum(nullptr, geom.scan_size, geom.tiles_touched, geom.tiles_touched, P);
obtain(chunk, geom.scanning_space, geom.scan_size, 128);
obtain(chunk, geom.point_offsets, P, 128);
return geom;
}
CudaRasterizer::ImageState CudaRasterizer::ImageState::fromChunk(char*& chunk, size_t N)
{
ImageState img;
obtain(chunk, img.accum_alpha, N, 128);
obtain(chunk, img.n_contrib, N, 128);
obtain(chunk, img.ranges, N, 128);
return img;
}
CudaRasterizer::BinningState CudaRasterizer::BinningState::fromChunk(char*& chunk, size_t P)
{
BinningState binning;
obtain(chunk, binning.point_list, P, 128);
obtain(chunk, binning.point_list_unsorted, P, 128);
obtain(chunk, binning.point_list_keys, P, 128);
obtain(chunk, binning.point_list_keys_unsorted, P, 128);
cub::DeviceRadixSort::SortPairs(
nullptr, binning.sorting_size,
binning.point_list_keys_unsorted, binning.point_list_keys,
binning.point_list_unsorted, binning.point_list, P);
obtain(chunk, binning.list_sorting_space, binning.sorting_size, 128);
return binning;
}
// Forward rendering procedure for differentiable rasterization
// of Gaussians.
int CudaRasterizer::Rasterizer::forward(
std::function<char* (size_t)> geometryBuffer,
std::function<char* (size_t)> binningBuffer,
std::function<char* (size_t)> imageBuffer,
const int P, int D, int M,
const float* background,
const int width, int height,
const float* means3D,
const float* shs,
const float* colors_precomp,
const float* opacities,
const float* scales,
const float scale_modifier,
const float* rotations,
const float* cov3D_precomp,
const float* viewmatrix,
const float* projmatrix,
const float* cam_pos,
const float tan_fovx, float tan_fovy,
const bool prefiltered,
float* out_color,
float* gs_w,
int* radii,
bool debug)
{
const float focal_y = height / (2.0f * tan_fovy);
const float focal_x = width / (2.0f * tan_fovx);
size_t chunk_size = required<GeometryState>(P);
char* chunkptr = geometryBuffer(chunk_size);
GeometryState geomState = GeometryState::fromChunk(chunkptr, P);
if (radii == nullptr)
{
radii = geomState.internal_radii;
}
dim3 tile_grid((width + BLOCK_X - 1) / BLOCK_X, (height + BLOCK_Y - 1) / BLOCK_Y, 1);
dim3 block(BLOCK_X, BLOCK_Y, 1);
// Dynamically resize image-based auxiliary buffers during training
size_t img_chunk_size = required<ImageState>(width * height);
char* img_chunkptr = imageBuffer(img_chunk_size);
ImageState imgState = ImageState::fromChunk(img_chunkptr, width * height);
if (NUM_CHANNELS != 3 && colors_precomp == nullptr)
{
throw std::runtime_error("For non-RGB, provide precomputed Gaussian colors!");
}
// Run preprocessing per-Gaussian (transformation, bounding, conversion of SHs to RGB)
CHECK_CUDA(FORWARD::preprocess(
P, D, M,
means3D,
(glm::vec3*)scales,
scale_modifier,
(glm::vec4*)rotations,
opacities,
shs,
geomState.clamped,
cov3D_precomp,
colors_precomp,
viewmatrix, projmatrix,
(glm::vec3*)cam_pos,
width, height,
focal_x, focal_y,
tan_fovx, tan_fovy,
radii,
geomState.means2D,
geomState.depths,
geomState.cov3D,
geomState.rgb,
geomState.conic_opacity,
tile_grid,
geomState.tiles_touched,
prefiltered
), debug)
// Compute prefix sum over full list of touched tile counts by Gaussians
// E.g., [2, 3, 0, 2, 1] -> [2, 5, 5, 7, 8]
CHECK_CUDA(cub::DeviceScan::InclusiveSum(geomState.scanning_space, geomState.scan_size, geomState.tiles_touched, geomState.point_offsets, P), debug)
// Retrieve total number of Gaussian instances to launch and resize aux buffers
int num_rendered;
CHECK_CUDA(cudaMemcpy(&num_rendered, geomState.point_offsets + P - 1, sizeof(int), cudaMemcpyDeviceToHost), debug);
size_t binning_chunk_size = required<BinningState>(num_rendered);
char* binning_chunkptr = binningBuffer(binning_chunk_size);
BinningState binningState = BinningState::fromChunk(binning_chunkptr, num_rendered);
// For each instance to be rendered, produce adequate [ tile | depth ] key
// and corresponding dublicated Gaussian indices to be sorted
duplicateWithKeys << <(P + 255) / 256, 256 >> > (
P,
geomState.means2D,
geomState.depths,
geomState.point_offsets,
binningState.point_list_keys_unsorted,
binningState.point_list_unsorted,
radii,
tile_grid)
CHECK_CUDA(, debug)
int bit = getHigherMsb(tile_grid.x * tile_grid.y);
// Sort complete list of (duplicated) Gaussian indices by keys
CHECK_CUDA(cub::DeviceRadixSort::SortPairs(
binningState.list_sorting_space,
binningState.sorting_size,
binningState.point_list_keys_unsorted, binningState.point_list_keys,
binningState.point_list_unsorted, binningState.point_list,
num_rendered, 0, 32 + bit), debug)
CHECK_CUDA(cudaMemset(imgState.ranges, 0, tile_grid.x * tile_grid.y * sizeof(uint2)), debug);
// Identify start and end of per-tile workloads in sorted list
if (num_rendered > 0)
identifyTileRanges << <(num_rendered + 255) / 256, 256 >> > (
num_rendered,
binningState.point_list_keys,
imgState.ranges);
CHECK_CUDA(, debug)
// Let each tile blend its range of Gaussians independently in parallel
const float* feature_ptr = colors_precomp != nullptr ? colors_precomp : geomState.rgb;
CHECK_CUDA(FORWARD::render(
tile_grid, block,
imgState.ranges,
binningState.point_list,
width, height,
geomState.means2D,
feature_ptr,
geomState.conic_opacity,
imgState.accum_alpha,
imgState.n_contrib,
background,
out_color,
gs_w), debug)
return num_rendered;
}
// Produce necessary gradients for optimization, corresponding
// to forward render pass
void CudaRasterizer::Rasterizer::backward(
const int P, int D, int M, int R,
const float* background,
const int width, int height,
const float* means3D,
const float* shs,
const float* colors_precomp,
const float* scales,
const float scale_modifier,
const float* rotations,
const float* cov3D_precomp,
const float* viewmatrix,
const float* projmatrix,
const float* campos,
const float tan_fovx, float tan_fovy,
const int* radii,
char* geom_buffer,
char* binning_buffer,
char* img_buffer,
const float* dL_dpix,
float* dL_dmean2D,
float* dL_dconic,
float* dL_dopacity,
float* dL_dcolor,
float* dL_dmean3D,
float* dL_dcov3D,
float* dL_dsh,
float* dL_dscale,
float* dL_drot,
bool debug)
{
GeometryState geomState = GeometryState::fromChunk(geom_buffer, P);
BinningState binningState = BinningState::fromChunk(binning_buffer, R);
ImageState imgState = ImageState::fromChunk(img_buffer, width * height);
if (radii == nullptr)
{
radii = geomState.internal_radii;
}
const float focal_y = height / (2.0f * tan_fovy);
const float focal_x = width / (2.0f * tan_fovx);
const dim3 tile_grid((width + BLOCK_X - 1) / BLOCK_X, (height + BLOCK_Y - 1) / BLOCK_Y, 1);
const dim3 block(BLOCK_X, BLOCK_Y, 1);
// Compute loss gradients w.r.t. 2D mean position, conic matrix,
// opacity and RGB of Gaussians from per-pixel loss gradients.
// If we were given precomputed colors and not SHs, use them.
const float* color_ptr = (colors_precomp != nullptr) ? colors_precomp : geomState.rgb;
CHECK_CUDA(BACKWARD::render(
tile_grid,
block,
imgState.ranges,
binningState.point_list,
width, height,
background,
geomState.means2D,
geomState.conic_opacity,
color_ptr,
imgState.accum_alpha,
imgState.n_contrib,
dL_dpix,
(float4*)dL_dmean2D,
(float4*)dL_dconic,
dL_dopacity,
dL_dcolor), debug)
// Take care of the rest of preprocessing. Was the precomputed covariance
// given to us or a scales/rot pair? If precomputed, pass that. If not,
// use the one we computed ourselves.
const float* cov3D_ptr = (cov3D_precomp != nullptr) ? cov3D_precomp : geomState.cov3D;
CHECK_CUDA(BACKWARD::preprocess(P, D, M,
(float3*)means3D,
radii,
shs,
geomState.clamped,
(glm::vec3*)scales,
(glm::vec4*)rotations,
scale_modifier,
cov3D_ptr,
viewmatrix,
projmatrix,
focal_x, focal_y,
tan_fovx, tan_fovy,
(glm::vec3*)campos,
(float4*)dL_dmean2D,
dL_dconic,
(glm::vec3*)dL_dmean3D,
dL_dcolor,
dL_dcov3D,
dL_dsh,
(glm::vec3*)dL_dscale,
(glm::vec4*)dL_drot), debug)
}
================================================
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/rasterizer_impl.h
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#pragma once
#include <iostream>
#include <vector>
#include "rasterizer.h"
#include <cuda_runtime_api.h>
namespace CudaRasterizer
{
template <typename T>
static void obtain(char*& chunk, T*& ptr, std::size_t count, std::size_t alignment)
{
std::size_t offset = (reinterpret_cast<std::uintptr_t>(chunk) + alignment - 1) & ~(alignment - 1);
ptr = reinterpret_cast<T*>(offset);
chunk = reinterpret_cast<char*>(ptr + count);
}
struct GeometryState
{
size_t scan_size;
float* depths;
char* scanning_space;
bool* clamped;
int* internal_radii;
float2* means2D;
float* cov3D;
float4* conic_opacity;
float* rgb;
uint32_t* point_offsets;
uint32_t* tiles_touched;
static GeometryState fromChunk(char*& chunk, size_t P);
};
struct ImageState
{
uint2* ranges;
uint32_t* n_contrib;
float* accum_alpha;
static ImageState fromChunk(char*& chunk, size_t N);
};
struct BinningState
{
size_t sorting_size;
uint64_t* point_list_keys_unsorted;
uint64_t* point_list_keys;
uint32_t* point_list_unsorted;
uint32_t* point_list;
char* list_sorting_space;
static BinningState fromChunk(char*& chunk, size_t P);
};
template<typename T>
size_t required(size_t P)
{
char* size = nullptr;
T::fromChunk(size, P);
return ((size_t)size) + 128;
}
};
================================================
FILE: submodules/diff-gaussian-rasterization-abs/diff_gaussian_rasterization_abs/__init__.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
from typing import NamedTuple
import torch.nn as nn
import torch
from . import _C
def cpu_deep_copy_tuple(input_tuple):
copied_tensors = [item.cpu().clone() if isinstance(item, torch.Tensor) else item for item in input_tuple]
return tuple(copied_tensors)
def rasterize_gaussians(
means3D,
means2D,
sh,
colors_precomp,
opacities,
scales,
rotations,
cov3Ds_precomp,
raster_settings,
):
return _RasterizeGaussians.apply(
means3D,
means2D,
sh,
colors_precomp,
opacities,
scales,
rotations,
cov3Ds_precomp,
raster_settings,
)
class _RasterizeGaussians(torch.autograd.Function):
@staticmethod
def forward(
ctx,
means3D,
means2D,
sh,
colors_precomp,
opacities,
scales,
rotations,
cov3Ds_precomp,
raster_settings,
):
# Restructure arguments the way that the C++ lib expects them
args = (
raster_settings.bg,
means3D,
colors_precomp,
opacities,
scales,
rotations,
raster_settings.scale_modifier,
cov3Ds_precomp,
raster_settings.viewmatrix,
raster_settings.projmatrix,
raster_settings.tanfovx,
raster_settings.tanfovy,
raster_settings.image_height,
raster_settings.image_width,
sh,
raster_settings.sh_degree,
raster_settings.campos,
raster_settings.prefiltered,
raster_settings.debug
)
# Invoke C++/CUDA rasterizer
if raster_settings.debug:
cpu_args = cpu_deep_copy_tuple(args) # Copy them before they can be corrupted
try:
num_rendered, color, radii, geomBuffer, binningBuffer, imgBuffer, gs_w = _C.rasterize_gaussians(*args)
except Exception as ex:
torch.save(cpu_args, "snapshot_fw.dump")
print("\nAn error occured in forward. Please forward snapshot_fw.dump for debugging.")
raise ex
else:
num_rendered, color, radii, geomBuffer, binningBuffer, imgBuffer, gs_w = _C.rasterize_gaussians(*args)
# Keep relevant tensors for backward
ctx.raster_settings = raster_settings
ctx.num_rendered = num_rendered
ctx.save_for_backward(colors_precomp, means3D, scales, rotations, cov3Ds_precomp, radii, sh, geomBuffer, binningBuffer, imgBuffer)
return color, radii, gs_w
@staticmethod
def backward(ctx, grad_out_color, grad_radii, grad_gs_w):
# Restore necessary values from context
num_rendered = ctx.num_rendered
raster_settings = ctx.raster_settings
colors_precomp, means3D, scales, rotations, cov3Ds_precomp, radii, sh, geomBuffer, binningBuffer, imgBuffer = ctx.saved_tensors
# Restructure args as C++ method expects them
args = (raster_settings.bg,
means3D,
radii,
colors_precomp,
scales,
rotations,
raster_settings.scale_modifier,
cov3Ds_precomp,
raster_settings.viewmatrix,
raster_settings.projmatrix,
raster_settings.tanfovx,
raster_settings.tanfovy,
grad_out_color,
sh,
raster_settings.sh_degree,
raster_settings.campos,
geomBuffer,
num_rendered,
binningBuffer,
imgBuffer,
raster_settings.debug)
# Compute gradients for relevant tensors by invoking backward method
if raster_settings.debug:
cpu_args = cpu_deep_copy_tuple(args) # Copy them before they can be corrupted
try:
grad_means2D, grad_colors_precomp, grad_opacities, grad_means3D, grad_cov3Ds_precomp, grad_sh, grad_scales, grad_rotations = _C.rasterize_gaussians_backward(*args)
except Exception as ex:
torch.save(cpu_args, "snapshot_bw.dump")
print("\nAn error occured in backward. Writing snapshot_bw.dump for debugging.\n")
raise ex
else:
grad_means2D, grad_colors_precomp, grad_opacities, grad_means3D, grad_cov3Ds_precomp, grad_sh, grad_scales, grad_rotations = _C.rasterize_gaussians_backward(*args)
grads = (
grad_means3D,
grad_means2D,
grad_sh,
grad_colors_precomp,
grad_opacities,
grad_scales,
grad_rotations,
grad_cov3Ds_precomp,
None,
)
return grads
class GaussianRasterizationSettings(NamedTuple):
image_height: int
image_width: int
tanfovx : float
tanfovy : float
bg : torch.Tensor
scale_modifier : float
viewmatrix : torch.Tensor
projmatrix : torch.Tensor
sh_degree : int
campos : torch.Tensor
prefiltered : bool
debug : bool
class GaussianRasterizer(nn.Module):
def __init__(self, raster_settings):
super().__init__()
self.raster_settings = raster_settings
def markVisible(self, positions):
# Mark visible points (based on frustum culling for camera) with a boolean
with torch.no_grad():
raster_settings = self.raster_settings
visible = _C.mark_visible(
positions,
raster_settings.viewmatrix,
raster_settings.projmatrix)
return visible
def forward(self, means3D, means2D, opacities, shs = None, colors_precomp = None, scales = None, rotations = None, cov3D_precomp = None):
raster_settings = self.raster_settings
if (shs is None and colors_precomp is None) or (shs is not None and colors_precomp is not None):
raise Exception('Please provide excatly one of either SHs or precomputed colors!')
if ((scales is None or rotations is None) and cov3D_precomp is None) or ((scales is not None or rotations is not None) and cov3D_precomp is not None):
raise Exception('Please provide exactly one of either scale/rotation pair or precomputed 3D covariance!')
if shs is None:
shs = torch.Tensor([])
if colors_precomp is None:
colors_precomp = torch.Tensor([])
if scales is None:
scales = torch.Tensor([])
if rotations is None:
rotations = torch.Tensor([])
if cov3D_precomp is None:
cov3D_precomp = torch.Tensor([])
# Invoke C++/CUDA rasterization routine
return rasterize_gaussians(
means3D,
means2D,
shs,
colors_precomp,
opacities,
scales,
rotations,
cov3D_precomp,
raster_settings,
)
================================================
FILE: submodules/diff-gaussian-rasterization-abs/ext.cpp
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#include <torch/extension.h>
#include "rasterize_points.h"
PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
m.def("rasterize_gaussians", &RasterizeGaussiansCUDA);
m.def("rasterize_gaussians_backward", &RasterizeGaussiansBackwardCUDA);
m.def("mark_visible", &markVisible);
}
================================================
FILE: submodules/diff-gaussian-rasterization-abs/rasterize_points.cu
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#include <math.h>
#include <torch/extension.h>
#include <cstdio>
#include <sstream>
#include <iostream>
#include <tuple>
#include <stdio.h>
#include <cuda_runtime_api.h>
#include <memory>
#include "cuda_rasterizer/config.h"
#include "cuda_rasterizer/rasterizer.h"
#include <fstream>
#include <string>
#include <functional>
std::function<char*(size_t N)> resizeFunctional(torch::Tensor& t) {
auto lambda = [&t](size_t N) {
t.resize_({(long long)N});
return reinterpret_cast<char*>(t.contiguous().data_ptr());
};
return lambda;
}
std::tuple<int, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
RasterizeGaussiansCUDA(
const torch::Tensor& background,
const torch::Tensor& means3D,
const torch::Tensor& colors,
const torch::Tensor& opacity,
const torch::Tensor& scales,
const torch::Tensor& rotations,
const float scale_modifier,
const torch::Tensor& cov3D_precomp,
const torch::Tensor& viewmatrix,
const torch::Tensor& projmatrix,
const float tan_fovx,
const float tan_fovy,
const int image_height,
const int image_width,
const torch::Tensor& sh,
const int degree,
const torch::Tensor& campos,
const bool prefiltered,
const bool debug)
{
if (means3D.ndimension() != 2 || means3D.size(1) != 3) {
AT_ERROR("means3D must have dimensions (num_points, 3)");
}
const int P = means3D.size(0);
const int H = image_height;
const int W = image_width;
auto int_opts = means3D.options().dtype(torch::kInt32);
auto float_opts = means3D.options().dtype(torch::kFloat32);
torch::Tensor out_color = torch::full({NUM_CHANNELS, H, W}, 0.0, float_opts);
torch::Tensor radii = torch::full({P}, 0, means3D.options().dtype(torch::kInt32));
torch::Tensor gs_w = torch::full({P}, 0.0, means3D.options());
torch::Device device(torch::kCUDA);
torch::TensorOptions options(torch::kByte);
torch::Tensor geomBuffer = torch::empty({0}, options.device(device));
torch::Tensor binningBuffer = torch::empty({0}, options.device(device));
torch::Tensor imgBuffer = torch::empty({0}, options.device(device));
std::function<char*(size_t)> geomFunc = resizeFunctional(geomBuffer);
std::function<char*(size_t)> binningFunc = resizeFunctional(binningBuffer);
std::function<char*(size_t)> imgFunc = resizeFunctional(imgBuffer);
int rendered = 0;
if(P != 0)
{
int M = 0;
if(sh.size(0) != 0)
{
M = sh.size(1);
}
rendered = CudaRasterizer::Rasterizer::forward(
geomFunc,
binningFunc,
imgFunc,
P, degree, M,
background.contiguous().data<float>(),
W, H,
means3D.contiguous().data<float>(),
sh.contiguous().data_ptr<float>(),
colors.contiguous().data<float>(),
opacity.contiguous().data<float>(),
scales.contiguous().data_ptr<float>(),
scale_modifier,
rotations.contiguous().data_ptr<float>(),
cov3D_precomp.contiguous().data<float>(),
viewmatrix.contiguous().data<float>(),
projmatrix.contiguous().data<float>(),
campos.contiguous().data<float>(),
tan_fovx,
tan_fovy,
prefiltered,
out_color.contiguous().data<float>(),
gs_w.contiguous().data<float>(),
radii.contiguous().data<int>(),
debug);
}
return std::make_tuple(rendered, out_color, radii, geomBuffer, binningBuffer, imgBuffer, gs_w);
}
std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
RasterizeGaussiansBackwardCUDA(
const torch::Tensor& background,
const torch::Tensor& means3D,
const torch::Tensor& radii,
const torch::Tensor& colors,
const torch::Tensor& scales,
const torch::Tensor& rotations,
const float scale_modifier,
const torch::Tensor& cov3D_precomp,
const torch::Tensor& viewmatrix,
const torch::Tensor& projmatrix,
const float tan_fovx,
const float tan_fovy,
const torch::Tensor& dL_dout_color,
const torch::Tensor& sh,
const int degree,
const torch::Tensor& campos,
const torch::Tensor& geomBuffer,
const int R,
const torch::Tensor& binningBuffer,
const torch::Tensor& imageBuffer,
const bool debug)
{
const int P = means3D.size(0);
const int H = dL_dout_color.size(1);
const int W = dL_dout_color.size(2);
int M = 0;
if(sh.size(0) != 0)
{
M = sh.size(1);
}
torch::Tensor dL_dmeans3D = torch::zeros({P, 3}, means3D.options());
torch::Tensor dL_dmeans2D = torch::zeros({P, 4}, means3D.options());
torch::Tensor dL_dcolors = torch::zeros({P, NUM_CHANNELS}, means3D.options());
torch::Tensor dL_dconic = torch::zeros({P, 2, 2}, means3D.options());
torch::Tensor dL_dopacity = torch::zeros({P, 1}, means3D.options());
torch::Tensor dL_dcov3D = torch::zeros({P, 6}, means3D.options());
torch::Tensor dL_dsh = torch::zeros({P, M, 3}, means3D.options());
torch::Tensor dL_dscales = torch::zeros({P, 3}, means3D.options());
torch::Tensor dL_drotations = torch::zeros({P, 4}, means3D.options());
if(P != 0)
{
CudaRasterizer::Rasterizer::backward(P, degree, M, R,
background.contiguous().data<float>(),
W, H,
means3D.contiguous().data<float>(),
sh.contiguous().data<float>(),
colors.contiguous().data<float>(),
scales.data_ptr<float>(),
scale_modifier,
rotations.data_ptr<float>(),
cov3D_precomp.contiguous().data<float>(),
viewmatrix.contiguous().data<float>(),
projmatrix.contiguous().data<float>(),
campos.contiguous().data<float>(),
tan_fovx,
tan_fovy,
radii.contiguous().data<int>(),
reinterpret_cast<char*>(geomBuffer.contiguous().data_ptr()),
reinterpret_cast<char*>(binningBuffer.contiguous().data_ptr()),
reinterpret_cast<char*>(imageBuffer.contiguous().data_ptr()),
dL_dout_color.contiguous().data<float>(),
dL_dmeans2D.contiguous().data<float>(),
dL_dconic.contiguous().data<float>(),
dL_dopacity.contiguous().data<float>(),
dL_dcolors.contiguous().data<float>(),
dL_dmeans3D.contiguous().data<float>(),
dL_dcov3D.contiguous().data<float>(),
dL_dsh.contiguous().data<float>(),
dL_dscales.contiguous().data<float>(),
dL_drotations.contiguous().data<float>(),
debug);
}
return std::make_tuple(dL_dmeans2D, dL_dcolors, dL_dopacity, dL_dmeans3D, dL_dcov3D, dL_dsh, dL_dscales, dL_drotations);
}
torch::Tensor markVisible(
torch::Tensor& means3D,
torch::Tensor& viewmatrix,
torch::Tensor& projmatrix)
{
const int P = means3D.size(0);
torch::Tensor present = torch::full({P}, false, means3D.options().dtype(at::kBool));
if(P != 0)
{
CudaRasterizer::Rasterizer::markVisible(P,
means3D.contiguous().data<float>(),
viewmatrix.contiguous().data<float>(),
projmatrix.contiguous().data<float>(),
present.contiguous().data<bool>());
}
return present;
}
================================================
FILE: submodules/diff-gaussian-rasterization-abs/rasterize_points.h
================================================
/*
* Copyright (C) 2023, Inria
* GRAPHDECO research group, https://team.inria.fr/graphdeco
* All rights reserved.
*
* This software is free for non-commercial, research and evaluation use
* under the terms of the LICENSE.md file.
*
* For inquiries contact george.drettakis@inria.fr
*/
#pragma once
#include <torch/extension.h>
#include <cstdio>
#include <tuple>
#include <string>
std::tuple<int, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
RasterizeGaussiansCUDA(
const torch::Tensor& background,
const torch::Tensor& means3D,
const torch::Tensor& colors,
const torch::Tensor& opacity,
const torch::Tensor& scales,
const torch::Tensor& rotations,
const float scale_modifier,
const torch::Tensor& cov3D_precomp,
const torch::Tensor& viewmatrix,
const torch::Tensor& projmatrix,
const float tan_fovx,
const float tan_fovy,
const int image_height,
const int image_width,
const torch::Tensor& sh,
const int degree,
const torch::Tensor& campos,
const bool prefiltered,
const bool debug);
std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
RasterizeGaussiansBackwardCUDA(
const torch::Tensor& background,
const torch::Tensor& means3D,
const torch::Tensor& radii,
const torch::Tensor& colors,
const torch::Tensor& scales,
const torch::Tensor& rotations,
const float scale_modifier,
const torch::Tensor& cov3D_precomp,
const torch::Tensor& viewmatrix,
const torch::Tensor& projmatrix,
const float tan_fovx,
const float tan_fovy,
const torch::Tensor& dL_dout_color,
const torch::Tensor& sh,
const int degree,
const torch::Tensor& campos,
const torch::Tensor& geomBuffer,
const int R,
const torch::Tensor& binningBuffer,
const torch::Tensor& imageBuffer,
const bool debug);
torch::Tensor markVisible(
torch::Tensor& means3D,
torch::Tensor& viewmatrix,
torch::Tensor& projmatrix);
================================================
FILE: submodules/diff-gaussian-rasterization-abs/setup.py
================================================
#
# Copyright (C) 2023, Inria
# GRAPHDECO research group, https://team.inria.fr/graphdeco
# All rights reserved.
#
# This software is free for non-commercial, research and evaluation use
# under the terms of the LICENSE.md file.
#
# For inquiries contact george.drettakis@inria.fr
#
from setuptools import setup
from torch.utils.cpp_extension import CUDAExtension, BuildExtension
import os
os.path.dirname(os.path.abspath(__file__))
setup(
name="diff_gaussian_rasterization_abs",
packages=['diff_gaussian_rasterization_abs'],
ext_modules=[
CUDAExtension(
name="diff_gaussian_rasterization_abs._C",
sources=[
"cuda_rasterizer/rasterizer_impl.cu",
"cuda_rasterizer/forward.cu",
"cuda_rasterizer/backward.cu",
"rasterize_points.cu",
"ext.cpp"],
extra_compile_args={"nvcc": ["-I" + os.path.join(os.path.dirname(os.path.abspath(__file__)), "third_party/glm/")]})
],
cmdclass={
'build_ext': BuildExtension
}
)
================================================
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/.appveyor.yml
================================================
shallow_clone: true
platform:
- x86
- x64
configuration:
- Debug
- Release
image:
- Visual Studio 2013
- Visual Studio 2015
- Visual Studio 2017
- Visual Studio 2019
environment:
matrix:
- GLM_ARGUMENTS: -DGLM_TEST_FORCE_PURE=ON
- GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_14=ON
- GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_17=ON
matrix:
exclude:
- image: Visual Studio 2013
GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- image: Visual Studio 2013
GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_14=ON
- image: Visual Studio 2013
GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_17=ON
- image: Visual Studio 2013
configuration: Debug
- image: Visual Studio 2015
GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- image: Visual Studio 2015
GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_14=ON
- image: Visual Studio 2015
GLM_ARGUMENTS: -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_CXX_17=ON
- image: Visual Studio 2015
platform: x86
- image: Visual Studio 2015
configuration: Debug
- image: Visual Studio 2017
platform: x86
- image: Visual Studio 2017
configuration: Debug
- image: Visual Studio 2019
platform: x64
branches:
only:
- master
before_build:
- ps: |
mkdir build
cd build
if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2013") {
$env:generator="Visual Studio 12 2013"
}
if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2015") {
$env:generator="Visual Studio 14 2015"
}
if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2017") {
$env:generator="Visual Studio 15 2017"
}
if ("$env:APPVEYOR_JOB_NAME" -match "Image: Visual Studio 2019") {
$env:generator="Visual Studio 16 2019"
}
if ($env:PLATFORM -eq "x64") {
$env:generator="$env:generator Win64"
}
echo generator="$env:generator"
cmake .. -G "$env:generator" -DCMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER/install" -DGLM_QUIET=ON -DGLM_TEST_ENABLE=ON "$env:GLM_ARGUMENTS"
build_script:
- cmake --build . --parallel --config %CONFIGURATION% -- /m /v:minimal
- cmake --build . --target install --parallel --config %CONFIGURATION% -- /m /v:minimal
test_script:
- ctest --parallel 4 --verbose -C %CONFIGURATION%
- cd ..
- ps: |
mkdir build_test_cmake
cd build_test_cmake
cmake ..\test\cmake\ -G "$env:generator" -DCMAKE_PREFIX_PATH="$env:APPVEYOR_BUILD_FOLDER/install"
- cmake --build . --parallel --config %CONFIGURATION% -- /m /v:minimal
deploy: off
================================================
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/.gitignore
================================================
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
# CMake
CMakeCache.txt
CMakeFiles
cmake_install.cmake
install_manifest.txt
*.cmake
!glmConfig.cmake
!glmConfig-version.cmake
# ^ May need to add future .cmake files as exceptions
# Test logs
Testing/*
# Test input
test/gtc/*.dds
# Project Files
Makefile
*.cbp
*.user
# Misc.
*.log
# local build(s)
build*
/.vs
/.vscode
/CMakeSettings.json
.DS_Store
*.swp
================================================
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/.travis.yml
================================================
language: cpp
branches:
only:
- master
- stable
jobs:
include:
- name: "Xcode 7.3 C++98 pure release"
os: osx
osx_image: xcode7.3
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_FORCE_PURE=ON"
- name: "Xcode 7.3 C++98 sse2 release"
os: osx
osx_image: xcode7.3
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE2=ON"
- name: "Xcode 7.3 C++98 ms release"
os: osx
osx_image: xcode7.3
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON"
- name: "XCode 7.3 C++11 pure release"
os: osx
osx_image: xcode7.3
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_FORCE_PURE=ON"
- name: "XCode 7.3 C++11 sse2 release"
os: osx
osx_image: xcode7.3
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE3=ON"
- name: "XCode 10.3 C++11 sse2 release"
os: osx
osx_image: xcode10.3
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE3=ON"
- name: "XCode 12.2 C++11 sse2 release"
os: osx
osx_image: xcode12.2
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Release -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE3=ON"
- CTEST_ENV="--parallel 4 --output-on-failure"
- CMAKE_ENV="--parallel"
- name: "XCode 12.2 C++11 sse2 debug"
os: osx
osx_image: xcode12.2
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_SSE3=ON"
- CTEST_ENV="--parallel 4 --output-on-failure"
- CMAKE_ENV="--parallel"
- name: "XCode 12.2 C++11 avx debug"
os: osx
osx_image: xcode12.2
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_AVX=ON"
- CTEST_ENV="--parallel 4 --output-on-failure"
- CMAKE_ENV="--parallel"
- name: "XCode 12.2 C++14 avx debug"
os: osx
osx_image: xcode12.2
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_ENABLE_SIMD_AVX=ON"
- CTEST_ENV="--parallel 4 --output-on-failure"
- CMAKE_ENV="--parallel"
- name: "XCode 12.2 C++14 pure debug"
os: osx
osx_image: xcode12.2
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_14=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON -DGLM_TEST_FORCE_PURE=ON"
- CTEST_ENV="--parallel 4 --output-on-failure"
- CMAKE_ENV="--parallel"
- name: "XCode 12.2 C++17 pure debug"
os: osx
osx_image: xcode12.2
env:
- MATRIX_EVAL=""
- CMAKE_BUILD_ENV="-DCMAKE_BUILD_TYPE=Debug -DGLM_TEST_ENABLE=ON -DGLM_TEST_ENABLE_CXX_17=ON -DGLM_TEST_E
gitextract_iv7jw_c9/
├── .gitignore
├── .gitmodules
├── LICENSE.md
├── README.md
├── arguments/
│ └── __init__.py
├── convert.py
├── environment.yml
├── full_eval.py
├── gaussian_renderer/
│ ├── __init__.py
│ └── network_gui.py
├── lpipsPyTorch/
│ ├── __init__.py
│ └── modules/
│ ├── lpips.py
│ ├── networks.py
│ └── utils.py
├── metrics.py
├── render.py
├── scene/
│ ├── __init__.py
│ ├── cameras.py
│ ├── colmap_loader.py
│ ├── dataset_readers.py
│ └── gaussian_model.py
├── submodules/
│ ├── diff-gaussian-rasterization-abs/
│ │ ├── .gitignore
│ │ ├── .gitmodules
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── cuda_rasterizer/
│ │ │ ├── auxiliary.h
│ │ │ ├── backward.cu
│ │ │ ├── backward.h
│ │ │ ├── config.h
│ │ │ ├── forward.cu
│ │ │ ├── forward.h
│ │ │ ├── rasterizer.h
│ │ │ ├── rasterizer_impl.cu
│ │ │ └── rasterizer_impl.h
│ │ ├── diff_gaussian_rasterization_abs/
│ │ │ └── __init__.py
│ │ ├── ext.cpp
│ │ ├── rasterize_points.cu
│ │ ├── rasterize_points.h
│ │ ├── setup.py
│ │ └── third_party/
│ │ ├── glm/
│ │ │ ├── .appveyor.yml
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── CMakeLists.txt
│ │ │ ├── cmake/
│ │ │ │ └── cmake_uninstall.cmake.in
│ │ │ ├── copying.txt
│ │ │ ├── doc/
│ │ │ │ ├── api/
│ │ │ │ │ ├── a00001_source.html
│ │ │ │ │ ├── a00002_source.html
│ │ │ │ │ ├── a00003_source.html
│ │ │ │ │ ├── a00004_source.html
│ │ │ │ │ ├── a00005_source.html
│ │ │ │ │ ├── a00006_source.html
│ │ │ │ │ ├── a00007.html
│ │ │ │ │ ├── a00007_source.html
│ │ │ │ │ ├── a00008.html
│ │ │ │ │ ├── a00008_source.html
│ │ │ │ │ ├── a00009.html
│ │ │ │ │ ├── a00009_source.html
│ │ │ │ │ ├── a00010.html
│ │ │ │ │ ├── a00010_source.html
│ │ │ │ │ ├── a00011.html
│ │ │ │ │ ├── a00011_source.html
│ │ │ │ │ ├── a00012.html
│ │ │ │ │ ├── a00012_source.html
│ │ │ │ │ ├── a00013.html
│ │ │ │ │ ├── a00013_source.html
│ │ │ │ │ ├── a00014.html
│ │ │ │ │ ├── a00014_source.html
│ │ │ │ │ ├── a00015.html
│ │ │ │ │ ├── a00015_source.html
│ │ │ │ │ ├── a00016.html
│ │ │ │ │ ├── a00016_source.html
│ │ │ │ │ ├── a00017.html
│ │ │ │ │ ├── a00017_source.html
│ │ │ │ │ ├── a00018.html
│ │ │ │ │ ├── a00018_source.html
│ │ │ │ │ ├── a00019_source.html
│ │ │ │ │ ├── a00020_source.html
│ │ │ │ │ ├── a00021.html
│ │ │ │ │ ├── a00021_source.html
│ │ │ │ │ ├── a00022.html
│ │ │ │ │ ├── a00022_source.html
│ │ │ │ │ ├── a00023.html
│ │ │ │ │ ├── a00023_source.html
│ │ │ │ │ ├── a00024.html
│ │ │ │ │ ├── a00024_source.html
│ │ │ │ │ ├── a00025.html
│ │ │ │ │ ├── a00025_source.html
│ │ │ │ │ ├── a00026.html
│ │ │ │ │ ├── a00026_source.html
│ │ │ │ │ ├── a00027.html
│ │ │ │ │ ├── a00027_source.html
│ │ │ │ │ ├── a00028.html
│ │ │ │ │ ├── a00028_source.html
│ │ │ │ │ ├── a00029.html
│ │ │ │ │ ├── a00029_source.html
│ │ │ │ │ ├── a00030.html
│ │ │ │ │ ├── a00030_source.html
│ │ │ │ │ ├── a00031.html
│ │ │ │ │ ├── a00031_source.html
│ │ │ │ │ ├── a00032.html
│ │ │ │ │ ├── a00032_source.html
│ │ │ │ │ ├── a00033.html
│ │ │ │ │ ├── a00033_source.html
│ │ │ │ │ ├── a00034.html
│ │ │ │ │ ├── a00034_source.html
│ │ │ │ │ ├── a00035_source.html
│ │ │ │ │ ├── a00036.html
│ │ │ │ │ ├── a00036_source.html
│ │ │ │ │ ├── a00037.html
│ │ │ │ │ ├── a00037_source.html
│ │ │ │ │ ├── a00038.html
│ │ │ │ │ ├── a00038_source.html
│ │ │ │ │ ├── a00039.html
│ │ │ │ │ ├── a00039_source.html
│ │ │ │ │ ├── a00040.html
│ │ │ │ │ ├── a00040_source.html
│ │ │ │ │ ├── a00041.html
│ │ │ │ │ ├── a00041_source.html
│ │ │ │ │ ├── a00042.html
│ │ │ │ │ ├── a00042_source.html
│ │ │ │ │ ├── a00043.html
│ │ │ │ │ ├── a00043_source.html
│ │ │ │ │ ├── a00044.html
│ │ │ │ │ ├── a00044_source.html
│ │ │ │ │ ├── a00045.html
│ │ │ │ │ ├── a00045_source.html
│ │ │ │ │ ├── a00046.html
│ │ │ │ │ ├── a00046_source.html
│ │ │ │ │ ├── a00047_source.html
│ │ │ │ │ ├── a00048.html
│ │ │ │ │ ├── a00048_source.html
│ │ │ │ │ ├── a00049.html
│ │ │ │ │ ├── a00049_source.html
│ │ │ │ │ ├── a00050.html
│ │ │ │ │ ├── a00050_source.html
│ │ │ │ │ ├── a00051.html
│ │ │ │ │ ├── a00051_source.html
│ │ │ │ │ ├── a00052.html
│ │ │ │ │ ├── a00052_source.html
│ │ │ │ │ ├── a00053.html
│ │ │ │ │ ├── a00053_source.html
│ │ │ │ │ ├── a00054.html
│ │ │ │ │ ├── a00054_source.html
│ │ │ │ │ ├── a00055.html
│ │ │ │ │ ├── a00055_source.html
│ │ │ │ │ ├── a00056.html
│ │ │ │ │ ├── a00056_source.html
│ │ │ │ │ ├── a00057.html
│ │ │ │ │ ├── a00057_source.html
│ │ │ │ │ ├── a00058.html
│ │ │ │ │ ├── a00058_source.html
│ │ │ │ │ ├── a00059.html
│ │ │ │ │ ├── a00059_source.html
│ │ │ │ │ ├── a00060.html
│ │ │ │ │ ├── a00060_source.html
│ │ │ │ │ ├── a00061.html
│ │ │ │ │ ├── a00061_source.html
│ │ │ │ │ ├── a00062.html
│ │ │ │ │ ├── a00062_source.html
│ │ │ │ │ ├── a00063.html
│ │ │ │ │ ├── a00063_source.html
│ │ │ │ │ ├── a00064.html
│ │ │ │ │ ├── a00064_source.html
│ │ │ │ │ ├── a00065.html
│ │ │ │ │ ├── a00065_source.html
│ │ │ │ │ ├── a00066.html
│ │ │ │ │ ├── a00066_source.html
│ │ │ │ │ ├── a00067.html
│ │ │ │ │ ├── a00067_source.html
│ │ │ │ │ ├── a00068.html
│ │ │ │ │ ├── a00068_source.html
│ │ │ │ │ ├── a00069.html
│ │ │ │ │ ├── a00069_source.html
│ │ │ │ │ ├── a00070.html
│ │ │ │ │ ├── a00070_source.html
│ │ │ │ │ ├── a00071.html
│ │ │ │ │ ├── a00071_source.html
│ │ │ │ │ ├── a00072.html
│ │ │ │ │ ├── a00072_source.html
│ │ │ │ │ ├── a00073.html
│ │ │ │ │ ├── a00073_source.html
│ │ │ │ │ ├── a00074.html
│ │ │ │ │ ├── a00074_source.html
│ │ │ │ │ ├── a00075.html
│ │ │ │ │ ├── a00075_source.html
│ │ │ │ │ ├── a00076.html
│ │ │ │ │ ├── a00076_source.html
│ │ │ │ │ ├── a00077.html
│ │ │ │ │ ├── a00077_source.html
│ │ │ │ │ ├── a00078.html
│ │ │ │ │ ├── a00078_source.html
│ │ │ │ │ ├── a00079.html
│ │ │ │ │ ├── a00079_source.html
│ │ │ │ │ ├── a00080.html
│ │ │ │ │ ├── a00080_source.html
│ │ │ │ │ ├── a00081.html
│ │ │ │ │ ├── a00081_source.html
│ │ │ │ │ ├── a00082.html
│ │ │ │ │ ├── a00082_source.html
│ │ │ │ │ ├── a00083.html
│ │ │ │ │ ├── a00083_source.html
│ │ │ │ │ ├── a00084.html
│ │ │ │ │ ├── a00084_source.html
│ │ │ │ │ ├── a00085.html
│ │ │ │ │ ├── a00085_source.html
│ │ │ │ │ ├── a00086.html
│ │ │ │ │ ├── a00086_source.html
│ │ │ │ │ ├── a00087.html
│ │ │ │ │ ├── a00087_source.html
│ │ │ │ │ ├── a00088.html
│ │ │ │ │ ├── a00088_source.html
│ │ │ │ │ ├── a00089.html
│ │ │ │ │ ├── a00089_source.html
│ │ │ │ │ ├── a00090.html
│ │ │ │ │ ├── a00090_source.html
│ │ │ │ │ ├── a00091.html
│ │ │ │ │ ├── a00091_source.html
│ │ │ │ │ ├── a00092.html
│ │ │ │ │ ├── a00092_source.html
│ │ │ │ │ ├── a00093.html
│ │ │ │ │ ├── a00093_source.html
│ │ │ │ │ ├── a00094.html
│ │ │ │ │ ├── a00094_source.html
│ │ │ │ │ ├── a00095_source.html
│ │ │ │ │ ├── a00096.html
│ │ │ │ │ ├── a00096_source.html
│ │ │ │ │ ├── a00097.html
│ │ │ │ │ ├── a00097_source.html
│ │ │ │ │ ├── a00098.html
│ │ │ │ │ ├── a00098_source.html
│ │ │ │ │ ├── a00099.html
│ │ │ │ │ ├── a00099_source.html
│ │ │ │ │ ├── a00100.html
│ │ │ │ │ ├── a00100_source.html
│ │ │ │ │ ├── a00101.html
│ │ │ │ │ ├── a00101_source.html
│ │ │ │ │ ├── a00102.html
│ │ │ │ │ ├── a00102_source.html
│ │ │ │ │ ├── a00103.html
│ │ │ │ │ ├── a00103_source.html
│ │ │ │ │ ├── a00104.html
│ │ │ │ │ ├── a00104_source.html
│ │ │ │ │ ├── a00105.html
│ │ │ │ │ ├── a00105_source.html
│ │ │ │ │ ├── a00106.html
│ │ │ │ │ ├── a00106_source.html
│ │ │ │ │ ├── a00107.html
│ │ │ │ │ ├── a00107_source.html
│ │ │ │ │ ├── a00108.html
│ │ │ │ │ ├── a00108_source.html
│ │ │ │ │ ├── a00109.html
│ │ │ │ │ ├── a00109_source.html
│ │ │ │ │ ├── a00110.html
│ │ │ │ │ ├── a00110_source.html
│ │ │ │ │ ├── a00111.html
│ │ │ │ │ ├── a00111_source.html
│ │ │ │ │ ├── a00112.html
│ │ │ │ │ ├── a00112_source.html
│ │ │ │ │ ├── a00113.html
│ │ │ │ │ ├── a00113_source.html
│ │ │ │ │ ├── a00114.html
│ │ │ │ │ ├── a00114_source.html
│ │ │ │ │ ├── a00115.html
│ │ │ │ │ ├── a00115_source.html
│ │ │ │ │ ├── a00116.html
│ │ │ │ │ ├── a00116_source.html
│ │ │ │ │ ├── a00117.html
│ │ │ │ │ ├── a00117_source.html
│ │ │ │ │ ├── a00118.html
│ │ │ │ │ ├── a00118_source.html
│ │ │ │ │ ├── a00119.html
│ │ │ │ │ ├── a00119_source.html
│ │ │ │ │ ├── a00120.html
│ │ │ │ │ ├── a00120_source.html
│ │ │ │ │ ├── a00121.html
│ │ │ │ │ ├── a00121_source.html
│ │ │ │ │ ├── a00122.html
│ │ │ │ │ ├── a00122_source.html
│ │ │ │ │ ├── a00123.html
│ │ │ │ │ ├── a00123_source.html
│ │ │ │ │ ├── a00124_source.html
│ │ │ │ │ ├── a00125.html
│ │ │ │ │ ├── a00125_source.html
│ │ │ │ │ ├── a00126.html
│ │ │ │ │ ├── a00126_source.html
│ │ │ │ │ ├── a00127.html
│ │ │ │ │ ├── a00127_source.html
│ │ │ │ │ ├── a00128.html
│ │ │ │ │ ├── a00128_source.html
│ │ │ │ │ ├── a00129.html
│ │ │ │ │ ├── a00129_source.html
│ │ │ │ │ ├── a00130.html
│ │ │ │ │ ├── a00130_source.html
│ │ │ │ │ ├── a00131.html
│ │ │ │ │ ├── a00131_source.html
│ │ │ │ │ ├── a00132.html
│ │ │ │ │ ├── a00132_source.html
│ │ │ │ │ ├── a00133.html
│ │ │ │ │ ├── a00133_source.html
│ │ │ │ │ ├── a00134.html
│ │ │ │ │ ├── a00134_source.html
│ │ │ │ │ ├── a00135.html
│ │ │ │ │ ├── a00135_source.html
│ │ │ │ │ ├── a00136.html
│ │ │ │ │ ├── a00136_source.html
│ │ │ │ │ ├── a00137.html
│ │ │ │ │ ├── a00137_source.html
│ │ │ │ │ ├── a00138.html
│ │ │ │ │ ├── a00138_source.html
│ │ │ │ │ ├── a00139.html
│ │ │ │ │ ├── a00139_source.html
│ │ │ │ │ ├── a00140.html
│ │ │ │ │ ├── a00140_source.html
│ │ │ │ │ ├── a00141.html
│ │ │ │ │ ├── a00141_source.html
│ │ │ │ │ ├── a00142.html
│ │ │ │ │ ├── a00142_source.html
│ │ │ │ │ ├── a00143.html
│ │ │ │ │ ├── a00143_source.html
│ │ │ │ │ ├── a00144.html
│ │ │ │ │ ├── a00144_source.html
│ │ │ │ │ ├── a00145.html
│ │ │ │ │ ├── a00145_source.html
│ │ │ │ │ ├── a00146.html
│ │ │ │ │ ├── a00146_source.html
│ │ │ │ │ ├── a00147.html
│ │ │ │ │ ├── a00147_source.html
│ │ │ │ │ ├── a00148.html
│ │ │ │ │ ├── a00148_source.html
│ │ │ │ │ ├── a00149.html
│ │ │ │ │ ├── a00149_source.html
│ │ │ │ │ ├── a00150.html
│ │ │ │ │ ├── a00150_source.html
│ │ │ │ │ ├── a00151.html
│ │ │ │ │ ├── a00151_source.html
│ │ │ │ │ ├── a00152.html
│ │ │ │ │ ├── a00152_source.html
│ │ │ │ │ ├── a00153_source.html
│ │ │ │ │ ├── a00154.html
│ │ │ │ │ ├── a00154_source.html
│ │ │ │ │ ├── a00155.html
│ │ │ │ │ ├── a00155_source.html
│ │ │ │ │ ├── a00156.html
│ │ │ │ │ ├── a00156_source.html
│ │ │ │ │ ├── a00157.html
│ │ │ │ │ ├── a00157_source.html
│ │ │ │ │ ├── a00158.html
│ │ │ │ │ ├── a00158_source.html
│ │ │ │ │ ├── a00159.html
│ │ │ │ │ ├── a00159_source.html
│ │ │ │ │ ├── a00160.html
│ │ │ │ │ ├── a00160_source.html
│ │ │ │ │ ├── a00161.html
│ │ │ │ │ ├── a00161_source.html
│ │ │ │ │ ├── a00162.html
│ │ │ │ │ ├── a00162_source.html
│ │ │ │ │ ├── a00163_source.html
│ │ │ │ │ ├── a00164_source.html
│ │ │ │ │ ├── a00165.html
│ │ │ │ │ ├── a00165_source.html
│ │ │ │ │ ├── a00166.html
│ │ │ │ │ ├── a00166_source.html
│ │ │ │ │ ├── a00167.html
│ │ │ │ │ ├── a00167_source.html
│ │ │ │ │ ├── a00168.html
│ │ │ │ │ ├── a00168_source.html
│ │ │ │ │ ├── a00169.html
│ │ │ │ │ ├── a00169_source.html
│ │ │ │ │ ├── a00170.html
│ │ │ │ │ ├── a00170_source.html
│ │ │ │ │ ├── a00171.html
│ │ │ │ │ ├── a00171_source.html
│ │ │ │ │ ├── a00172.html
│ │ │ │ │ ├── a00172_source.html
│ │ │ │ │ ├── a00173.html
│ │ │ │ │ ├── a00173_source.html
│ │ │ │ │ ├── a00174.html
│ │ │ │ │ ├── a00174_source.html
│ │ │ │ │ ├── a00175.html
│ │ │ │ │ ├── a00175_source.html
│ │ │ │ │ ├── a00176.html
│ │ │ │ │ ├── a00176_source.html
│ │ │ │ │ ├── a00177.html
│ │ │ │ │ ├── a00177_source.html
│ │ │ │ │ ├── a00178.html
│ │ │ │ │ ├── a00178_source.html
│ │ │ │ │ ├── a00179.html
│ │ │ │ │ ├── a00179_source.html
│ │ │ │ │ ├── a00180.html
│ │ │ │ │ ├── a00180_source.html
│ │ │ │ │ ├── a00181.html
│ │ │ │ │ ├── a00181_source.html
│ │ │ │ │ ├── a00182.html
│ │ │ │ │ ├── a00182_source.html
│ │ │ │ │ ├── a00183.html
│ │ │ │ │ ├── a00183_source.html
│ │ │ │ │ ├── a00184.html
│ │ │ │ │ ├── a00184_source.html
│ │ │ │ │ ├── a00185.html
│ │ │ │ │ ├── a00185_source.html
│ │ │ │ │ ├── a00186.html
│ │ │ │ │ ├── a00186_source.html
│ │ │ │ │ ├── a00187.html
│ │ │ │ │ ├── a00187_source.html
│ │ │ │ │ ├── a00188.html
│ │ │ │ │ ├── a00188_source.html
│ │ │ │ │ ├── a00189.html
│ │ │ │ │ ├── a00189_source.html
│ │ │ │ │ ├── a00190.html
│ │ │ │ │ ├── a00190_source.html
│ │ │ │ │ ├── a00191.html
│ │ │ │ │ ├── a00191_source.html
│ │ │ │ │ ├── a00192.html
│ │ │ │ │ ├── a00192_source.html
│ │ │ │ │ ├── a00193.html
│ │ │ │ │ ├── a00193_source.html
│ │ │ │ │ ├── a00194.html
│ │ │ │ │ ├── a00194_source.html
│ │ │ │ │ ├── a00195.html
│ │ │ │ │ ├── a00195_source.html
│ │ │ │ │ ├── a00196.html
│ │ │ │ │ ├── a00196_source.html
│ │ │ │ │ ├── a00197.html
│ │ │ │ │ ├── a00197_source.html
│ │ │ │ │ ├── a00198.html
│ │ │ │ │ ├── a00198_source.html
│ │ │ │ │ ├── a00199.html
│ │ │ │ │ ├── a00199_source.html
│ │ │ │ │ ├── a00200.html
│ │ │ │ │ ├── a00200_source.html
│ │ │ │ │ ├── a00201.html
│ │ │ │ │ ├── a00201_source.html
│ │ │ │ │ ├── a00202.html
│ │ │ │ │ ├── a00202_source.html
│ │ │ │ │ ├── a00203.html
│ │ │ │ │ ├── a00203_source.html
│ │ │ │ │ ├── a00204.html
│ │ │ │ │ ├── a00204_source.html
│ │ │ │ │ ├── a00205.html
│ │ │ │ │ ├── a00205_source.html
│ │ │ │ │ ├── a00206.html
│ │ │ │ │ ├── a00206_source.html
│ │ │ │ │ ├── a00207.html
│ │ │ │ │ ├── a00207_source.html
│ │ │ │ │ ├── a00208.html
│ │ │ │ │ ├── a00208_source.html
│ │ │ │ │ ├── a00209.html
│ │ │ │ │ ├── a00209_source.html
│ │ │ │ │ ├── a00210.html
│ │ │ │ │ ├── a00210_source.html
│ │ │ │ │ ├── a00211.html
│ │ │ │ │ ├── a00211_source.html
│ │ │ │ │ ├── a00212.html
│ │ │ │ │ ├── a00212_source.html
│ │ │ │ │ ├── a00213.html
│ │ │ │ │ ├── a00213_source.html
│ │ │ │ │ ├── a00214.html
│ │ │ │ │ ├── a00214_source.html
│ │ │ │ │ ├── a00215.html
│ │ │ │ │ ├── a00215_source.html
│ │ │ │ │ ├── a00216.html
│ │ │ │ │ ├── a00216_source.html
│ │ │ │ │ ├── a00217.html
│ │ │ │ │ ├── a00217_source.html
│ │ │ │ │ ├── a00218.html
│ │ │ │ │ ├── a00218_source.html
│ │ │ │ │ ├── a00219.html
│ │ │ │ │ ├── a00219_source.html
│ │ │ │ │ ├── a00220.html
│ │ │ │ │ ├── a00220_source.html
│ │ │ │ │ ├── a00221.html
│ │ │ │ │ ├── a00221_source.html
│ │ │ │ │ ├── a00222.html
│ │ │ │ │ ├── a00222_source.html
│ │ │ │ │ ├── a00223.html
│ │ │ │ │ ├── a00223_source.html
│ │ │ │ │ ├── a00224.html
│ │ │ │ │ ├── a00224_source.html
│ │ │ │ │ ├── a00225.html
│ │ │ │ │ ├── a00225_source.html
│ │ │ │ │ ├── a00226.html
│ │ │ │ │ ├── a00226_source.html
│ │ │ │ │ ├── a00227.html
│ │ │ │ │ ├── a00227_source.html
│ │ │ │ │ ├── a00228.html
│ │ │ │ │ ├── a00228_source.html
│ │ │ │ │ ├── a00229.html
│ │ │ │ │ ├── a00229_source.html
│ │ │ │ │ ├── a00230.html
│ │ │ │ │ ├── a00230_source.html
│ │ │ │ │ ├── a00231.html
│ │ │ │ │ ├── a00231_source.html
│ │ │ │ │ ├── a00232.html
│ │ │ │ │ ├── a00232_source.html
│ │ │ │ │ ├── a00233.html
│ │ │ │ │ ├── a00233_source.html
│ │ │ │ │ ├── a00234.html
│ │ │ │ │ ├── a00234_source.html
│ │ │ │ │ ├── a00235.html
│ │ │ │ │ ├── a00235_source.html
│ │ │ │ │ ├── a00241.html
│ │ │ │ │ ├── a00242.html
│ │ │ │ │ ├── a00243.html
│ │ │ │ │ ├── a00244.html
│ │ │ │ │ ├── a00245.html
│ │ │ │ │ ├── a00246.html
│ │ │ │ │ ├── a00247.html
│ │ │ │ │ ├── a00248.html
│ │ │ │ │ ├── a00249.html
│ │ │ │ │ ├── a00250.html
│ │ │ │ │ ├── a00251.html
│ │ │ │ │ ├── a00252.html
│ │ │ │ │ ├── a00253.html
│ │ │ │ │ ├── a00254.html
│ │ │ │ │ ├── a00255.html
│ │ │ │ │ ├── a00256.html
│ │ │ │ │ ├── a00257.html
│ │ │ │ │ ├── a00258.html
│ │ │ │ │ ├── a00259.html
│ │ │ │ │ ├── a00260.html
│ │ │ │ │ ├── a00261.html
│ │ │ │ │ ├── a00262.html
│ │ │ │ │ ├── a00263.html
│ │ │ │ │ ├── a00264.html
│ │ │ │ │ ├── a00265.html
│ │ │ │ │ ├── a00266.html
│ │ │ │ │ ├── a00267.html
│ │ │ │ │ ├── a00268.html
│ │ │ │ │ ├── a00269.html
│ │ │ │ │ ├── a00270.html
│ │ │ │ │ ├── a00271.html
│ │ │ │ │ ├── a00272.html
│ │ │ │ │ ├── a00273.html
│ │ │ │ │ ├── a00274.html
│ │ │ │ │ ├── a00275.html
│ │ │ │ │ ├── a00276.html
│ │ │ │ │ ├── a00277.html
│ │ │ │ │ ├── a00278.html
│ │ │ │ │ ├── a00279.html
│ │ │ │ │ ├── a00280.html
│ │ │ │ │ ├── a00281.html
│ │ │ │ │ ├── a00282.html
│ │ │ │ │ ├── a00283.html
│ │ │ │ │ ├── a00284.html
│ │ │ │ │ ├── a00285.html
│ │ │ │ │ ├── a00286.html
│ │ │ │ │ ├── a00287.html
│ │ │ │ │ ├── a00288.html
│ │ │ │ │ ├── a00289.html
│ │ │ │ │ ├── a00290.html
│ │ │ │ │ ├── a00291.html
│ │ │ │ │ ├── a00292.html
│ │ │ │ │ ├── a00293.html
│ │ │ │ │ ├── a00294.html
│ │ │ │ │ ├── a00295.html
│ │ │ │ │ ├── a00296.html
│ │ │ │ │ ├── a00297.html
│ │ │ │ │ ├── a00298.html
│ │ │ │ │ ├── a00299.html
│ │ │ │ │ ├── a00300.html
│ │ │ │ │ ├── a00301.html
│ │ │ │ │ ├── a00302.html
│ │ │ │ │ ├── a00303.html
│ │ │ │ │ ├── a00304.html
│ │ │ │ │ ├── a00305.html
│ │ │ │ │ ├── a00306.html
│ │ │ │ │ ├── a00307.html
│ │ │ │ │ ├── a00308.html
│ │ │ │ │ ├── a00309.html
│ │ │ │ │ ├── a00310.html
│ │ │ │ │ ├── a00311.html
│ │ │ │ │ ├── a00312.html
│ │ │ │ │ ├── a00313.html
│ │ │ │ │ ├── a00314.html
│ │ │ │ │ ├── a00315.html
│ │ │ │ │ ├── a00316.html
│ │ │ │ │ ├── a00317.html
│ │ │ │ │ ├── a00318.html
│ │ │ │ │ ├── a00319.html
│ │ │ │ │ ├── a00320.html
│ │ │ │ │ ├── a00321.html
│ │ │ │ │ ├── a00322.html
│ │ │ │ │ ├── a00323.html
│ │ │ │ │ ├── a00324.html
│ │ │ │ │ ├── a00325.html
│ │ │ │ │ ├── a00326.html
│ │ │ │ │ ├── a00327.html
│ │ │ │ │ ├── a00328.html
│ │ │ │ │ ├── a00329.html
│ │ │ │ │ ├── a00330.html
│ │ │ │ │ ├── a00331.html
│ │ │ │ │ ├── a00332.html
│ │ │ │ │ ├── a00333.html
│ │ │ │ │ ├── a00334.html
│ │ │ │ │ ├── a00335.html
│ │ │ │ │ ├── a00336.html
│ │ │ │ │ ├── a00337.html
│ │ │ │ │ ├── a00338.html
│ │ │ │ │ ├── a00339.html
│ │ │ │ │ ├── a00340.html
│ │ │ │ │ ├── a00341.html
│ │ │ │ │ ├── a00342.html
│ │ │ │ │ ├── a00343.html
│ │ │ │ │ ├── a00344.html
│ │ │ │ │ ├── a00345.html
│ │ │ │ │ ├── a00346.html
│ │ │ │ │ ├── a00347.html
│ │ │ │ │ ├── a00348.html
│ │ │ │ │ ├── a00349.html
│ │ │ │ │ ├── a00350.html
│ │ │ │ │ ├── a00351.html
│ │ │ │ │ ├── a00352.html
│ │ │ │ │ ├── a00353.html
│ │ │ │ │ ├── a00354.html
│ │ │ │ │ ├── a00355.html
│ │ │ │ │ ├── a00356.html
│ │ │ │ │ ├── a00357.html
│ │ │ │ │ ├── a00358.html
│ │ │ │ │ ├── a00359.html
│ │ │ │ │ ├── a00360.html
│ │ │ │ │ ├── a00361.html
│ │ │ │ │ ├── a00362.html
│ │ │ │ │ ├── a00363.html
│ │ │ │ │ ├── a00364.html
│ │ │ │ │ ├── a00365.html
│ │ │ │ │ ├── a00366.html
│ │ │ │ │ ├── a00367.html
│ │ │ │ │ ├── a00368.html
│ │ │ │ │ ├── a00369.html
│ │ │ │ │ ├── a00370.html
│ │ │ │ │ ├── a00371.html
│ │ │ │ │ ├── a00372.html
│ │ │ │ │ ├── a00373.html
│ │ │ │ │ ├── a00374.html
│ │ │ │ │ ├── dir_033f5edb0915b828d2c46ed4804e5503.html
│ │ │ │ │ ├── dir_3a581ba30d25676e4b797b1f96d53b45.html
│ │ │ │ │ ├── dir_44e5e654415abd9ca6fdeaddaff8565e.html
│ │ │ │ │ ├── dir_4c6bd29c73fa4e5a2509e1c15f846751.html
│ │ │ │ │ ├── dir_5189610d3ba09ec39b766fb99b34cd93.html
│ │ │ │ │ ├── dir_6b66465792d005310484819a0eb0b0d3.html
│ │ │ │ │ ├── dir_9e5fe034a00e89334fd5186c3e7db156.html
│ │ │ │ │ ├── dir_a8bee7be44182a33f3820393ae0b105d.html
│ │ │ │ │ ├── dir_cef2d71d502cb69a9252bca2297d9549.html
│ │ │ │ │ ├── dir_d9496f0844b48bc7e53b5af8c99b9ab2.html
│ │ │ │ │ ├── dir_f35778ec600a1b9bbc4524e62e226aa2.html
│ │ │ │ │ ├── doxygen.css
│ │ │ │ │ ├── dynsections.js
│ │ │ │ │ ├── files.html
│ │ │ │ │ ├── index.html
│ │ │ │ │ ├── jquery.js
│ │ │ │ │ ├── modules.html
│ │ │ │ │ ├── search/
│ │ │ │ │ │ ├── all_0.html
│ │ │ │ │ │ ├── all_0.js
│ │ │ │ │ │ ├── all_1.html
│ │ │ │ │ │ ├── all_1.js
│ │ │ │ │ │ ├── all_10.html
│ │ │ │ │ │ ├── all_10.js
│ │ │ │ │ │ ├── all_11.html
│ │ │ │ │ │ ├── all_11.js
│ │ │ │ │ │ ├── all_12.html
│ │ │ │ │ │ ├── all_12.js
│ │ │ │ │ │ ├── all_13.html
│ │ │ │ │ │ ├── all_13.js
│ │ │ │ │ │ ├── all_14.html
│ │ │ │ │ │ ├── all_14.js
│ │ │ │ │ │ ├── all_15.html
│ │ │ │ │ │ ├── all_15.js
│ │ │ │ │ │ ├── all_16.html
│ │ │ │ │ │ ├── all_16.js
│ │ │ │ │ │ ├── all_2.html
│ │ │ │ │ │ ├── all_2.js
│ │ │ │ │ │ ├── all_3.html
│ │ │ │ │ │ ├── all_3.js
│ │ │ │ │ │ ├── all_4.html
│ │ │ │ │ │ ├── all_4.js
│ │ │ │ │ │ ├── all_5.html
│ │ │ │ │ │ ├── all_5.js
│ │ │ │ │ │ ├── all_6.html
│ │ │ │ │ │ ├── all_6.js
│ │ │ │ │ │ ├── all_7.html
│ │ │ │ │ │ ├── all_7.js
│ │ │ │ │ │ ├── all_8.html
│ │ │ │ │ │ ├── all_8.js
│ │ │ │ │ │ ├── all_9.html
│ │ │ │ │ │ ├── all_9.js
│ │ │ │ │ │ ├── all_a.html
│ │ │ │ │ │ ├── all_a.js
│ │ │ │ │ │ ├── all_b.html
│ │ │ │ │ │ ├── all_b.js
│ │ │ │ │ │ ├── all_c.html
│ │ │ │ │ │ ├── all_c.js
│ │ │ │ │ │ ├── all_d.html
│ │ │ │ │ │ ├── all_d.js
│ │ │ │ │ │ ├── all_e.html
│ │ │ │ │ │ ├── all_e.js
│ │ │ │ │ │ ├── all_f.html
│ │ │ │ │ │ ├── all_f.js
│ │ │ │ │ │ ├── files_0.html
│ │ │ │ │ │ ├── files_0.js
│ │ │ │ │ │ ├── files_1.html
│ │ │ │ │ │ ├── files_1.js
│ │ │ │ │ │ ├── files_10.html
│ │ │ │ │ │ ├── files_10.js
│ │ │ │ │ │ ├── files_11.html
│ │ │ │ │ │ ├── files_11.js
│ │ │ │ │ │ ├── files_12.html
│ │ │ │ │ │ ├── files_12.js
│ │ │ │ │ │ ├── files_13.html
│ │ │ │ │ │ ├── files_13.js
│ │ │ │ │ │ ├── files_14.html
│ │ │ │ │ │ ├── files_14.js
│ │ │ │ │ │ ├── files_2.html
│ │ │ │ │ │ ├── files_2.js
│ │ │ │ │ │ ├── files_3.html
│ │ │ │ │ │ ├── files_3.js
│ │ │ │ │ │ ├── files_4.html
│ │ │ │ │ │ ├── files_4.js
│ │ │ │ │ │ ├── files_5.html
│ │ │ │ │ │ ├── files_5.js
│ │ │ │ │ │ ├── files_6.html
│ │ │ │ │ │ ├── files_6.js
│ │ │ │ │ │ ├── files_7.html
│ │ │ │ │ │ ├── files_7.js
│ │ │ │ │ │ ├── files_8.html
│ │ │ │ │ │ ├── files_8.js
│ │ │ │ │ │ ├── files_9.html
│ │ │ │ │ │ ├── files_9.js
│ │ │ │ │ │ ├── files_a.html
│ │ │ │ │ │ ├── files_a.js
│ │ │ │ │ │ ├── files_b.html
│ │ │ │ │ │ ├── files_b.js
│ │ │ │ │ │ ├── files_c.html
│ │ │ │ │ │ ├── files_c.js
│ │ │ │ │ │ ├── files_d.html
│ │ │ │ │ │ ├── files_d.js
│ │ │ │ │ │ ├── files_e.html
│ │ │ │ │ │ ├── files_e.js
│ │ │ │ │ │ ├── files_f.html
│ │ │ │ │ │ ├── files_f.js
│ │ │ │ │ │ ├── functions_0.html
│ │ │ │ │ │ ├── functions_0.js
│ │ │ │ │ │ ├── functions_1.html
│ │ │ │ │ │ ├── functions_1.js
│ │ │ │ │ │ ├── functions_10.html
│ │ │ │ │ │ ├── functions_10.js
│ │ │ │ │ │ ├── functions_11.html
│ │ │ │ │ │ ├── functions_11.js
│ │ │ │ │ │ ├── functions_12.html
│ │ │ │ │ │ ├── functions_12.js
│ │ │ │ │ │ ├── functions_13.html
│ │ │ │ │ │ ├── functions_13.js
│ │ │ │ │ │ ├── functions_14.html
│ │ │ │ │ │ ├── functions_14.js
│ │ │ │ │ │ ├── functions_15.html
│ │ │ │ │ │ ├── functions_15.js
│ │ │ │ │ │ ├── functions_16.html
│ │ │ │ │ │ ├── functions_16.js
│ │ │ │ │ │ ├── functions_2.html
│ │ │ │ │ │ ├── functions_2.js
│ │ │ │ │ │ ├── functions_3.html
│ │ │ │ │ │ ├── functions_3.js
│ │ │ │ │ │ ├── functions_4.html
│ │ │ │ │ │ ├── functions_4.js
│ │ │ │ │ │ ├── functions_5.html
│ │ │ │ │ │ ├── functions_5.js
│ │ │ │ │ │ ├── functions_6.html
│ │ │ │ │ │ ├── functions_6.js
│ │ │ │ │ │ ├── functions_7.html
│ │ │ │ │ │ ├── functions_7.js
│ │ │ │ │ │ ├── functions_8.html
│ │ │ │ │ │ ├── functions_8.js
│ │ │ │ │ │ ├── functions_9.html
│ │ │ │ │ │ ├── functions_9.js
│ │ │ │ │ │ ├── functions_a.html
│ │ │ │ │ │ ├── functions_a.js
│ │ │ │ │ │ ├── functions_b.html
│ │ │ │ │ │ ├── functions_b.js
│ │ │ │ │ │ ├── functions_c.html
│ │ │ │ │ │ ├── functions_c.js
│ │ │ │ │ │ ├── functions_d.html
│ │ │ │ │ │ ├── functions_d.js
│ │ │ │ │ │ ├── functions_e.html
│ │ │ │ │ │ ├── functions_e.js
│ │ │ │ │ │ ├── functions_f.html
│ │ │ │ │ │ ├── functions_f.js
│ │ │ │ │ │ ├── groups_0.html
│ │ │ │ │ │ ├── groups_0.js
│ │ │ │ │ │ ├── groups_1.html
│ │ │ │ │ │ ├── groups_1.js
│ │ │ │ │ │ ├── groups_2.html
│ │ │ │ │ │ ├── groups_2.js
│ │ │ │ │ │ ├── groups_3.html
│ │ │ │ │ │ ├── groups_3.js
│ │ │ │ │ │ ├── groups_4.html
│ │ │ │ │ │ ├── groups_4.js
│ │ │ │ │ │ ├── groups_5.html
│ │ │ │ │ │ ├── groups_5.js
│ │ │ │ │ │ ├── groups_6.html
│ │ │ │ │ │ ├── groups_6.js
│ │ │ │ │ │ ├── groups_7.html
│ │ │ │ │ │ ├── groups_7.js
│ │ │ │ │ │ ├── groups_8.html
│ │ │ │ │ │ ├── groups_8.js
│ │ │ │ │ │ ├── groups_9.html
│ │ │ │ │ │ ├── groups_9.js
│ │ │ │ │ │ ├── nomatches.html
│ │ │ │ │ │ ├── pages_0.html
│ │ │ │ │ │ ├── pages_0.js
│ │ │ │ │ │ ├── search.css
│ │ │ │ │ │ ├── search.js
│ │ │ │ │ │ ├── searchdata.js
│ │ │ │ │ │ ├── typedefs_0.html
│ │ │ │ │ │ ├── typedefs_0.js
│ │ │ │ │ │ ├── typedefs_1.html
│ │ │ │ │ │ ├── typedefs_1.js
│ │ │ │ │ │ ├── typedefs_2.html
│ │ │ │ │ │ ├── typedefs_2.js
│ │ │ │ │ │ ├── typedefs_3.html
│ │ │ │ │ │ ├── typedefs_3.js
│ │ │ │ │ │ ├── typedefs_4.html
│ │ │ │ │ │ ├── typedefs_4.js
│ │ │ │ │ │ ├── typedefs_5.html
│ │ │ │ │ │ ├── typedefs_5.js
│ │ │ │ │ │ ├── typedefs_6.html
│ │ │ │ │ │ ├── typedefs_6.js
│ │ │ │ │ │ ├── typedefs_7.html
│ │ │ │ │ │ ├── typedefs_7.js
│ │ │ │ │ │ ├── typedefs_8.html
│ │ │ │ │ │ ├── typedefs_8.js
│ │ │ │ │ │ ├── typedefs_9.html
│ │ │ │ │ │ ├── typedefs_9.js
│ │ │ │ │ │ ├── typedefs_a.html
│ │ │ │ │ │ ├── typedefs_a.js
│ │ │ │ │ │ ├── typedefs_b.html
│ │ │ │ │ │ ├── typedefs_b.js
│ │ │ │ │ │ ├── typedefs_c.html
│ │ │ │ │ │ ├── typedefs_c.js
│ │ │ │ │ │ ├── typedefs_d.html
│ │ │ │ │ │ └── typedefs_d.js
│ │ │ │ │ └── tabs.css
│ │ │ │ ├── man.doxy
│ │ │ │ └── theme/
│ │ │ │ └── doxygen.css
│ │ │ ├── glm/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── common.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── _features.hpp
│ │ │ │ │ ├── _fixes.hpp
│ │ │ │ │ ├── _noise.hpp
│ │ │ │ │ ├── _swizzle.hpp
│ │ │ │ │ ├── _swizzle_func.hpp
│ │ │ │ │ ├── _vectorize.hpp
│ │ │ │ │ ├── compute_common.hpp
│ │ │ │ │ ├── compute_vector_relational.hpp
│ │ │ │ │ ├── func_common.inl
│ │ │ │ │ ├── func_common_simd.inl
│ │ │ │ │ ├── func_exponential.inl
│ │ │ │ │ ├── func_exponential_simd.inl
│ │ │ │ │ ├── func_geometric.inl
│ │ │ │ │ ├── func_geometric_simd.inl
│ │ │ │ │ ├── func_integer.inl
│ │ │ │ │ ├── func_integer_simd.inl
│ │ │ │ │ ├── func_matrix.inl
│ │ │ │ │ ├── func_matrix_simd.inl
│ │ │ │ │ ├── func_packing.inl
│ │ │ │ │ ├── func_packing_simd.inl
│ │ │ │ │ ├── func_trigonometric.inl
│ │ │ │ │ ├── func_trigonometric_simd.inl
│ │ │ │ │ ├── func_vector_relational.inl
│ │ │ │ │ ├── func_vector_relational_simd.inl
│ │ │ │ │ ├── glm.cpp
│ │ │ │ │ ├── qualifier.hpp
│ │ │ │ │ ├── setup.hpp
│ │ │ │ │ ├── type_float.hpp
│ │ │ │ │ ├── type_half.hpp
│ │ │ │ │ ├── type_half.inl
│ │ │ │ │ ├── type_mat2x2.hpp
│ │ │ │ │ ├── type_mat2x2.inl
│ │ │ │ │ ├── type_mat2x3.hpp
│ │ │ │ │ ├── type_mat2x3.inl
│ │ │ │ │ ├── type_mat2x4.hpp
│ │ │ │ │ ├── type_mat2x4.inl
│ │ │ │ │ ├── type_mat3x2.hpp
│ │ │ │ │ ├── type_mat3x2.inl
│ │ │ │ │ ├── type_mat3x3.hpp
│ │ │ │ │ ├── type_mat3x3.inl
│ │ │ │ │ ├── type_mat3x4.hpp
│ │ │ │ │ ├── type_mat3x4.inl
│ │ │ │ │ ├── type_mat4x2.hpp
│ │ │ │ │ ├── type_mat4x2.inl
│ │ │ │ │ ├── type_mat4x3.hpp
│ │ │ │ │ ├── type_mat4x3.inl
│ │ │ │ │ ├── type_mat4x4.hpp
│ │ │ │ │ ├── type_mat4x4.inl
│ │ │ │ │ ├── type_mat4x4_simd.inl
│ │ │ │ │ ├── type_quat.hpp
│ │ │ │ │ ├── type_quat.inl
│ │ │ │ │ ├── type_quat_simd.inl
│ │ │ │ │ ├── type_vec1.hpp
│ │ │ │ │ ├── type_vec1.inl
│ │ │ │ │ ├── type_vec2.hpp
│ │ │ │ │ ├── type_vec2.inl
│ │ │ │ │ ├── type_vec3.hpp
│ │ │ │ │ ├── type_vec3.inl
│ │ │ │ │ ├── type_vec4.hpp
│ │ │ │ │ ├── type_vec4.inl
│ │ │ │ │ └── type_vec4_simd.inl
│ │ │ │ ├── exponential.hpp
│ │ │ │ ├── ext/
│ │ │ │ │ ├── _matrix_vectorize.hpp
│ │ │ │ │ ├── matrix_clip_space.hpp
│ │ │ │ │ ├── matrix_clip_space.inl
│ │ │ │ │ ├── matrix_common.hpp
│ │ │ │ │ ├── matrix_common.inl
│ │ │ │ │ ├── matrix_double2x2.hpp
│ │ │ │ │ ├── matrix_double2x2_precision.hpp
│ │ │ │ │ ├── matrix_double2x3.hpp
│ │ │ │ │ ├── matrix_double2x3_precision.hpp
│ │ │ │ │ ├── matrix_double2x4.hpp
│ │ │ │ │ ├── matrix_double2x4_precision.hpp
│ │ │ │ │ ├── matrix_double3x2.hpp
│ │ │ │ │ ├── matrix_double3x2_precision.hpp
│ │ │ │ │ ├── matrix_double3x3.hpp
│ │ │ │ │ ├── matrix_double3x3_precision.hpp
│ │ │ │ │ ├── matrix_double3x4.hpp
│ │ │ │ │ ├── matrix_double3x4_precision.hpp
│ │ │ │ │ ├── matrix_double4x2.hpp
│ │ │ │ │ ├── matrix_double4x2_precision.hpp
│ │ │ │ │ ├── matrix_double4x3.hpp
│ │ │ │ │ ├── matrix_double4x3_precision.hpp
│ │ │ │ │ ├── matrix_double4x4.hpp
│ │ │ │ │ ├── matrix_double4x4_precision.hpp
│ │ │ │ │ ├── matrix_float2x2.hpp
│ │ │ │ │ ├── matrix_float2x2_precision.hpp
│ │ │ │ │ ├── matrix_float2x3.hpp
│ │ │ │ │ ├── matrix_float2x3_precision.hpp
│ │ │ │ │ ├── matrix_float2x4.hpp
│ │ │ │ │ ├── matrix_float2x4_precision.hpp
│ │ │ │ │ ├── matrix_float3x2.hpp
│ │ │ │ │ ├── matrix_float3x2_precision.hpp
│ │ │ │ │ ├── matrix_float3x3.hpp
│ │ │ │ │ ├── matrix_float3x3_precision.hpp
│ │ │ │ │ ├── matrix_float3x4.hpp
│ │ │ │ │ ├── matrix_float3x4_precision.hpp
│ │ │ │ │ ├── matrix_float4x2.hpp
│ │ │ │ │ ├── matrix_float4x2_precision.hpp
│ │ │ │ │ ├── matrix_float4x3.hpp
│ │ │ │ │ ├── matrix_float4x3_precision.hpp
│ │ │ │ │ ├── matrix_float4x4.hpp
│ │ │ │ │ ├── matrix_float4x4_precision.hpp
│ │ │ │ │ ├── matrix_int2x2.hpp
│ │ │ │ │ ├── matrix_int2x2_sized.hpp
│ │ │ │ │ ├── matrix_int2x3.hpp
│ │ │ │ │ ├── matrix_int2x3_sized.hpp
│ │ │ │ │ ├── matrix_int2x4.hpp
│ │ │ │ │ ├── matrix_int2x4_sized.hpp
│ │ │ │ │ ├── matrix_int3x2.hpp
│ │ │ │ │ ├── matrix_int3x2_sized.hpp
│ │ │ │ │ ├── matrix_int3x3.hpp
│ │ │ │ │ ├── matrix_int3x3_sized.hpp
│ │ │ │ │ ├── matrix_int3x4.hpp
│ │ │ │ │ ├── matrix_int3x4_sized.hpp
│ │ │ │ │ ├── matrix_int4x2.hpp
│ │ │ │ │ ├── matrix_int4x2_sized.hpp
│ │ │ │ │ ├── matrix_int4x3.hpp
│ │ │ │ │ ├── matrix_int4x3_sized.hpp
│ │ │ │ │ ├── matrix_int4x4.hpp
│ │ │ │ │ ├── matrix_int4x4_sized.hpp
│ │ │ │ │ ├── matrix_integer.hpp
│ │ │ │ │ ├── matrix_integer.inl
│ │ │ │ │ ├── matrix_projection.hpp
│ │ │ │ │ ├── matrix_projection.inl
│ │ │ │ │ ├── matrix_relational.hpp
│ │ │ │ │ ├── matrix_relational.inl
│ │ │ │ │ ├── matrix_transform.hpp
│ │ │ │ │ ├── matrix_transform.inl
│ │ │ │ │ ├── matrix_uint2x2.hpp
│ │ │ │ │ ├── matrix_uint2x2_sized.hpp
│ │ │ │ │ ├── matrix_uint2x3.hpp
│ │ │ │ │ ├── matrix_uint2x3_sized.hpp
│ │ │ │ │ ├── matrix_uint2x4.hpp
│ │ │ │ │ ├── matrix_uint2x4_sized.hpp
│ │ │ │ │ ├── matrix_uint3x2.hpp
│ │ │ │ │ ├── matrix_uint3x2_sized.hpp
│ │ │ │ │ ├── matrix_uint3x3.hpp
│ │ │ │ │ ├── matrix_uint3x3_sized.hpp
│ │ │ │ │ ├── matrix_uint3x4.hpp
│ │ │ │ │ ├── matrix_uint3x4_sized.hpp
│ │ │ │ │ ├── matrix_uint4x2.hpp
│ │ │ │ │ ├── matrix_uint4x2_sized.hpp
│ │ │ │ │ ├── matrix_uint4x3.hpp
│ │ │ │ │ ├── matrix_uint4x3_sized.hpp
│ │ │ │ │ ├── matrix_uint4x4.hpp
│ │ │ │ │ ├── matrix_uint4x4_sized.hpp
│ │ │ │ │ ├── quaternion_common.hpp
│ │ │ │ │ ├── quaternion_common.inl
│ │ │ │ │ ├── quaternion_common_simd.inl
│ │ │ │ │ ├── quaternion_double.hpp
│ │ │ │ │ ├── quaternion_double_precision.hpp
│ │ │ │ │ ├── quaternion_exponential.hpp
│ │ │ │ │ ├── quaternion_exponential.inl
│ │ │ │ │ ├── quaternion_float.hpp
│ │ │ │ │ ├── quaternion_float_precision.hpp
│ │ │ │ │ ├── quaternion_geometric.hpp
│ │ │ │ │ ├── quaternion_geometric.inl
│ │ │ │ │ ├── quaternion_relational.hpp
│ │ │ │ │ ├── quaternion_relational.inl
│ │ │ │ │ ├── quaternion_transform.hpp
│ │ │ │ │ ├── quaternion_transform.inl
│ │ │ │ │ ├── quaternion_trigonometric.hpp
│ │ │ │ │ ├── quaternion_trigonometric.inl
│ │ │ │ │ ├── scalar_common.hpp
│ │ │ │ │ ├── scalar_common.inl
│ │ │ │ │ ├── scalar_constants.hpp
│ │ │ │ │ ├── scalar_constants.inl
│ │ │ │ │ ├── scalar_int_sized.hpp
│ │ │ │ │ ├── scalar_integer.hpp
│ │ │ │ │ ├── scalar_integer.inl
│ │ │ │ │ ├── scalar_packing.hpp
│ │ │ │ │ ├── scalar_packing.inl
│ │ │ │ │ ├── scalar_reciprocal.hpp
│ │ │ │ │ ├── scalar_reciprocal.inl
│ │ │ │ │ ├── scalar_relational.hpp
│ │ │ │ │ ├── scalar_relational.inl
│ │ │ │ │ ├── scalar_uint_sized.hpp
│ │ │ │ │ ├── scalar_ulp.hpp
│ │ │ │ │ ├── scalar_ulp.inl
│ │ │ │ │ ├── vector_bool1.hpp
│ │ │ │ │ ├── vector_bool1_precision.hpp
│ │ │ │ │ ├── vector_bool2.hpp
│ │ │ │ │ ├── vector_bool2_precision.hpp
│ │ │ │ │ ├── vector_bool3.hpp
│ │ │ │ │ ├── vector_bool3_precision.hpp
│ │ │ │ │ ├── vector_bool4.hpp
│ │ │ │ │ ├── vector_bool4_precision.hpp
│ │ │ │ │ ├── vector_common.hpp
│ │ │ │ │ ├── vector_common.inl
│ │ │ │ │ ├── vector_double1.hpp
│ │ │ │ │ ├── vector_double1_precision.hpp
│ │ │ │ │ ├── vector_double2.hpp
│ │ │ │ │ ├── vector_double2_precision.hpp
│ │ │ │ │ ├── vector_double3.hpp
│ │ │ │ │ ├── vector_double3_precision.hpp
│ │ │ │ │ ├── vector_double4.hpp
│ │ │ │ │ ├── vector_double4_precision.hpp
│ │ │ │ │ ├── vector_float1.hpp
│ │ │ │ │ ├── vector_float1_precision.hpp
│ │ │ │ │ ├── vector_float2.hpp
│ │ │ │ │ ├── vector_float2_precision.hpp
│ │ │ │ │ ├── vector_float3.hpp
│ │ │ │ │ ├── vector_float3_precision.hpp
│ │ │ │ │ ├── vector_float4.hpp
│ │ │ │ │ ├── vector_float4_precision.hpp
│ │ │ │ │ ├── vector_int1.hpp
│ │ │ │ │ ├── vector_int1_sized.hpp
│ │ │ │ │ ├── vector_int2.hpp
│ │ │ │ │ ├── vector_int2_sized.hpp
│ │ │ │ │ ├── vector_int3.hpp
│ │ │ │ │ ├── vector_int3_sized.hpp
│ │ │ │ │ ├── vector_int4.hpp
│ │ │ │ │ ├── vector_int4_sized.hpp
│ │ │ │ │ ├── vector_integer.hpp
│ │ │ │ │ ├── vector_integer.inl
│ │ │ │ │ ├── vector_packing.hpp
│ │ │ │ │ ├── vector_packing.inl
│ │ │ │ │ ├── vector_reciprocal.hpp
│ │ │ │ │ ├── vector_reciprocal.inl
│ │ │ │ │ ├── vector_relational.hpp
│ │ │ │ │ ├── vector_relational.inl
│ │ │ │ │ ├── vector_uint1.hpp
│ │ │ │ │ ├── vector_uint1_sized.hpp
│ │ │ │ │ ├── vector_uint2.hpp
│ │ │ │ │ ├── vector_uint2_sized.hpp
│ │ │ │ │ ├── vector_uint3.hpp
│ │ │ │ │ ├── vector_uint3_sized.hpp
│ │ │ │ │ ├── vector_uint4.hpp
│ │ │ │ │ ├── vector_uint4_sized.hpp
│ │ │ │ │ ├── vector_ulp.hpp
│ │ │ │ │ └── vector_ulp.inl
│ │ │ │ ├── ext.hpp
│ │ │ │ ├── fwd.hpp
│ │ │ │ ├── geometric.hpp
│ │ │ │ ├── glm.hpp
│ │ │ │ ├── gtc/
│ │ │ │ │ ├── bitfield.hpp
│ │ │ │ │ ├── bitfield.inl
│ │ │ │ │ ├── color_space.hpp
│ │ │ │ │ ├── color_space.inl
│ │ │ │ │ ├── constants.hpp
│ │ │ │ │ ├── constants.inl
│ │ │ │ │ ├── epsilon.hpp
│ │ │ │ │ ├── epsilon.inl
│ │ │ │ │ ├── integer.hpp
│ │ │ │ │ ├── integer.inl
│ │ │ │ │ ├── matrix_access.hpp
│ │ │ │ │ ├── matrix_access.inl
│ │ │ │ │ ├── matrix_integer.hpp
│ │ │ │ │ ├── matrix_inverse.hpp
│ │ │ │ │ ├── matrix_inverse.inl
│ │ │ │ │ ├── matrix_transform.hpp
│ │ │ │ │ ├── matrix_transform.inl
│ │ │ │ │ ├── noise.hpp
│ │ │ │ │ ├── noise.inl
│ │ │ │ │ ├── packing.hpp
│ │ │ │ │ ├── packing.inl
│ │ │ │ │ ├── quaternion.hpp
│ │ │ │ │ ├── quaternion.inl
│ │ │ │ │ ├── quaternion_simd.inl
│ │ │ │ │ ├── random.hpp
│ │ │ │ │ ├── random.inl
│ │ │ │ │ ├── reciprocal.hpp
│ │ │ │ │ ├── round.hpp
│ │ │ │ │ ├── round.inl
│ │ │ │ │ ├── type_aligned.hpp
│ │ │ │ │ ├── type_precision.hpp
│ │ │ │ │ ├── type_precision.inl
│ │ │ │ │ ├── type_ptr.hpp
│ │ │ │ │ ├── type_ptr.inl
│ │ │ │ │ ├── ulp.hpp
│ │ │ │ │ ├── ulp.inl
│ │ │ │ │ └── vec1.hpp
│ │ │ │ ├── gtx/
│ │ │ │ │ ├── associated_min_max.hpp
│ │ │ │ │ ├── associated_min_max.inl
│ │ │ │ │ ├── bit.hpp
│ │ │ │ │ ├── bit.inl
│ │ │ │ │ ├── closest_point.hpp
│ │ │ │ │ ├── closest_point.inl
│ │ │ │ │ ├── color_encoding.hpp
│ │ │ │ │ ├── color_encoding.inl
│ │ │ │ │ ├── color_space.hpp
│ │ │ │ │ ├── color_space.inl
│ │ │ │ │ ├── color_space_YCoCg.hpp
│ │ │ │ │ ├── color_space_YCoCg.inl
│ │ │ │ │ ├── common.hpp
│ │ │ │ │ ├── common.inl
│ │ │ │ │ ├── compatibility.hpp
│ │ │ │ │ ├── compatibility.inl
│ │ │ │ │ ├── component_wise.hpp
│ │ │ │ │ ├── component_wise.inl
│ │ │ │ │ ├── dual_quaternion.hpp
│ │ │ │ │ ├── dual_quaternion.inl
│ │ │ │ │ ├── easing.hpp
│ │ │ │ │ ├── easing.inl
│ │ │ │ │ ├── euler_angles.hpp
│ │ │ │ │ ├── euler_angles.inl
│ │ │ │ │ ├── extend.hpp
│ │ │ │ │ ├── extend.inl
│ │ │ │ │ ├── extended_min_max.hpp
│ │ │ │ │ ├── extended_min_max.inl
│ │ │ │ │ ├── exterior_product.hpp
│ │ │ │ │ ├── exterior_product.inl
│ │ │ │ │ ├── fast_exponential.hpp
│ │ │ │ │ ├── fast_exponential.inl
│ │ │ │ │ ├── fast_square_root.hpp
│ │ │ │ │ ├── fast_square_root.inl
│ │ │ │ │ ├── fast_trigonometry.hpp
│ │ │ │ │ ├── fast_trigonometry.inl
│ │ │ │ │ ├── float_notmalize.inl
│ │ │ │ │ ├── functions.hpp
│ │ │ │ │ ├── functions.inl
│ │ │ │ │ ├── gradient_paint.hpp
│ │ │ │ │ ├── gradient_paint.inl
│ │ │ │ │ ├── handed_coordinate_space.hpp
│ │ │ │ │ ├── handed_coordinate_space.inl
│ │ │ │ │ ├── hash.hpp
│ │ │ │ │ ├── hash.inl
│ │ │ │ │ ├── integer.hpp
│ │ │ │ │ ├── integer.inl
│ │ │ │ │ ├── intersect.hpp
│ │ │ │ │ ├── intersect.inl
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ ├── io.inl
│ │ │ │ │ ├── log_base.hpp
│ │ │ │ │ ├── log_base.inl
│ │ │ │ │ ├── matrix_cross_product.hpp
│ │ │ │ │ ├── matrix_cross_product.inl
│ │ │ │ │ ├── matrix_decompose.hpp
│ │ │ │ │ ├── matrix_decompose.inl
│ │ │ │ │ ├── matrix_factorisation.hpp
│ │ │ │ │ ├── matrix_factorisation.inl
│ │ │ │ │ ├── matrix_interpolation.hpp
│ │ │ │ │ ├── matrix_interpolation.inl
│ │ │ │ │ ├── matrix_major_storage.hpp
│ │ │ │ │ ├── matrix_major_storage.inl
│ │ │ │ │ ├── matrix_operation.hpp
│ │ │ │ │ ├── matrix_operation.inl
│ │ │ │ │ ├── matrix_query.hpp
│ │ │ │ │ ├── matrix_query.inl
│ │ │ │ │ ├── matrix_transform_2d.hpp
│ │ │ │ │ ├── matrix_transform_2d.inl
│ │ │ │ │ ├── mixed_product.hpp
│ │ │ │ │ ├── mixed_product.inl
│ │ │ │ │ ├── norm.hpp
│ │ │ │ │ ├── norm.inl
│ │ │ │ │ ├── normal.hpp
│ │ │ │ │ ├── normal.inl
│ │ │ │ │ ├── normalize_dot.hpp
│ │ │ │ │ ├── normalize_dot.inl
│ │ │ │ │ ├── number_precision.hpp
│ │ │ │ │ ├── number_precision.inl
│ │ │ │ │ ├── optimum_pow.hpp
│ │ │ │ │ ├── optimum_pow.inl
│ │ │ │ │ ├── orthonormalize.hpp
│ │ │ │ │ ├── orthonormalize.inl
│ │ │ │ │ ├── pca.hpp
│ │ │ │ │ ├── pca.inl
│ │ │ │ │ ├── perpendicular.hpp
│ │ │ │ │ ├── perpendicular.inl
│ │ │ │ │ ├── polar_coordinates.hpp
│ │ │ │ │ ├── polar_coordinates.inl
│ │ │ │ │ ├── projection.hpp
│ │ │ │ │ ├── projection.inl
│ │ │ │ │ ├── quaternion.hpp
│ │ │ │ │ ├── quaternion.inl
│ │ │ │ │ ├── range.hpp
│ │ │ │ │ ├── raw_data.hpp
│ │ │ │ │ ├── raw_data.inl
│ │ │ │ │ ├── rotate_normalized_axis.hpp
│ │ │ │ │ ├── rotate_normalized_axis.inl
│ │ │ │ │ ├── rotate_vector.hpp
│ │ │ │ │ ├── rotate_vector.inl
│ │ │ │ │ ├── scalar_multiplication.hpp
│ │ │ │ │ ├── scalar_relational.hpp
│ │ │ │ │ ├── scalar_relational.inl
│ │ │ │ │ ├── spline.hpp
│ │ │ │ │ ├── spline.inl
│ │ │ │ │ ├── std_based_type.hpp
│ │ │ │ │ ├── std_based_type.inl
│ │ │ │ │ ├── string_cast.hpp
│ │ │ │ │ ├── string_cast.inl
│ │ │ │ │ ├── texture.hpp
│ │ │ │ │ ├── texture.inl
│ │ │ │ │ ├── transform.hpp
│ │ │ │ │ ├── transform.inl
│ │ │ │ │ ├── transform2.hpp
│ │ │ │ │ ├── transform2.inl
│ │ │ │ │ ├── type_aligned.hpp
│ │ │ │ │ ├── type_aligned.inl
│ │ │ │ │ ├── type_trait.hpp
│ │ │ │ │ ├── type_trait.inl
│ │ │ │ │ ├── vec_swizzle.hpp
│ │ │ │ │ ├── vector_angle.hpp
│ │ │ │ │ ├── vector_angle.inl
│ │ │ │ │ ├── vector_query.hpp
│ │ │ │ │ ├── vector_query.inl
│ │ │ │ │ ├── wrap.hpp
│ │ │ │ │ └── wrap.inl
│ │ │ │ ├── integer.hpp
│ │ │ │ ├── mat2x2.hpp
│ │ │ │ ├── mat2x3.hpp
│ │ │ │ ├── mat2x4.hpp
│ │ │ │ ├── mat3x2.hpp
│ │ │ │ ├── mat3x3.hpp
│ │ │ │ ├── mat3x4.hpp
│ │ │ │ ├── mat4x2.hpp
│ │ │ │ ├── mat4x3.hpp
│ │ │ │ ├── mat4x4.hpp
│ │ │ │ ├── matrix.hpp
│ │ │ │ ├── packing.hpp
│ │ │ │ ├── simd/
│ │ │ │ │ ├── common.h
│ │ │ │ │ ├── exponential.h
│ │ │ │ │ ├── geometric.h
│ │ │ │ │ ├── integer.h
│ │ │ │ │ ├── matrix.h
│ │ │ │ │ ├── neon.h
│ │ │ │ │ ├── packing.h
│ │ │ │ │ ├── platform.h
│ │ │ │ │ ├── trigonometric.h
│ │ │ │ │ └── vector_relational.h
│ │ │ │ ├── trigonometric.hpp
│ │ │ │ ├── vec2.hpp
│ │ │ │ ├── vec3.hpp
│ │ │ │ ├── vec4.hpp
│ │ │ │ └── vector_relational.hpp
│ │ │ ├── manual.md
│ │ │ ├── readme.md
│ │ │ ├── test/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── bug/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── bug_ms_vec_static.cpp
│ │ │ │ ├── cmake/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ └── test_find_glm.cpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── core_cpp_constexpr.cpp
│ │ │ │ │ ├── core_cpp_defaulted_ctor.cpp
│ │ │ │ │ ├── core_force_aligned_gentypes.cpp
│ │ │ │ │ ├── core_force_arch_unknown.cpp
│ │ │ │ │ ├── core_force_compiler_unknown.cpp
│ │ │ │ │ ├── core_force_ctor_init.cpp
│ │ │ │ │ ├── core_force_cxx03.cpp
│ │ │ │ │ ├── core_force_cxx98.cpp
│ │ │ │ │ ├── core_force_cxx_unknown.cpp
│ │ │ │ │ ├── core_force_depth_zero_to_one.cpp
│ │ │ │ │ ├── core_force_explicit_ctor.cpp
│ │ │ │ │ ├── core_force_inline.cpp
│ │ │ │ │ ├── core_force_left_handed.cpp
│ │ │ │ │ ├── core_force_platform_unknown.cpp
│ │ │ │ │ ├── core_force_pure.cpp
│ │ │ │ │ ├── core_force_quat_xyzw.cpp
│ │ │ │ │ ├── core_force_size_t_length.cpp
│ │ │ │ │ ├── core_force_unrestricted_gentype.cpp
│ │ │ │ │ ├── core_force_xyzw_only.cpp
│ │ │ │ │ ├── core_func_common.cpp
│ │ │ │ │ ├── core_func_exponential.cpp
│ │ │ │ │ ├── core_func_geometric.cpp
│ │ │ │ │ ├── core_func_integer.cpp
│ │ │ │ │ ├── core_func_integer_bit_count.cpp
│ │ │ │ │ ├── core_func_integer_find_lsb.cpp
│ │ │ │ │ ├── core_func_integer_find_msb.cpp
│ │ │ │ │ ├── core_func_matrix.cpp
│ │ │ │ │ ├── core_func_noise.cpp
│ │ │ │ │ ├── core_func_packing.cpp
│ │ │ │ │ ├── core_func_swizzle.cpp
│ │ │ │ │ ├── core_func_trigonometric.cpp
│ │ │ │ │ ├── core_func_vector_relational.cpp
│ │ │ │ │ ├── core_setup_force_cxx98.cpp
│ │ │ │ │ ├── core_setup_force_size_t_length.cpp
│ │ │ │ │ ├── core_setup_message.cpp
│ │ │ │ │ ├── core_setup_platform_unknown.cpp
│ │ │ │ │ ├── core_setup_precision.cpp
│ │ │ │ │ ├── core_type_aligned.cpp
│ │ │ │ │ ├── core_type_cast.cpp
│ │ │ │ │ ├── core_type_ctor.cpp
│ │ │ │ │ ├── core_type_int.cpp
│ │ │ │ │ ├── core_type_length.cpp
│ │ │ │ │ ├── core_type_mat2x2.cpp
│ │ │ │ │ ├── core_type_mat2x3.cpp
│ │ │ │ │ ├── core_type_mat2x4.cpp
│ │ │ │ │ ├── core_type_mat3x2.cpp
│ │ │ │ │ ├── core_type_mat3x3.cpp
│ │ │ │ │ ├── core_type_mat3x4.cpp
│ │ │ │ │ ├── core_type_mat4x2.cpp
│ │ │ │ │ ├── core_type_mat4x3.cpp
│ │ │ │ │ ├── core_type_mat4x4.cpp
│ │ │ │ │ ├── core_type_vec1.cpp
│ │ │ │ │ ├── core_type_vec2.cpp
│ │ │ │ │ ├── core_type_vec3.cpp
│ │ │ │ │ └── core_type_vec4.cpp
│ │ │ │ ├── ext/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── ext_matrix_clip_space.cpp
│ │ │ │ │ ├── ext_matrix_common.cpp
│ │ │ │ │ ├── ext_matrix_int2x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int2x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int2x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int3x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_int4x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_integer.cpp
│ │ │ │ │ ├── ext_matrix_projection.cpp
│ │ │ │ │ ├── ext_matrix_relational.cpp
│ │ │ │ │ ├── ext_matrix_transform.cpp
│ │ │ │ │ ├── ext_matrix_uint2x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint2x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint2x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint3x4_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x2_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x3_sized.cpp
│ │ │ │ │ ├── ext_matrix_uint4x4_sized.cpp
│ │ │ │ │ ├── ext_quaternion_common.cpp
│ │ │ │ │ ├── ext_quaternion_exponential.cpp
│ │ │ │ │ ├── ext_quaternion_geometric.cpp
│ │ │ │ │ ├── ext_quaternion_relational.cpp
│ │ │ │ │ ├── ext_quaternion_transform.cpp
│ │ │ │ │ ├── ext_quaternion_trigonometric.cpp
│ │ │ │ │ ├── ext_quaternion_type.cpp
│ │ │ │ │ ├── ext_scalar_common.cpp
│ │ │ │ │ ├── ext_scalar_constants.cpp
│ │ │ │ │ ├── ext_scalar_int_sized.cpp
│ │ │ │ │ ├── ext_scalar_integer.cpp
│ │ │ │ │ ├── ext_scalar_packing.cpp
│ │ │ │ │ ├── ext_scalar_reciprocal.cpp
│ │ │ │ │ ├── ext_scalar_relational.cpp
│ │ │ │ │ ├── ext_scalar_uint_sized.cpp
│ │ │ │ │ ├── ext_scalar_ulp.cpp
│ │ │ │ │ ├── ext_vec1.cpp
│ │ │ │ │ ├── ext_vector_bool1.cpp
│ │ │ │ │ ├── ext_vector_common.cpp
│ │ │ │ │ ├── ext_vector_iec559.cpp
│ │ │ │ │ ├── ext_vector_int1_sized.cpp
│ │ │ │ │ ├── ext_vector_int2_sized.cpp
│ │ │ │ │ ├── ext_vector_int3_sized.cpp
│ │ │ │ │ ├── ext_vector_int4_sized.cpp
│ │ │ │ │ ├── ext_vector_integer.cpp
│ │ │ │ │ ├── ext_vector_integer_sized.cpp
│ │ │ │ │ ├── ext_vector_packing.cpp
│ │ │ │ │ ├── ext_vector_reciprocal.cpp
│ │ │ │ │ ├── ext_vector_relational.cpp
│ │ │ │ │ ├── ext_vector_uint1_sized.cpp
│ │ │ │ │ ├── ext_vector_uint2_sized.cpp
│ │ │ │ │ ├── ext_vector_uint3_sized.cpp
│ │ │ │ │ ├── ext_vector_uint4_sized.cpp
│ │ │ │ │ └── ext_vector_ulp.cpp
│ │ │ │ ├── glm.cppcheck
│ │ │ │ ├── gtc/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── gtc_bitfield.cpp
│ │ │ │ │ ├── gtc_color_space.cpp
│ │ │ │ │ ├── gtc_constants.cpp
│ │ │ │ │ ├── gtc_epsilon.cpp
│ │ │ │ │ ├── gtc_integer.cpp
│ │ │ │ │ ├── gtc_matrix_access.cpp
│ │ │ │ │ ├── gtc_matrix_integer.cpp
│ │ │ │ │ ├── gtc_matrix_inverse.cpp
│ │ │ │ │ ├── gtc_matrix_transform.cpp
│ │ │ │ │ ├── gtc_noise.cpp
│ │ │ │ │ ├── gtc_packing.cpp
│ │ │ │ │ ├── gtc_quaternion.cpp
│ │ │ │ │ ├── gtc_random.cpp
│ │ │ │ │ ├── gtc_reciprocal.cpp
│ │ │ │ │ ├── gtc_round.cpp
│ │ │ │ │ ├── gtc_type_aligned.cpp
│ │ │ │ │ ├── gtc_type_precision.cpp
│ │ │ │ │ ├── gtc_type_ptr.cpp
│ │ │ │ │ ├── gtc_ulp.cpp
│ │ │ │ │ ├── gtc_user_defined_types.cpp
│ │ │ │ │ └── gtc_vec1.cpp
│ │ │ │ ├── gtx/
│ │ │ │ │ ├── CMakeLists.txt
│ │ │ │ │ ├── gtx.cpp
│ │ │ │ │ ├── gtx_associated_min_max.cpp
│ │ │ │ │ ├── gtx_closest_point.cpp
│ │ │ │ │ ├── gtx_color_encoding.cpp
│ │ │ │ │ ├── gtx_color_space.cpp
│ │ │ │ │ ├── gtx_color_space_YCoCg.cpp
│ │ │ │ │ ├── gtx_common.cpp
│ │ │ │ │ ├── gtx_compatibility.cpp
│ │ │ │ │ ├── gtx_component_wise.cpp
│ │ │ │ │ ├── gtx_dual_quaternion.cpp
│ │ │ │ │ ├── gtx_easing.cpp
│ │ │ │ │ ├── gtx_euler_angle.cpp
│ │ │ │ │ ├── gtx_extend.cpp
│ │ │ │ │ ├── gtx_extended_min_max.cpp
│ │ │ │ │ ├── gtx_extented_min_max.cpp
│ │ │ │ │ ├── gtx_exterior_product.cpp
│ │ │ │ │ ├── gtx_fast_exponential.cpp
│ │ │ │ │ ├── gtx_fast_square_root.cpp
│ │ │ │ │ ├── gtx_fast_trigonometry.cpp
│ │ │ │ │ ├── gtx_functions.cpp
│ │ │ │ │ ├── gtx_gradient_paint.cpp
│ │ │ │ │ ├── gtx_handed_coordinate_space.cpp
│ │ │ │ │ ├── gtx_hash.cpp
│ │ │ │ │ ├── gtx_int_10_10_10_2.cpp
│ │ │ │ │ ├── gtx_integer.cpp
│ │ │ │ │ ├── gtx_intersect.cpp
│ │ │ │ │ ├── gtx_io.cpp
│ │ │ │ │ ├── gtx_load.cpp
│ │ │ │ │ ├── gtx_log_base.cpp
│ │ │ │ │ ├── gtx_matrix_cross_product.cpp
│ │ │ │ │ ├── gtx_matrix_decompose.cpp
│ │ │ │ │ ├── gtx_matrix_factorisation.cpp
│ │ │ │ │ ├── gtx_matrix_interpolation.cpp
│ │ │ │ │ ├── gtx_matrix_major_storage.cpp
│ │ │ │ │ ├── gtx_matrix_operation.cpp
│ │ │ │ │ ├── gtx_matrix_query.cpp
│ │ │ │ │ ├── gtx_matrix_transform_2d.cpp
│ │ │ │ │ ├── gtx_mixed_product.cpp
│ │ │ │ │ ├── gtx_norm.cpp
│ │ │ │ │ ├── gtx_normal.cpp
│ │ │ │ │ ├── gtx_normalize_dot.cpp
│ │ │ │ │ ├── gtx_number_precision.cpp
│ │ │ │ │ ├── gtx_optimum_pow.cpp
│ │ │ │ │ ├── gtx_orthonormalize.cpp
│ │ │ │ │ ├── gtx_pca.cpp
│ │ │ │ │ ├── gtx_perpendicular.cpp
│ │ │ │ │ ├── gtx_polar_coordinates.cpp
│ │ │ │ │ ├── gtx_projection.cpp
│ │ │ │ │ ├── gtx_quaternion.cpp
│ │ │ │ │ ├── gtx_random.cpp
│ │ │ │ │ ├── gtx_range.cpp
│ │ │ │ │ ├── gtx_rotate_normalized_axis.cpp
│ │ │ │ │ ├── gtx_rotate_vector.cpp
│ │ │ │ │ ├── gtx_scalar_multiplication.cpp
│ │ │ │ │ ├── gtx_scalar_relational.cpp
│ │ │ │ │ ├── gtx_simd_mat4.cpp
│ │ │ │ │ ├── gtx_simd_vec4.cpp
│ │ │ │ │ ├── gtx_spline.cpp
│ │ │ │ │ ├── gtx_string_cast.cpp
│ │ │ │ │ ├── gtx_texture.cpp
│ │ │ │ │ ├── gtx_type_aligned.cpp
│ │ │ │ │ ├── gtx_type_trait.cpp
│ │ │ │ │ ├── gtx_vec_swizzle.cpp
│ │ │ │ │ ├── gtx_vector_angle.cpp
│ │ │ │ │ ├── gtx_vector_query.cpp
│ │ │ │ │ └── gtx_wrap.cpp
│ │ │ │ └── perf/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── perf_matrix_div.cpp
│ │ │ │ ├── perf_matrix_inverse.cpp
│ │ │ │ ├── perf_matrix_mul.cpp
│ │ │ │ ├── perf_matrix_mul_vector.cpp
│ │ │ │ ├── perf_matrix_transpose.cpp
│ │ │ │ └── perf_vector_mul_matrix.cpp
│ │ │ └── util/
│ │ │ ├── autoexp.txt
│ │ │ └── glm.natvis
│ │ └── stbi_image_write.h
│ └── simple-knn/
│ ├── dist/
│ │ └── simple_knn-0.0.0-py3.8-linux-x86_64.egg
│ ├── ext.cpp
│ ├── setup.py
│ ├── simple_knn/
│ │ └── .gitkeep
│ ├── simple_knn.cu
│ ├── simple_knn.egg-info/
│ │ ├── PKG-INFO
│ │ ├── SOURCES.txt
│ │ ├── dependency_links.txt
│ │ └── top_level.txt
│ ├── simple_knn.h
│ ├── spatial.cu
│ └── spatial.h
├── train.py
└── utils/
├── camera_utils.py
├── general_utils.py
├── graphics_utils.py
├── image_utils.py
├── loss_utils.py
├── sh_utils.py
└── system_utils.py
Showing preview only (290K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2894 symbols across 507 files)
FILE: arguments/__init__.py
class GroupParams (line 16) | class GroupParams:
class ParamGroup (line 19) | class ParamGroup:
method __init__ (line 20) | def __init__(self, parser: ArgumentParser, name : str, fill_none = Fal...
method extract (line 40) | def extract(self, args):
class ModelParams (line 47) | class ModelParams(ParamGroup):
method __init__ (line 48) | def __init__(self, parser, sentinel=False):
method extract (line 60) | def extract(self, args):
class PipelineParams (line 65) | class PipelineParams(ParamGroup):
method __init__ (line 66) | def __init__(self, parser):
class OptimizationParams (line 72) | class OptimizationParams(ParamGroup):
method __init__ (line 73) | def __init__(self, parser):
function get_combined_args (line 101) | def get_combined_args(parser : ArgumentParser):
FILE: gaussian_renderer/__init__.py
function render (line 19) | def render(viewpoint_camera, pc : GaussianModel, pipe, bg_color : torch....
FILE: gaussian_renderer/network_gui.py
function init (line 26) | def init(wish_host, wish_port):
function try_connect (line 34) | def try_connect():
function read (line 43) | def read():
function send (line 50) | def send(message_bytes, verify):
function receive (line 57) | def receive():
FILE: lpipsPyTorch/__init__.py
function lpips (line 6) | def lpips(x: torch.Tensor,
FILE: lpipsPyTorch/modules/lpips.py
class LPIPS (line 8) | class LPIPS(nn.Module):
method __init__ (line 17) | def __init__(self, net_type: str = 'alex', version: str = '0.1'):
method forward (line 30) | def forward(self, x: torch.Tensor, y: torch.Tensor):
FILE: lpipsPyTorch/modules/networks.py
function get_network (line 12) | def get_network(net_type: str):
class LinLayers (line 23) | class LinLayers(nn.ModuleList):
method __init__ (line 24) | def __init__(self, n_channels_list: Sequence[int]):
class BaseNet (line 36) | class BaseNet(nn.Module):
method __init__ (line 37) | def __init__(self):
method set_requires_grad (line 46) | def set_requires_grad(self, state: bool):
method z_score (line 50) | def z_score(self, x: torch.Tensor):
method forward (line 53) | def forward(self, x: torch.Tensor):
class SqueezeNet (line 66) | class SqueezeNet(BaseNet):
method __init__ (line 67) | def __init__(self):
class AlexNet (line 77) | class AlexNet(BaseNet):
method __init__ (line 78) | def __init__(self):
class VGG16 (line 88) | class VGG16(BaseNet):
method __init__ (line 89) | def __init__(self):
FILE: lpipsPyTorch/modules/utils.py
function normalize_activation (line 6) | def normalize_activation(x, eps=1e-10):
function get_state_dict (line 11) | def get_state_dict(net_type: str = 'alex', version: str = '0.1'):
FILE: metrics.py
function readImages (line 24) | def readImages(renders_dir, gt_dir):
function evaluate (line 36) | def evaluate(model_paths):
FILE: render.py
function render_set (line 24) | def render_set(model_path, name, iteration, views, gaussians, pipeline, ...
function render_sets (line 37) | def render_sets(dataset : ModelParams, iteration : int, pipeline : Pipel...
FILE: scene/__init__.py
class Scene (line 21) | class Scene:
method __init__ (line 25) | def __init__(self, args : ModelParams, gaussians : GaussianModel, load...
method save (line 85) | def save(self, iteration):
method getTrainCameras (line 89) | def getTrainCameras(self, scale=1.0):
method getTestCameras (line 92) | def getTestCameras(self, scale=1.0):
FILE: scene/cameras.py
class Camera (line 17) | class Camera(nn.Module):
method __init__ (line 18) | def __init__(self, colmap_id, R, T, FoVx, FoVy, image, gt_alpha_mask,
class MiniCam (line 59) | class MiniCam:
method __init__ (line 60) | def __init__(self, width, height, fovy, fovx, znear, zfar, world_view_...
FILE: scene/colmap_loader.py
function qvec2rotmat (line 43) | def qvec2rotmat(qvec):
function rotmat2qvec (line 55) | def rotmat2qvec(R):
class Image (line 68) | class Image(BaseImage):
method qvec2rotmat (line 69) | def qvec2rotmat(self):
function read_next_bytes (line 72) | def read_next_bytes(fid, num_bytes, format_char_sequence, endian_charact...
function read_points3D_text_3DGS (line 83) | def read_points3D_text_3DGS(path):
function read_points3D_text (line 125) | def read_points3D_text(path, max_err=2, min_track_length=3):
function read_points3D_binary_3DGS (line 178) | def read_points3D_binary_3DGS(path_to_model_file):
function read_points3D_binary (line 207) | def read_points3D_binary(path_to_model_file,max_err=2,min_track_length=3):
function read_intrinsics_text (line 250) | def read_intrinsics_text(path):
function read_extrinsics_binary (line 274) | def read_extrinsics_binary(path_to_model_file):
function read_intrinsics_binary (line 309) | def read_intrinsics_binary(path_to_model_file):
function read_extrinsics_text (line 338) | def read_extrinsics_text(path):
function read_colmap_bin_array (line 367) | def read_colmap_bin_array(path):
FILE: scene/dataset_readers.py
class CameraInfo (line 26) | class CameraInfo(NamedTuple):
class SceneInfo (line 38) | class SceneInfo(NamedTuple):
function getNerfppNorm (line 45) | def getNerfppNorm(cam_info):
function readColmapCameras (line 68) | def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder):
function fetchPly (line 109) | def fetchPly(path):
function storePly (line 117) | def storePly(path, xyz, rgb):
function readColmapSceneInfo (line 134) | def readColmapSceneInfo(path, images, eval, llffhold=8):
function readCamerasFromTransforms (line 183) | def readCamerasFromTransforms(path, transformsfile, white_background, ex...
function readNerfSyntheticInfo (line 225) | def readNerfSyntheticInfo(path, white_background, eval, extension=".png"):
FILE: scene/gaussian_model.py
class GaussianModel (line 24) | class GaussianModel:
method setup_functions (line 26) | def setup_functions(self):
method __init__ (line 44) | def __init__(self, sh_degree : int):
method capture (line 63) | def capture(self):
method restore (line 81) | def restore(self, model_args, training_args):
method capture_for_3DGS (line 102) | def capture_for_3DGS(self):
method restore_from_3DGS (line 118) | def restore_from_3DGS(self, model_args, training_args):
method get_scaling (line 139) | def get_scaling(self):
method get_rotation (line 143) | def get_rotation(self):
method get_xyz (line 147) | def get_xyz(self):
method get_features (line 151) | def get_features(self):
method get_opacity (line 157) | def get_opacity(self):
method get_covariance (line 160) | def get_covariance(self, scaling_modifier = 1):
method oneupSHdegree (line 163) | def oneupSHdegree(self):
method create_from_pcd (line 167) | def create_from_pcd(self, pcd : BasicPointCloud, spatial_lr_scale : fl...
method training_setup (line 193) | def training_setup(self, training_args):
method update_learning_rate (line 214) | def update_learning_rate(self, iteration):
method construct_list_of_attributes (line 222) | def construct_list_of_attributes(self):
method save_ply (line 236) | def save_ply(self, path):
method reset_opacity (line 255) | def reset_opacity(self):
method reduce_opacity (line 260) | def reduce_opacity(self):
method load_ply (line 266) | def load_ply(self, path):
method replace_tensor_to_optimizer (line 309) | def replace_tensor_to_optimizer(self, tensor, name):
method _prune_optimizer (line 324) | def _prune_optimizer(self, mask):
method prune_points (line 342) | def prune_points(self, mask):
method initial_prune (line 360) | def initial_prune(self):
method cat_tensors_to_optimizer (line 375) | def cat_tensors_to_optimizer(self, tensors_dict):
method densification_postfix (line 397) | def densification_postfix(self, new_xyz, new_features_dc, new_features...
method densify_and_split (line 421) | def densify_and_split(self, grads, grad_threshold, scene_extent, N=2):
method densify_and_clone (line 446) | def densify_and_clone(self, grads, grad_threshold, scene_extent):
method densify_and_prune (line 461) | def densify_and_prune(self, max_grad, max_grad_abs, min_opacity, exten...
method add_densification_stats (line 479) | def add_densification_stats(self, viewspace_point_tensor, update_filter):
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/auxiliary.h
function ndc2Pix (line 41) | float ndc2Pix(float v, int S)
function getRect (line 46) | void getRect(const float2 p, int max_radius, uint2& rect_min, uint2& rec...
function float3 (line 58) | float3 transformPoint4x3(const float3& p, const float* matrix)
function float4 (line 68) | float4 transformPoint4x4(const float3& p, const float* matrix)
function float3 (line 79) | float3 transformVec4x3(const float3& p, const float* matrix)
function float3 (line 89) | float3 transformVec4x3Transpose(const float3& p, const float* matrix)
function dnormvdz (line 99) | float dnormvdz(float3 v, float3 dv)
function float3 (line 107) | float3 dnormvdv(float3 v, float3 dv)
function float4 (line 119) | float4 dnormvdv(float4 v, float4 dv)
function sigmoid (line 134) | float sigmoid(float x)
function in_frustum (line 139) | bool in_frustum(int idx,
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/backward.h
function namespace (line 21) | namespace BACKWARD
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/forward.h
function namespace (line 21) | namespace FORWARD
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/rasterizer.h
function namespace (line 18) | namespace CudaRasterizer
FILE: submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/rasterizer_impl.h
function namespace (line 19) | namespace CudaRasterizer
FILE: submodules/diff-gaussian-rasterization-abs/diff_gaussian_rasterization_abs/__init__.py
function cpu_deep_copy_tuple (line 17) | def cpu_deep_copy_tuple(input_tuple):
function rasterize_gaussians (line 21) | def rasterize_gaussians(
class _RasterizeGaussians (line 44) | class _RasterizeGaussians(torch.autograd.Function):
method forward (line 46) | def forward(
method backward (line 101) | def backward(ctx, grad_out_color, grad_radii, grad_gs_w):
class GaussianRasterizationSettings (line 157) | class GaussianRasterizationSettings(NamedTuple):
class GaussianRasterizer (line 171) | class GaussianRasterizer(nn.Module):
method __init__ (line 172) | def __init__(self, raster_settings):
method markVisible (line 176) | def markVisible(self, positions):
method forward (line 187) | def forward(self, means3D, means2D, opacities, shs = None, colors_prec...
FILE: submodules/diff-gaussian-rasterization-abs/ext.cpp
function PYBIND11_MODULE (line 15) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/dynsections.js
function toggleVisibility (line 1) | function toggleVisibility(linkObj)
function updateStripes (line 22) | function updateStripes()
function toggleLevel (line 28) | function toggleLevel(level)
function toggleFolder (line 49) | function toggleFolder(id)
function toggleInherit (line 84) | function toggleInherit(id)
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/jquery.js
function b0 (line 16) | function b0(b3,b4){return new b0.fn.init(b3,b4)}
function bw (line 16) | function bw(){if(bF.isReady){return}try{av.documentElement.doScroll("lef...
function X (line 16) | function X(e){var bv=a2[e]={},bw,bx;e=e.split(/\s+/);for(bw=0,bx=e.lengt...
function bD (line 16) | function bD(bF){return function(bG){bx[bF]=arguments.length>1?aJ.call(ar...
function bz (line 16) | function bz(bF){return function(bG){bB[bF]=arguments.length>1?aJ.call(ar...
function a5 (line 16) | function a5(bx,bw,by){if(by===L&&bx.nodeType===1){var bv="data-"+bw.repl...
function S (line 16) | function S(bv){for(var e in bv){if(e==="data"&&b.isEmptyObject(bv[e])){c...
function bi (line 16) | function bi(by,bx,bA){var bw=bx+"defer",bv=bx+"queue",e=bx+"mark",bz=b._...
function bE (line 16) | function bE(){if(!(--bB)){e.resolveWith(bv,[bv])}}
function bk (line 16) | function bk(){return false}
function i (line 16) | function i(){return true}
function bv (line 23) | function bv(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT<bS;bT++){var...
function bN (line 23) | function bN(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT<bS;bT++){var...
function C (line 23) | function C(e){return !e||!e.parentNode||e.parentNode.nodeType===11}
function aG (line 23) | function aG(bx,bw,e){bw=bw||0;if(b.isFunction(bw)){return b.grep(bx,func...
function a (line 23) | function a(e){var bw=aR.split("|"),bv=e.createDocumentFragment();if(bv.c...
function ba (line 23) | function ba(e,bv){return b.nodeName(e,"table")?(e.getElementsByTagName("...
function t (line 23) | function t(bB,bv){if(bv.nodeType!==1||!b.hasData(bB)){return}var by,bx,e...
function ai (line 23) | function ai(bv,e){var bw;if(e.nodeType!==1){return}if(e.clearAttributes)...
function bg (line 23) | function bg(e){if(typeof e.getElementsByTagName!=="undefined"){return e....
function az (line 23) | function az(e){if(e.type==="checkbox"||e.type==="radio"){e.defaultChecke...
function E (line 23) | function E(e){var bv=(e.nodeName||"").toLowerCase();if(bv==="input"){az(...
function al (line 23) | function al(e){var bv=av.createElement("div");ac.appendChild(bv);bv.inne...
function bo (line 23) | function bo(e,bv){if(bv.src){b.ajax({url:bv.src,async:false,dataType:"sc...
function p (line 23) | function p(by,bw,bv){var bA=bw==="width"?by.offsetWidth:by.offsetHeight,...
function f (line 23) | function f(e){return function(by,bA){if(typeof by!=="string"){bA=by;by="...
function aW (line 23) | function aW(bv,bE,bz,bD,bB,bx){bB=bB||bE.dataTypes[0];bx=bx||{};bx[bB]=t...
function am (line 23) | function am(bw,bx){var bv,e,by=b.ajaxSettings.flatOptions||{};for(bv in ...
function bF (line 23) | function bF(bZ,bU,b0,bW){if(bA===2){return}bA=2;if(bE){clearTimeout(bE)}...
function v (line 23) | function v(bw,by,bv,bx){if(b.isArray(by)){b.each(by,function(bA,bz){if(b...
function bj (line 23) | function bj(bD,bC,bz){var bv=bD.contents,bB=bD.dataTypes,bw=bD.responseF...
function G (line 23) | function G(bH,bz){if(bH.dataFilter){bz=bH.dataFilter(bz,bH.dataType)}var...
function aL (line 23) | function aL(){try{return new bb.XMLHttpRequest()}catch(bv){}}
function aj (line 23) | function aj(){try{return new bb.ActiveXObject("Microsoft.XMLHTTP")}catch...
function bv (line 23) | function bv(){if(e.queue===false){b._mark(this)}var bE=b.extend({},e),bK...
function bB (line 23) | function bB(bE,bF,bD){var bC=bF[bD];b.removeData(bE,bD,true);bC.stop(e)}
function bh (line 23) | function bh(){setTimeout(at,0);return(a4=b.now())}
function at (line 23) | function at(){a4=L}
function a0 (line 23) | function a0(bv,e){var bw={};b.each(aH.concat.apply([],aH.slice(0,e)),fun...
function bv (line 23) | function bv(bA){return e.step(bA)}
function x (line 23) | function x(bx){if(!Q[bx]){var e=av.body,bv=b("<"+bx+">").appendTo(e),bw=...
function aK (line 23) | function aK(e){return b.isWindow(e)?e:e.nodeType===9?e.defaultView||e.pa...
function j (line 32) | function j(m,l,i,n){a.each(f,function(){l-=parseFloat(a.curCSS(m,"paddin...
function c (line 32) | function c(g,e){var j=g.nodeName.toLowerCase();if("area"===j){var i=g.pa...
function b (line 32) | function b(e){return !a(e).parents().andSelf().filter(function(){return ...
function a (line 61) | function a(j){j=j||location.href;return"#"+j.replace(/^[^#]*#?(.*)$/,"$1")}
function n (line 61) | function n(){var r=a(),q=o(m);if(r!==m){l(m=r,q);$(e).trigger(c)}else{if...
function h (line 61) | function h(n){j.animate(g,e,d.easing,n&&function(){n.call(this,f,d)})}
function b (line 61) | function b(d){return typeof d=="object"?d:{top:d,left:d}}
function b (line 68) | function b(){var F=this;F.top="auto";F.left="auto";F.right="auto";F.bott...
function t (line 68) | function t(K,N,F){var J=null;function L(P,Q){M();if(!K.data(e)){if(!P){c...
function j (line 68) | function j(){function G(M,L,J,O,P){var K=L.split("-")[0],N=new b(),I;if(...
function x (line 68) | function x(Q){var P=new j(),O=k("#"+Q.popupId);if(O.length===0){O=k("<di...
function q (line 68) | function q(F){return window.SVGElement&&F[0] instanceof SVGElement}
function h (line 68) | function h(){if(!c.mouseTrackingActive){c.mouseTrackingActive=true;k(fun...
function i (line 68) | function i(F){c.currentX=F.pageX;c.currentY=F.pageY}
function v (line 68) | function v(F){var H=F.offset(),J=F[0].getBoundingClientRect(),I=J.right-...
function B (line 68) | function B(I){var G=I.data(y),F=I.data(o),K=I.data(l),H,J;if(G){if(k.isF...
function m (line 68) | function m(M,L,K){var G=c.scrollTop,J=c.scrollLeft,I=G+c.windowHeight,F=...
function a (line 68) | function a(G){var F=0;while(G){G&=G-1;F++}return F}
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/search/search.js
function convertToId (line 1) | function convertToId(search)
function getXPos (line 24) | function getXPos(item)
function getYPos (line 38) | function getYPos(item)
function SearchBox (line 59) | function SearchBox(name, resultsPath, inFrame, label)
function SearchResults (line 404) | function SearchResults(name)
function setKeyActions (line 709) | function setKeyActions(elem,action)
function setClassAttr (line 716) | function setClassAttr(elem,attr)
function createResults (line 722) | function createResults()
function init_search (line 777) | function init_search()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/common.hpp
type glm (line 20) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/_noise.hpp
type glm (line 5) | namespace glm{
type detail (line 6) | namespace detail
function GLM_FUNC_QUALIFIER (line 9) | GLM_FUNC_QUALIFIER T mod289(T const& x)
function GLM_FUNC_QUALIFIER (line 15) | GLM_FUNC_QUALIFIER T permute(T const& x)
function GLM_FUNC_QUALIFIER (line 21) | GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x)
function GLM_FUNC_QUALIFIER (line 27) | GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x)
function GLM_FUNC_QUALIFIER (line 33) | GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x)
function GLM_FUNC_QUALIFIER (line 39) | GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r)
function GLM_FUNC_QUALIFIER (line 45) | GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
function GLM_FUNC_QUALIFIER (line 51) | GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
function GLM_FUNC_QUALIFIER (line 57) | GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
function GLM_FUNC_QUALIFIER (line 63) | GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
function GLM_FUNC_QUALIFIER (line 69) | GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
function GLM_FUNC_QUALIFIER (line 75) | GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/_swizzle.hpp
type glm (line 3) | namespace glm{
type detail (line 4) | namespace detail
type _swizzle_base0 (line 8) | struct _swizzle_base0
method GLM_FUNC_QUALIFIER (line 11) | GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast<T*>...
method GLM_FUNC_QUALIFIER (line 12) | GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterp...
type _swizzle_base1 (line 21) | struct _swizzle_base1 : public _swizzle_base0<T, N>
type _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> (line 26) | struct _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> : public _swizz...
method GLM_FUNC_QUALIFIER (line 28) | GLM_FUNC_QUALIFIER vec<2, T, Q> operator ()() const { return vec<...
type _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> (line 32) | struct _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> : public _swizz...
method GLM_FUNC_QUALIFIER (line 34) | GLM_FUNC_QUALIFIER vec<3, T, Q> operator ()() const { return vec<...
type _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> (line 38) | struct _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> : public _swizz...
method GLM_FUNC_QUALIFIER (line 40) | GLM_FUNC_QUALIFIER vec<4, T, Q> operator ()() const { return vec<...
type _swizzle_base2 (line 55) | struct _swizzle_base2 : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, ...
type op_equal (line 57) | struct op_equal
method GLM_FUNC_QUALIFIER (line 59) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e = t; }
type op_minus (line 62) | struct op_minus
method GLM_FUNC_QUALIFIER (line 64) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e -= t; }
type op_plus (line 67) | struct op_plus
method GLM_FUNC_QUALIFIER (line 69) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e += t; }
type op_mul (line 72) | struct op_mul
method GLM_FUNC_QUALIFIER (line 74) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e *= t; }
type op_div (line 77) | struct op_div
method GLM_FUNC_QUALIFIER (line 79) | GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e /= t; }
method GLM_FUNC_QUALIFIER (line 83) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
method GLM_FUNC_QUALIFIER (line 90) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec<N, T, Q> const& ...
method GLM_FUNC_QUALIFIER (line 96) | GLM_FUNC_QUALIFIER void operator -= (vec<N, T, Q> const& that)
method GLM_FUNC_QUALIFIER (line 101) | GLM_FUNC_QUALIFIER void operator += (vec<N, T, Q> const& that)
method GLM_FUNC_QUALIFIER (line 106) | GLM_FUNC_QUALIFIER void operator *= (vec<N, T, Q> const& that)
method GLM_FUNC_QUALIFIER (line 111) | GLM_FUNC_QUALIFIER void operator /= (vec<N, T, Q> const& that)
method GLM_FUNC_QUALIFIER (line 116) | GLM_FUNC_QUALIFIER T& operator[](size_t i)
method GLM_FUNC_QUALIFIER (line 121) | GLM_FUNC_QUALIFIER T operator[](size_t i) const
method GLM_FUNC_QUALIFIER (line 129) | GLM_FUNC_QUALIFIER void _apply_op(vec<N, T, Q> const& that, const ...
type _swizzle_base2<N, T, Q, E0,E1,E2,E3, 1> (line 144) | struct _swizzle_base2<N, T, Q, E0,E1,E2,E3, 1> : public _swizzle_bas...
type Stub (line 146) | struct Stub {}
method GLM_FUNC_QUALIFIER (line 148) | GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const&) { retur...
method GLM_FUNC_QUALIFIER (line 150) | GLM_FUNC_QUALIFIER T operator[] (size_t i) const
type _swizzle (line 158) | struct _swizzle : public _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0...
method GLM_FUNC_QUALIFIER (line 164) | GLM_FUNC_QUALIFIER operator vec<N, T, Q> () const { return (*this)...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/_vectorize.hpp
type glm (line 3) | namespace glm{
type detail (line 4) | namespace detail
type functor1 (line 7) | struct functor1{}
type functor1<vec, 1, R, T, Q> (line 10) | struct functor1<vec, 1, R, T, Q>
method call (line 12) | static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v)
type functor1<vec, 2, R, T, Q> (line 19) | struct functor1<vec, 2, R, T, Q>
method call (line 21) | static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v)
type functor1<vec, 3, R, T, Q> (line 28) | struct functor1<vec, 3, R, T, Q>
method call (line 30) | static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v)
type functor1<vec, 4, R, T, Q> (line 37) | struct functor1<vec, 4, R, T, Q>
method call (line 39) | static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v)
type functor2 (line 46) | struct functor2{}
type functor2<vec, 1, T, Q> (line 49) | struct functor2<vec, 1, T, Q>
method call (line 51) | call(T (*Func) (T x, T y), vec<1, T, Q> const& a, vec<1, T, Q> con...
type functor2<vec, 2, T, Q> (line 58) | struct functor2<vec, 2, T, Q>
method call (line 60) | call(T (*Func) (T x, T y), vec<2, T, Q> const& a, vec<2, T, Q> con...
type functor2<vec, 3, T, Q> (line 67) | struct functor2<vec, 3, T, Q>
method call (line 69) | call(T (*Func) (T x, T y), vec<3, T, Q> const& a, vec<3, T, Q> con...
type functor2<vec, 4, T, Q> (line 76) | struct functor2<vec, 4, T, Q>
method call (line 78) | call(T (*Func) (T x, T y), vec<4, T, Q> const& a, vec<4, T, Q> con...
type functor2_vec_sca (line 85) | struct functor2_vec_sca{}
type functor2_vec_sca<vec, 1, T, Q> (line 88) | struct functor2_vec_sca<vec, 1, T, Q>
method call (line 90) | call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b)
type functor2_vec_sca<vec, 2, T, Q> (line 97) | struct functor2_vec_sca<vec, 2, T, Q>
method call (line 99) | call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b)
type functor2_vec_sca<vec, 3, T, Q> (line 106) | struct functor2_vec_sca<vec, 3, T, Q>
method call (line 108) | call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b)
type functor2_vec_sca<vec, 4, T, Q> (line 115) | struct functor2_vec_sca<vec, 4, T, Q>
method call (line 117) | call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b)
type functor2_vec_int (line 124) | struct functor2_vec_int {}
type functor2_vec_int<1, T, Q> (line 127) | struct functor2_vec_int<1, T, Q>
method call (line 129) | call(int (*Func) (T x, int y), vec<1, T, Q> const& a, vec<1, int, ...
type functor2_vec_int<2, T, Q> (line 136) | struct functor2_vec_int<2, T, Q>
method call (line 138) | call(int (*Func) (T x, int y), vec<2, T, Q> const& a, vec<2, int, ...
type functor2_vec_int<3, T, Q> (line 145) | struct functor2_vec_int<3, T, Q>
method call (line 147) | call(int (*Func) (T x, int y), vec<3, T, Q> const& a, vec<3, int, ...
type functor2_vec_int<4, T, Q> (line 154) | struct functor2_vec_int<4, T, Q>
method call (line 156) | call(int (*Func) (T x, int y), vec<4, T, Q> const& a, vec<4, int, ...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/compute_common.hpp
type glm (line 6) | namespace glm{
type detail (line 7) | namespace detail
type compute_abs (line 10) | struct compute_abs
type compute_abs<genFIType, true> (line 14) | struct compute_abs<genFIType, true>
method genFIType (line 16) | static genFIType call(genFIType x)
type compute_abs<float, true> (line 29) | struct compute_abs<float, true>
method call (line 31) | static float call(float x)
type compute_abs<genFIType, false> (line 39) | struct compute_abs<genFIType, false>
method genFIType (line 41) | static genFIType call(genFIType x)
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/compute_vector_relational.hpp
type glm (line 7) | namespace glm{
type detail (line 8) | namespace detail
type compute_equal (line 11) | struct compute_equal
method call (line 13) | static bool call(T a, T b)
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/glm.cpp
type glm (line 14) | namespace glm
type vec<1, uint8, lowp> (line 17) | struct vec<1, uint8, lowp>
type vec<1, uint16, lowp> (line 18) | struct vec<1, uint16, lowp>
type vec<1, uint32, lowp> (line 19) | struct vec<1, uint32, lowp>
type vec<1, uint64, lowp> (line 20) | struct vec<1, uint64, lowp>
type vec<1, int8, lowp> (line 21) | struct vec<1, int8, lowp>
type vec<1, int16, lowp> (line 22) | struct vec<1, int16, lowp>
type vec<1, int32, lowp> (line 23) | struct vec<1, int32, lowp>
type vec<1, int64, lowp> (line 24) | struct vec<1, int64, lowp>
type vec<1, float32, lowp> (line 25) | struct vec<1, float32, lowp>
type vec<1, float64, lowp> (line 26) | struct vec<1, float64, lowp>
type vec<1, uint8, mediump> (line 28) | struct vec<1, uint8, mediump>
type vec<1, uint16, mediump> (line 29) | struct vec<1, uint16, mediump>
type vec<1, uint32, mediump> (line 30) | struct vec<1, uint32, mediump>
type vec<1, uint64, mediump> (line 31) | struct vec<1, uint64, mediump>
type vec<1, int8, mediump> (line 32) | struct vec<1, int8, mediump>
type vec<1, int16, mediump> (line 33) | struct vec<1, int16, mediump>
type vec<1, int32, mediump> (line 34) | struct vec<1, int32, mediump>
type vec<1, int64, mediump> (line 35) | struct vec<1, int64, mediump>
type vec<1, float32, mediump> (line 36) | struct vec<1, float32, mediump>
type vec<1, float64, mediump> (line 37) | struct vec<1, float64, mediump>
type vec<1, uint8, highp> (line 39) | struct vec<1, uint8, highp>
type vec<1, uint16, highp> (line 40) | struct vec<1, uint16, highp>
type vec<1, uint32, highp> (line 41) | struct vec<1, uint32, highp>
type vec<1, uint64, highp> (line 42) | struct vec<1, uint64, highp>
type vec<1, int8, highp> (line 43) | struct vec<1, int8, highp>
type vec<1, int16, highp> (line 44) | struct vec<1, int16, highp>
type vec<1, int32, highp> (line 45) | struct vec<1, int32, highp>
type vec<1, int64, highp> (line 46) | struct vec<1, int64, highp>
type vec<1, float32, highp> (line 47) | struct vec<1, float32, highp>
type vec<1, float64, highp> (line 48) | struct vec<1, float64, highp>
type vec<2, uint8, lowp> (line 51) | struct vec<2, uint8, lowp>
type vec<2, uint16, lowp> (line 52) | struct vec<2, uint16, lowp>
type vec<2, uint32, lowp> (line 53) | struct vec<2, uint32, lowp>
type vec<2, uint64, lowp> (line 54) | struct vec<2, uint64, lowp>
type vec<2, int8, lowp> (line 55) | struct vec<2, int8, lowp>
type vec<2, int16, lowp> (line 56) | struct vec<2, int16, lowp>
type vec<2, int32, lowp> (line 57) | struct vec<2, int32, lowp>
type vec<2, int64, lowp> (line 58) | struct vec<2, int64, lowp>
type vec<2, float32, lowp> (line 59) | struct vec<2, float32, lowp>
type vec<2, float64, lowp> (line 60) | struct vec<2, float64, lowp>
type vec<2, uint8, mediump> (line 62) | struct vec<2, uint8, mediump>
type vec<2, uint16, mediump> (line 63) | struct vec<2, uint16, mediump>
type vec<2, uint32, mediump> (line 64) | struct vec<2, uint32, mediump>
type vec<2, uint64, mediump> (line 65) | struct vec<2, uint64, mediump>
type vec<2, int8, mediump> (line 66) | struct vec<2, int8, mediump>
type vec<2, int16, mediump> (line 67) | struct vec<2, int16, mediump>
type vec<2, int32, mediump> (line 68) | struct vec<2, int32, mediump>
type vec<2, int64, mediump> (line 69) | struct vec<2, int64, mediump>
type vec<2, float32, mediump> (line 70) | struct vec<2, float32, mediump>
type vec<2, float64, mediump> (line 71) | struct vec<2, float64, mediump>
type vec<2, uint8, highp> (line 73) | struct vec<2, uint8, highp>
type vec<2, uint16, highp> (line 74) | struct vec<2, uint16, highp>
type vec<2, uint32, highp> (line 75) | struct vec<2, uint32, highp>
type vec<2, uint64, highp> (line 76) | struct vec<2, uint64, highp>
type vec<2, int8, highp> (line 77) | struct vec<2, int8, highp>
type vec<2, int16, highp> (line 78) | struct vec<2, int16, highp>
type vec<2, int32, highp> (line 79) | struct vec<2, int32, highp>
type vec<2, int64, highp> (line 80) | struct vec<2, int64, highp>
type vec<2, float32, highp> (line 81) | struct vec<2, float32, highp>
type vec<2, float64, highp> (line 82) | struct vec<2, float64, highp>
type vec<3, uint8, lowp> (line 85) | struct vec<3, uint8, lowp>
type vec<3, uint16, lowp> (line 86) | struct vec<3, uint16, lowp>
type vec<3, uint32, lowp> (line 87) | struct vec<3, uint32, lowp>
type vec<3, uint64, lowp> (line 88) | struct vec<3, uint64, lowp>
type vec<3, int8, lowp> (line 89) | struct vec<3, int8, lowp>
type vec<3, int16, lowp> (line 90) | struct vec<3, int16, lowp>
type vec<3, int32, lowp> (line 91) | struct vec<3, int32, lowp>
type vec<3, int64, lowp> (line 92) | struct vec<3, int64, lowp>
type vec<3, float32, lowp> (line 93) | struct vec<3, float32, lowp>
type vec<3, float64, lowp> (line 94) | struct vec<3, float64, lowp>
type vec<3, uint8, mediump> (line 96) | struct vec<3, uint8, mediump>
type vec<3, uint16, mediump> (line 97) | struct vec<3, uint16, mediump>
type vec<3, uint32, mediump> (line 98) | struct vec<3, uint32, mediump>
type vec<3, uint64, mediump> (line 99) | struct vec<3, uint64, mediump>
type vec<3, int8, mediump> (line 100) | struct vec<3, int8, mediump>
type vec<3, int16, mediump> (line 101) | struct vec<3, int16, mediump>
type vec<3, int32, mediump> (line 102) | struct vec<3, int32, mediump>
type vec<3, int64, mediump> (line 103) | struct vec<3, int64, mediump>
type vec<3, float32, mediump> (line 104) | struct vec<3, float32, mediump>
type vec<3, float64, mediump> (line 105) | struct vec<3, float64, mediump>
type vec<3, uint8, highp> (line 107) | struct vec<3, uint8, highp>
type vec<3, uint16, highp> (line 108) | struct vec<3, uint16, highp>
type vec<3, uint32, highp> (line 109) | struct vec<3, uint32, highp>
type vec<3, uint64, highp> (line 110) | struct vec<3, uint64, highp>
type vec<3, int8, highp> (line 111) | struct vec<3, int8, highp>
type vec<3, int16, highp> (line 112) | struct vec<3, int16, highp>
type vec<3, int32, highp> (line 113) | struct vec<3, int32, highp>
type vec<3, int64, highp> (line 114) | struct vec<3, int64, highp>
type vec<3, float32, highp> (line 115) | struct vec<3, float32, highp>
type vec<3, float64, highp> (line 116) | struct vec<3, float64, highp>
type vec<4, uint8, lowp> (line 119) | struct vec<4, uint8, lowp>
type vec<4, uint16, lowp> (line 120) | struct vec<4, uint16, lowp>
type vec<4, uint32, lowp> (line 121) | struct vec<4, uint32, lowp>
type vec<4, uint64, lowp> (line 122) | struct vec<4, uint64, lowp>
type vec<4, int8, lowp> (line 123) | struct vec<4, int8, lowp>
type vec<4, int16, lowp> (line 124) | struct vec<4, int16, lowp>
type vec<4, int32, lowp> (line 125) | struct vec<4, int32, lowp>
type vec<4, int64, lowp> (line 126) | struct vec<4, int64, lowp>
type vec<4, float32, lowp> (line 127) | struct vec<4, float32, lowp>
type vec<4, float64, lowp> (line 128) | struct vec<4, float64, lowp>
type vec<4, uint8, mediump> (line 130) | struct vec<4, uint8, mediump>
type vec<4, uint16, mediump> (line 131) | struct vec<4, uint16, mediump>
type vec<4, uint32, mediump> (line 132) | struct vec<4, uint32, mediump>
type vec<4, uint64, mediump> (line 133) | struct vec<4, uint64, mediump>
type vec<4, int8, mediump> (line 134) | struct vec<4, int8, mediump>
type vec<4, int16, mediump> (line 135) | struct vec<4, int16, mediump>
type vec<4, int32, mediump> (line 136) | struct vec<4, int32, mediump>
type vec<4, int64, mediump> (line 137) | struct vec<4, int64, mediump>
type vec<4, float32, mediump> (line 138) | struct vec<4, float32, mediump>
type vec<4, float64, mediump> (line 139) | struct vec<4, float64, mediump>
type vec<4, uint8, highp> (line 141) | struct vec<4, uint8, highp>
type vec<4, uint16, highp> (line 142) | struct vec<4, uint16, highp>
type vec<4, uint32, highp> (line 143) | struct vec<4, uint32, highp>
type vec<4, uint64, highp> (line 144) | struct vec<4, uint64, highp>
type vec<4, int8, highp> (line 145) | struct vec<4, int8, highp>
type vec<4, int16, highp> (line 146) | struct vec<4, int16, highp>
type vec<4, int32, highp> (line 147) | struct vec<4, int32, highp>
type vec<4, int64, highp> (line 148) | struct vec<4, int64, highp>
type vec<4, float32, highp> (line 149) | struct vec<4, float32, highp>
type vec<4, float64, highp> (line 150) | struct vec<4, float64, highp>
type mat<2, 2, float32, lowp> (line 153) | struct mat<2, 2, float32, lowp>
type mat<2, 2, float64, lowp> (line 154) | struct mat<2, 2, float64, lowp>
type mat<2, 2, float32, mediump> (line 156) | struct mat<2, 2, float32, mediump>
type mat<2, 2, float64, mediump> (line 157) | struct mat<2, 2, float64, mediump>
type mat<2, 2, float32, highp> (line 159) | struct mat<2, 2, float32, highp>
type mat<2, 2, float64, highp> (line 160) | struct mat<2, 2, float64, highp>
type mat<2, 3, float32, lowp> (line 163) | struct mat<2, 3, float32, lowp>
type mat<2, 3, float64, lowp> (line 164) | struct mat<2, 3, float64, lowp>
type mat<2, 3, float32, mediump> (line 166) | struct mat<2, 3, float32, mediump>
type mat<2, 3, float64, mediump> (line 167) | struct mat<2, 3, float64, mediump>
type mat<2, 3, float32, highp> (line 169) | struct mat<2, 3, float32, highp>
type mat<2, 3, float64, highp> (line 170) | struct mat<2, 3, float64, highp>
type mat<2, 4, float32, lowp> (line 173) | struct mat<2, 4, float32, lowp>
type mat<2, 4, float64, lowp> (line 174) | struct mat<2, 4, float64, lowp>
type mat<2, 4, float32, mediump> (line 176) | struct mat<2, 4, float32, mediump>
type mat<2, 4, float64, mediump> (line 177) | struct mat<2, 4, float64, mediump>
type mat<2, 4, float32, highp> (line 179) | struct mat<2, 4, float32, highp>
type mat<2, 4, float64, highp> (line 180) | struct mat<2, 4, float64, highp>
type mat<3, 2, float32, lowp> (line 183) | struct mat<3, 2, float32, lowp>
type mat<3, 2, float64, lowp> (line 184) | struct mat<3, 2, float64, lowp>
type mat<3, 2, float32, mediump> (line 186) | struct mat<3, 2, float32, mediump>
type mat<3, 2, float64, mediump> (line 187) | struct mat<3, 2, float64, mediump>
type mat<3, 2, float32, highp> (line 189) | struct mat<3, 2, float32, highp>
type mat<3, 2, float64, highp> (line 190) | struct mat<3, 2, float64, highp>
type mat<3, 3, float32, lowp> (line 193) | struct mat<3, 3, float32, lowp>
type mat<3, 3, float64, lowp> (line 194) | struct mat<3, 3, float64, lowp>
type mat<3, 3, float32, mediump> (line 196) | struct mat<3, 3, float32, mediump>
type mat<3, 3, float64, mediump> (line 197) | struct mat<3, 3, float64, mediump>
type mat<3, 3, float32, highp> (line 199) | struct mat<3, 3, float32, highp>
type mat<3, 3, float64, highp> (line 200) | struct mat<3, 3, float64, highp>
type mat<3, 4, float32, lowp> (line 203) | struct mat<3, 4, float32, lowp>
type mat<3, 4, float64, lowp> (line 204) | struct mat<3, 4, float64, lowp>
type mat<3, 4, float32, mediump> (line 206) | struct mat<3, 4, float32, mediump>
type mat<3, 4, float64, mediump> (line 207) | struct mat<3, 4, float64, mediump>
type mat<3, 4, float32, highp> (line 209) | struct mat<3, 4, float32, highp>
type mat<3, 4, float64, highp> (line 210) | struct mat<3, 4, float64, highp>
type mat<4, 2, float32, lowp> (line 213) | struct mat<4, 2, float32, lowp>
type mat<4, 2, float64, lowp> (line 214) | struct mat<4, 2, float64, lowp>
type mat<4, 2, float32, mediump> (line 216) | struct mat<4, 2, float32, mediump>
type mat<4, 2, float64, mediump> (line 217) | struct mat<4, 2, float64, mediump>
type mat<4, 2, float32, highp> (line 219) | struct mat<4, 2, float32, highp>
type mat<4, 2, float64, highp> (line 220) | struct mat<4, 2, float64, highp>
type mat<4, 3, float32, lowp> (line 223) | struct mat<4, 3, float32, lowp>
type mat<4, 3, float64, lowp> (line 224) | struct mat<4, 3, float64, lowp>
type mat<4, 3, float32, mediump> (line 226) | struct mat<4, 3, float32, mediump>
type mat<4, 3, float64, mediump> (line 227) | struct mat<4, 3, float64, mediump>
type mat<4, 3, float32, highp> (line 229) | struct mat<4, 3, float32, highp>
type mat<4, 3, float64, highp> (line 230) | struct mat<4, 3, float64, highp>
type mat<4, 4, float32, lowp> (line 233) | struct mat<4, 4, float32, lowp>
type mat<4, 4, float64, lowp> (line 234) | struct mat<4, 4, float64, lowp>
type mat<4, 4, float32, mediump> (line 236) | struct mat<4, 4, float32, mediump>
type mat<4, 4, float64, mediump> (line 237) | struct mat<4, 4, float64, mediump>
type mat<4, 4, float32, highp> (line 239) | struct mat<4, 4, float32, highp>
type mat<4, 4, float64, highp> (line 240) | struct mat<4, 4, float64, highp>
type qua<float32, lowp> (line 243) | struct qua<float32, lowp>
type qua<float64, lowp> (line 244) | struct qua<float64, lowp>
type qua<float32, mediump> (line 246) | struct qua<float32, mediump>
type qua<float64, mediump> (line 247) | struct qua<float64, mediump>
type qua<float32, highp> (line 249) | struct qua<float32, highp>
type qua<float64, highp> (line 250) | struct qua<float64, highp>
type tdualquat<float32, lowp> (line 253) | struct tdualquat<float32, lowp>
type tdualquat<float64, lowp> (line 254) | struct tdualquat<float64, lowp>
type tdualquat<float32, mediump> (line 256) | struct tdualquat<float32, mediump>
type tdualquat<float64, mediump> (line 257) | struct tdualquat<float64, mediump>
type tdualquat<float32, highp> (line 259) | struct tdualquat<float32, highp>
type tdualquat<float64, highp> (line 260) | struct tdualquat<float64, highp>
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/qualifier.hpp
type glm (line 5) | namespace glm
type qualifier (line 8) | enum qualifier
type vec (line 35) | struct vec
type mat (line 36) | struct mat
type qua (line 37) | struct qua
type detail (line 56) | namespace detail
type is_aligned (line 59) | struct is_aligned
type is_aligned<glm::aligned_lowp> (line 66) | struct is_aligned<glm::aligned_lowp>
type is_aligned<glm::aligned_mediump> (line 72) | struct is_aligned<glm::aligned_mediump>
type is_aligned<glm::aligned_highp> (line 78) | struct is_aligned<glm::aligned_highp>
type storage (line 85) | struct storage
type type (line 87) | struct type {
type storage<L, T, true> (line 94) | struct storage<L, T, true>
type type (line 96) | struct alignas(L * sizeof(T)) type {
type storage<3, T, true> (line 102) | struct storage<3, T, true>
type type (line 104) | struct alignas(4 * sizeof(T)) type {
type storage<4, float, true> (line 112) | struct storage<4, float, true>
type storage<4, int, true> (line 118) | struct storage<4, int, true>
type storage<4, unsigned int, true> (line 124) | struct storage<4, unsigned int, true>
type storage<2, double, true> (line 130) | struct storage<2, double, true>
type storage<2, detail::int64, true> (line 136) | struct storage<2, detail::int64, true>
type storage<2, detail::uint64, true> (line 142) | struct storage<2, detail::uint64, true>
type storage<4, double, true> (line 149) | struct storage<4, double, true>
type storage<4, detail::int64, true> (line 157) | struct storage<4, detail::int64, true>
type storage<4, detail::uint64, true> (line 163) | struct storage<4, detail::uint64, true>
type storage<4, float, true> (line 171) | struct storage<4, float, true>
type storage<4, int, true> (line 177) | struct storage<4, int, true>
type storage<4, unsigned int, true> (line 183) | struct storage<4, unsigned int, true>
type genTypeEnum (line 189) | enum genTypeEnum
type genTypeTrait (line 197) | struct genTypeTrait
type genTypeTrait<mat<C, R, T> > (line 201) | struct genTypeTrait<mat<C, R, T> >
type init_gentype (line 207) | struct init_gentype
type init_gentype<genType, GENTYPE_QUAT> (line 212) | struct init_gentype<genType, GENTYPE_QUAT>
method genType (line 214) | static genType identity()
type init_gentype<genType, GENTYPE_MAT> (line 221) | struct init_gentype<genType, GENTYPE_MAT>
method genType (line 223) | static genType identity()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/setup.hpp
type glm (line 580) | namespace glm {
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 628) | namespace glm
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 644) | namespace glm
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 666) | namespace glm{
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 698) | namespace glm{
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 731) | namespace glm{
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type glm (line 740) | namespace glm{
type std (line 581) | namespace std {
function countof (line 647) | constexpr std::size_t countof(T const (&)[N])
type detail (line 667) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 699) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 732) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
type detail (line 741) | namespace detail
type is_int (line 670) | struct is_int
type test (line 672) | enum test {value = 0}
type is_int<unsigned int> (line 676) | struct is_int<unsigned int>
type test (line 678) | enum test {value = ~0}
type is_int<signed int> (line 682) | struct is_int<signed int>
type test (line 684) | enum test {value = ~0}
type make_unsigned (line 744) | struct make_unsigned
type make_unsigned<char> (line 748) | struct make_unsigned<char>
type make_unsigned<signed char> (line 754) | struct make_unsigned<signed char>
type make_unsigned<short> (line 760) | struct make_unsigned<short>
type make_unsigned<int> (line 766) | struct make_unsigned<int>
type make_unsigned<long> (line 772) | struct make_unsigned<long>
type make_unsigned<int64> (line 778) | struct make_unsigned<int64>
type make_unsigned<unsigned char> (line 784) | struct make_unsigned<unsigned char>
type make_unsigned<unsigned short> (line 790) | struct make_unsigned<unsigned short>
type make_unsigned<unsigned int> (line 796) | struct make_unsigned<unsigned int>
type make_unsigned<unsigned long> (line 802) | struct make_unsigned<unsigned long>
type make_unsigned<uint64> (line 808) | struct make_unsigned<uint64>
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_float.hpp
type glm (line 10) | namespace glm{
type detail (line 11) | namespace detail
function GLM_CONSTEXPR (line 24) | GLM_CONSTEXPR float_t(float_type Num = 0.0f) : f(Num) {}
function GLM_CONSTEXPR (line 26) | GLM_CONSTEXPR float_t& operator=(float_t const& x)
function GLM_CONSTEXPR (line 33) | GLM_CONSTEXPR bool negative() const { return i < 0; }
function GLM_CONSTEXPR (line 34) | GLM_CONSTEXPR int_type mantissa() const { return i & ((1 << 23) - 1); }
function GLM_CONSTEXPR (line 35) | GLM_CONSTEXPR int_type exponent() const { return (i >> 23) & ((1 << ...
function GLM_CONSTEXPR (line 47) | GLM_CONSTEXPR float_t(float_type Num = static_cast<float_type>(0)) :...
function GLM_CONSTEXPR (line 49) | GLM_CONSTEXPR float_t& operator=(float_t const& x)
function GLM_CONSTEXPR (line 56) | GLM_CONSTEXPR bool negative() const { return i < 0; }
function GLM_CONSTEXPR (line 57) | GLM_CONSTEXPR int_type mantissa() const { return i & ((int_type(1) <...
function GLM_CONSTEXPR (line 58) | GLM_CONSTEXPR int_type exponent() const { return (i >> 52) & ((int_t...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_half.hpp
type glm (line 5) | namespace glm{
type detail (line 6) | namespace detail
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat2x2.hpp
type glm (line 10) | namespace glm
type mat<2, 2, T, Q> (line 13) | struct mat<2, 2, T, Q>
method length_type (line 28) | length_type length() { return 2; }
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat2x3.hpp
type glm (line 11) | namespace glm
type mat<2, 3, T, Q> (line 14) | struct mat<2, 3, T, Q>
method length_type (line 29) | length_type length() { return 2; }
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat2x4.hpp
type glm (line 11) | namespace glm
type mat<2, 4, T, Q> (line 14) | struct mat<2, 4, T, Q>
method length_type (line 29) | length_type length() { return 2; }
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat3x2.hpp
type glm (line 11) | namespace glm
type mat<3, 2, T, Q> (line 14) | struct mat<3, 2, T, Q>
method length_type (line 29) | length_type length() { return 3; }
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat3x3.hpp
type glm (line 10) | namespace glm
type mat<3, 3, T, Q> (line 13) | struct mat<3, 3, T, Q>
method length_type (line 28) | length_type length() { return 3; }
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat3x4.hpp
type glm (line 11) | namespace glm
type mat<3, 4, T, Q> (line 14) | struct mat<3, 4, T, Q>
method length_type (line 29) | length_type length() { return 3; }
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat4x2.hpp
type glm (line 11) | namespace glm
type mat<4, 2, T, Q> (line 14) | struct mat<4, 2, T, Q>
method length_type (line 29) | length_type length() { return 4; }
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat4x3.hpp
type glm (line 11) | namespace glm
type mat<4, 3, T, Q> (line 14) | struct mat<4, 3, T, Q>
method length_type (line 29) | length_type length() { return 4; }
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_mat4x4.hpp
type glm (line 10) | namespace glm
type mat<4, 4, T, Q> (line 13) | struct mat<4, 4, T, Q>
method length_type (line 28) | length_type length(){return 4;}
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_quat.hpp
type glm (line 16) | namespace glm
type qua (line 19) | struct qua
method length_type (line 76) | length_type length(){return 4;}
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_vec1.hpp
type glm (line 14) | namespace glm
type vec<1, T, Q> (line 17) | struct vec<1, T, Q>
method length_type (line 88) | length_type length(){return 1;}
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_vec2.hpp
type glm (line 14) | namespace glm
type vec<2, T, Q> (line 17) | struct vec<2, T, Q>
method length_type (line 90) | length_type length(){return 2;}
method GLM_FUNC_DECL (line 138) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1,-1,...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_vec3.hpp
type glm (line 14) | namespace glm
type vec<3, T, Q> (line 17) | struct vec<3, T, Q>
method length_type (line 94) | length_type length(){return 3;}
method GLM_FUNC_DECL (line 159) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2...
method GLM_FUNC_DECL (line 165) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1...
method GLM_FUNC_DECL (line 171) | GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& scalar, detail::_swizzle<2,...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/detail/type_vec4.hpp
type glm (line 14) | namespace glm
type vec<4, T, Q> (line 17) | struct vec<4, T, Q>
method length_type (line 93) | length_type length(){return 4;}
method GLM_FUNC_DECL (line 208) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<4, T, Q, E0, E1, E2...
method GLM_FUNC_DECL (line 214) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1...
method GLM_FUNC_DECL (line 220) | GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, T const& y, detail::_swi...
method GLM_FUNC_DECL (line 226) | GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<2, T, Q...
method GLM_FUNC_DECL (line 232) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1...
method GLM_FUNC_DECL (line 238) | GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2...
method GLM_FUNC_DECL (line 244) | GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<3, T, Q...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/exponential.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/_matrix_vectorize.hpp
type glm (line 3) | namespace glm {
type detail (line 5) | namespace detail {
type matrix_functor_1 (line 8) | struct matrix_functor_1 {
type matrix_functor_1<mat, 2, 2, Ret, T, Q> (line 12) | struct matrix_functor_1<mat, 2, 2, Ret, T, Q> {
method call (line 13) | static mat<2, 2, T, Q> call(Ret (*Func)(T x), mat<2, 2, T, Q> cons...
type matrix_functor_1<mat, 2, 3, Ret, T, Q> (line 22) | struct matrix_functor_1<mat, 2, 3, Ret, T, Q> {
method call (line 24) | static mat<2, 3, T, Q> call(Ret (*Func)(T x), mat<2, 3, T, Q> cons...
type matrix_functor_1<mat, 2, 4, Ret, T, Q> (line 34) | struct matrix_functor_1<mat, 2, 4, Ret, T, Q> {
method call (line 36) | static mat<2, 4, T, Q> call(Ret (*Func)(T x), mat<2, 4, T, Q> cons...
type matrix_functor_1<mat, 3, 2, Ret, T, Q> (line 46) | struct matrix_functor_1<mat, 3, 2, Ret, T, Q> {
method call (line 48) | static mat<3, 2, T, Q> call(Ret (*Func)(T x), mat<3, 2, T, Q> cons...
type matrix_functor_1<mat, 3, 3, Ret, T, Q> (line 59) | struct matrix_functor_1<mat, 3, 3, Ret, T, Q> {
method call (line 61) | static mat<3, 3, T, Q> call(Ret (*Func)(T x), mat<3, 3, T, Q> cons...
type matrix_functor_1<mat, 3, 4, Ret, T, Q> (line 72) | struct matrix_functor_1<mat, 3, 4, Ret, T, Q> {
method call (line 74) | static mat<3, 4, T, Q> call(Ret (*Func)(T x), mat<3, 4, T, Q> cons...
type matrix_functor_1<mat, 4, 2, Ret, T, Q> (line 85) | struct matrix_functor_1<mat, 4, 2, Ret, T, Q> {
method call (line 87) | static mat<4, 2, T, Q> call(Ret (*Func)(T x), mat<4, 2, T, Q> cons...
type matrix_functor_1<mat, 4, 3, Ret, T, Q> (line 99) | struct matrix_functor_1<mat, 4, 3, Ret, T, Q> {
method call (line 101) | static mat<4, 3, T, Q> call(Ret (*Func)(T x), mat<4, 3, T, Q> cons...
type matrix_functor_1<mat, 4, 4, Ret, T, Q> (line 113) | struct matrix_functor_1<mat, 4, 4, Ret, T, Q> {
method call (line 115) | static mat<4, 4, T, Q> call(Ret (*Func)(T x), mat<4, 4, T, Q> cons...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_clip_space.hpp
type glm (line 31) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_common.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double2x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double2x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double2x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double2x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double2x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double2x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double3x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double3x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double3x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double3x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double3x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double3x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double4x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double4x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double4x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double4x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double4x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_double4x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float2x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float2x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float2x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float2x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float2x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float2x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float3x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float3x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float3x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float3x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float3x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float3x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float4x2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float4x2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float4x3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float4x3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float4x4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_float4x4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int2x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int2x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int2x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int2x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int2x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int2x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int3x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int3x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int3x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int3x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int3x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int3x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int4x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int4x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int4x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int4x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int4x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_int4x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_integer.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_projection.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_relational.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_transform.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint2x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint2x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint2x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint2x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint2x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint2x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint3x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint3x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint3x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint3x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint3x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint3x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint4x2.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint4x2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint4x3.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint4x3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint4x4.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/matrix_uint4x4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_common.hpp
type glm (line 35) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_double.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_double_precision.hpp
type glm (line 20) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_exponential.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_float.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_float_precision.hpp
type glm (line 20) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_geometric.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_relational.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_transform.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/quaternion_trigonometric.hpp
type glm (line 31) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_common.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_constants.hpp
type glm (line 20) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_int_sized.hpp
type glm (line 21) | namespace glm{
type detail (line 22) | namespace detail
type is_int<int8> (line 35) | struct is_int<int8>
type test (line 37) | enum test {value = ~0}
type is_int<int16> (line 41) | struct is_int<int16>
type test (line 43) | enum test {value = ~0}
type is_int<int64> (line 47) | struct is_int<int64>
type test (line 49) | enum test {value = ~0}
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_integer.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_packing.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_reciprocal.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_relational.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_uint_sized.hpp
type glm (line 21) | namespace glm{
type detail (line 22) | namespace detail
type is_int<uint8> (line 35) | struct is_int<uint8>
type test (line 37) | enum test {value = ~0}
type is_int<uint16> (line 41) | struct is_int<uint16>
type test (line 43) | enum test {value = ~0}
type is_int<uint64> (line 47) | struct is_int<uint64>
type test (line 49) | enum test {value = ~0}
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/scalar_ulp.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_bool1.hpp
type glm (line 21) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_bool1_precision.hpp
type glm (line 19) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_bool2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_bool2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_bool3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_bool3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_bool4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_bool4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_common.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_double1.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_double1_precision.hpp
type glm (line 21) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_double2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_double2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_double3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_double3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_double4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_double4_precision.hpp
type glm (line 8) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_float1.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_float1_precision.hpp
type glm (line 21) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_float2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_float2_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_float3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_float3_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_float4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_float4_precision.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_int1.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_int1_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_int2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_int2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_int3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_int3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_int4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_int4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_integer.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_packing.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_reciprocal.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_relational.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_uint1.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_uint1_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_uint2.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_uint2_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_uint3.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_uint3_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_uint4.hpp
type glm (line 7) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_uint4_sized.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/ext/vector_ulp.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/fwd.hpp
type glm (line 5) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/geometric.hpp
type glm (line 17) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/bitfield.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/color_space.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/constants.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/epsilon.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/integer.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/matrix_access.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/matrix_integer.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/matrix_inverse.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/noise.hpp
type glm (line 34) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/packing.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/quaternion.hpp
type glm (line 38) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/random.hpp
type glm (line 25) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/round.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/type_aligned.hpp
type glm (line 37) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/type_precision.hpp
type glm (line 46) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/type_ptr.hpp
type glm (line 57) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtc/ulp.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/associated_min_max.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/bit.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/closest_point.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/color_encoding.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/color_space.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/color_space_YCoCg.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/common.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/compatibility.hpp
type glm (line 36) | namespace glm
function GLM_FUNC_QUALIFIER (line 41) | GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}
function GLM_FUNC_QUALIFIER (line 42) | GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 44) | GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 45) | GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 46) | GLM_FUNC_QUALIFIER vec<2, T, Q> lerp(const vec<2, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 47) | GLM_FUNC_QUALIFIER vec<3, T, Q> lerp(const vec<3, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 48) | GLM_FUNC_QUALIFIER vec<4, T, Q> lerp(const vec<4, T, Q>& x, const vec<...
function GLM_FUNC_QUALIFIER (line 50) | GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}
function GLM_FUNC_QUALIFIER (line 51) | GLM_FUNC_QUALIFIER vec<2, T, Q> saturate(const vec<2, T, Q>& x){return...
function GLM_FUNC_QUALIFIER (line 52) | GLM_FUNC_QUALIFIER vec<3, T, Q> saturate(const vec<3, T, Q>& x){return...
function GLM_FUNC_QUALIFIER (line 53) | GLM_FUNC_QUALIFIER vec<4, T, Q> saturate(const vec<4, T, Q>& x){return...
function GLM_FUNC_QUALIFIER (line 55) | GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}
function GLM_FUNC_QUALIFIER (line 56) | GLM_FUNC_QUALIFIER vec<2, T, Q> atan2(const vec<2, T, Q>& x, const vec...
function GLM_FUNC_QUALIFIER (line 57) | GLM_FUNC_QUALIFIER vec<3, T, Q> atan2(const vec<3, T, Q>& x, const vec...
function GLM_FUNC_QUALIFIER (line 58) | GLM_FUNC_QUALIFIER vec<4, T, Q> atan2(const vec<4, T, Q>& x, const vec...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/component_wise.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/dual_quaternion.hpp
type glm (line 31) | namespace glm
type tdualquat (line 37) | struct tdualquat
method length_type (line 52) | length_type length(){return 2;}
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/easing.hpp
type glm (line 32) | namespace glm{
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/euler_angles.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/extend.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/extended_min_max.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/exterior_product.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/fast_exponential.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/fast_square_root.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/fast_trigonometry.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/functions.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/gradient_paint.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/handed_coordinate_space.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/hash.hpp
type std (line 49) | namespace std
type hash<glm::vec<1, T,Q> > (line 52) | struct hash<glm::vec<1, T,Q> >
type hash<glm::vec<2, T,Q> > (line 58) | struct hash<glm::vec<2, T,Q> >
type hash<glm::vec<3, T,Q> > (line 64) | struct hash<glm::vec<3, T,Q> >
type hash<glm::vec<4, T,Q> > (line 70) | struct hash<glm::vec<4, T,Q> >
type hash<glm::qua<T,Q>> (line 76) | struct hash<glm::qua<T,Q>>
type hash<glm::tdualquat<T,Q> > (line 82) | struct hash<glm::tdualquat<T,Q> >
type hash<glm::mat<2, 2, T,Q> > (line 88) | struct hash<glm::mat<2, 2, T,Q> >
type hash<glm::mat<2, 3, T,Q> > (line 94) | struct hash<glm::mat<2, 3, T,Q> >
type hash<glm::mat<2, 4, T,Q> > (line 100) | struct hash<glm::mat<2, 4, T,Q> >
type hash<glm::mat<3, 2, T,Q> > (line 106) | struct hash<glm::mat<3, 2, T,Q> >
type hash<glm::mat<3, 3, T,Q> > (line 112) | struct hash<glm::mat<3, 3, T,Q> >
type hash<glm::mat<3, 4, T,Q> > (line 118) | struct hash<glm::mat<3, 4, T,Q> >
type hash<glm::mat<4, 2, T,Q> > (line 124) | struct hash<glm::mat<4, 2, T,Q> >
type hash<glm::mat<4, 3, T,Q> > (line 130) | struct hash<glm::mat<4, 3, T,Q> >
type hash<glm::mat<4, 4, T,Q> > (line 136) | struct hash<glm::mat<4, 4, T,Q> >
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/integer.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/intersect.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/io.hpp
type glm (line 38) | namespace glm
type io (line 43) | namespace io
type order_type (line 45) | enum order_type { column_major, row_major}
class format_punct (line 48) | class format_punct : public std::locale::facet
class basic_state_saver (line 71) | class basic_state_saver {
class basic_format_saver (line 100) | class basic_format_saver
type precision (line 117) | struct precision
type width (line 124) | struct width
type delimeter (line 132) | struct delimeter
type order (line 139) | struct order
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/log_base.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/matrix_cross_product.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/matrix_decompose.hpp
type glm (line 31) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/matrix_factorisation.hpp
type glm (line 32) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/matrix_interpolation.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/matrix_major_storage.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/matrix_operation.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/matrix_query.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/matrix_transform_2d.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/mixed_product.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/norm.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/normal.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/normalize_dot.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/number_precision.hpp
type glm (line 29) | namespace glm{
type gtx (line 30) | namespace gtx
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/optimum_pow.hpp
type glm (line 26) | namespace glm{
type gtx (line 27) | namespace gtx
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/orthonormalize.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/pca.hpp
type glm (line 54) | namespace glm {
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/perpendicular.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/polar_coordinates.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/projection.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/quaternion.hpp
type glm (line 31) | namespace glm
function GLM_FUNC_QUALIFIER (line 113) | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> toMat3(
function GLM_FUNC_QUALIFIER (line 120) | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> toMat4(
function GLM_FUNC_QUALIFIER (line 127) | GLM_FUNC_QUALIFIER qua<T, Q> toQuat(
function GLM_FUNC_QUALIFIER (line 134) | GLM_FUNC_QUALIFIER qua<T, Q> toQuat(
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/range.hpp
type glm (line 29) | namespace glm
function length_t (line 40) | inline length_t components(vec<1, T, Q> const& v)
function length_t (line 46) | inline length_t components(vec<2, T, Q> const& v)
function length_t (line 52) | inline length_t components(vec<3, T, Q> const& v)
function length_t (line 58) | inline length_t components(vec<4, T, Q> const& v)
function length_t (line 64) | inline length_t components(genType const& m)
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/raw_data.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/rotate_normalized_axis.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/rotate_vector.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/scalar_multiplication.hpp
type glm (line 36) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/scalar_relational.hpp
type glm (line 26) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/spline.hpp
type glm (line 27) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/std_based_type.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/string_cast.hpp
type glm (line 33) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/texture.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/transform.hpp
type glm (line 30) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/transform2.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/type_trait.hpp
type glm (line 28) | namespace glm
type type (line 34) | struct type
type type<vec<L, T, Q> > (line 45) | struct type<vec<L, T, Q> >
type type<mat<C, R, T, Q> > (line 54) | struct type<mat<C, R, T, Q> >
type type<qua<T, Q> > (line 65) | struct type<qua<T, Q> >
type type<tdualquat<T, Q> > (line 74) | struct type<tdualquat<T, Q> >
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/vec_swizzle.hpp
type glm (line 25) | namespace glm {
function GLM_INLINE (line 31) | GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<1, T, Q> &v) {
function GLM_INLINE (line 36) | GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 41) | GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 46) | GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 52) | GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 57) | GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 62) | GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 68) | GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 73) | GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 79) | GLM_INLINE glm::vec<2, T, Q> xw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 85) | GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 90) | GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 95) | GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 101) | GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 106) | GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 111) | GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 117) | GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 122) | GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 128) | GLM_INLINE glm::vec<2, T, Q> yw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 134) | GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 139) | GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 145) | GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 150) | GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 156) | GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 161) | GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 167) | GLM_INLINE glm::vec<2, T, Q> zw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 173) | GLM_INLINE glm::vec<2, T, Q> wx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 179) | GLM_INLINE glm::vec<2, T, Q> wy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 185) | GLM_INLINE glm::vec<2, T, Q> wz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 191) | GLM_INLINE glm::vec<2, T, Q> ww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 197) | GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<1, T, Q> &v) {
function GLM_INLINE (line 202) | GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 207) | GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 212) | GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 218) | GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 223) | GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 228) | GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 234) | GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 239) | GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 245) | GLM_INLINE glm::vec<3, T, Q> xxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 251) | GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 256) | GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 261) | GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 267) | GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 272) | GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 277) | GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 283) | GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 288) | GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 294) | GLM_INLINE glm::vec<3, T, Q> xyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 300) | GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 305) | GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 311) | GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 316) | GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 322) | GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 327) | GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 333) | GLM_INLINE glm::vec<3, T, Q> xzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 339) | GLM_INLINE glm::vec<3, T, Q> xwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 345) | GLM_INLINE glm::vec<3, T, Q> xwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 351) | GLM_INLINE glm::vec<3, T, Q> xwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 357) | GLM_INLINE glm::vec<3, T, Q> xww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 363) | GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 368) | GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 373) | GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 379) | GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 384) | GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 389) | GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 395) | GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 400) | GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 406) | GLM_INLINE glm::vec<3, T, Q> yxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 412) | GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 417) | GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 422) | GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 428) | GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 433) | GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 438) | GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 444) | GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 449) | GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 455) | GLM_INLINE glm::vec<3, T, Q> yyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 461) | GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 466) | GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 472) | GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 477) | GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 483) | GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 488) | GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 494) | GLM_INLINE glm::vec<3, T, Q> yzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 500) | GLM_INLINE glm::vec<3, T, Q> ywx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 506) | GLM_INLINE glm::vec<3, T, Q> ywy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 512) | GLM_INLINE glm::vec<3, T, Q> ywz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 518) | GLM_INLINE glm::vec<3, T, Q> yww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 524) | GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 529) | GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 535) | GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 540) | GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 546) | GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 551) | GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 557) | GLM_INLINE glm::vec<3, T, Q> zxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 563) | GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 568) | GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 574) | GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 579) | GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 585) | GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 590) | GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 596) | GLM_INLINE glm::vec<3, T, Q> zyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 602) | GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 607) | GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 613) | GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 618) | GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 624) | GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 629) | GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 635) | GLM_INLINE glm::vec<3, T, Q> zzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 641) | GLM_INLINE glm::vec<3, T, Q> zwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 647) | GLM_INLINE glm::vec<3, T, Q> zwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 653) | GLM_INLINE glm::vec<3, T, Q> zwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 659) | GLM_INLINE glm::vec<3, T, Q> zww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 665) | GLM_INLINE glm::vec<3, T, Q> wxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 671) | GLM_INLINE glm::vec<3, T, Q> wxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 677) | GLM_INLINE glm::vec<3, T, Q> wxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 683) | GLM_INLINE glm::vec<3, T, Q> wxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 689) | GLM_INLINE glm::vec<3, T, Q> wyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 695) | GLM_INLINE glm::vec<3, T, Q> wyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 701) | GLM_INLINE glm::vec<3, T, Q> wyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 707) | GLM_INLINE glm::vec<3, T, Q> wyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 713) | GLM_INLINE glm::vec<3, T, Q> wzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 719) | GLM_INLINE glm::vec<3, T, Q> wzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 725) | GLM_INLINE glm::vec<3, T, Q> wzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 731) | GLM_INLINE glm::vec<3, T, Q> wzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 737) | GLM_INLINE glm::vec<3, T, Q> wwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 743) | GLM_INLINE glm::vec<3, T, Q> wwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 749) | GLM_INLINE glm::vec<3, T, Q> wwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 755) | GLM_INLINE glm::vec<3, T, Q> www(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 761) | GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<1, T, Q> &v) {
function GLM_INLINE (line 766) | GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 771) | GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 776) | GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 782) | GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 787) | GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 792) | GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 798) | GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 803) | GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 809) | GLM_INLINE glm::vec<4, T, Q> xxxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 815) | GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 820) | GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 825) | GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 831) | GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 836) | GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 841) | GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 847) | GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 852) | GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 858) | GLM_INLINE glm::vec<4, T, Q> xxyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 864) | GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 869) | GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 875) | GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 880) | GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 886) | GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 891) | GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 897) | GLM_INLINE glm::vec<4, T, Q> xxzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 903) | GLM_INLINE glm::vec<4, T, Q> xxwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 909) | GLM_INLINE glm::vec<4, T, Q> xxwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 915) | GLM_INLINE glm::vec<4, T, Q> xxwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 921) | GLM_INLINE glm::vec<4, T, Q> xxww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 927) | GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 932) | GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 937) | GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 943) | GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 948) | GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 953) | GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 959) | GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 964) | GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 970) | GLM_INLINE glm::vec<4, T, Q> xyxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 976) | GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 981) | GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 986) | GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 992) | GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 997) | GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1002) | GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1008) | GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1013) | GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1019) | GLM_INLINE glm::vec<4, T, Q> xyyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1025) | GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1030) | GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1036) | GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1041) | GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1047) | GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1052) | GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1058) | GLM_INLINE glm::vec<4, T, Q> xyzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1064) | GLM_INLINE glm::vec<4, T, Q> xywx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1070) | GLM_INLINE glm::vec<4, T, Q> xywy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1076) | GLM_INLINE glm::vec<4, T, Q> xywz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1082) | GLM_INLINE glm::vec<4, T, Q> xyww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1088) | GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1093) | GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1099) | GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1104) | GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1110) | GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1115) | GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1121) | GLM_INLINE glm::vec<4, T, Q> xzxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1127) | GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1132) | GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1138) | GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1143) | GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1149) | GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1154) | GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1160) | GLM_INLINE glm::vec<4, T, Q> xzyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1166) | GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1171) | GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1177) | GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1182) | GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1188) | GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1193) | GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1199) | GLM_INLINE glm::vec<4, T, Q> xzzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1205) | GLM_INLINE glm::vec<4, T, Q> xzwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1211) | GLM_INLINE glm::vec<4, T, Q> xzwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1217) | GLM_INLINE glm::vec<4, T, Q> xzwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1223) | GLM_INLINE glm::vec<4, T, Q> xzww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1229) | GLM_INLINE glm::vec<4, T, Q> xwxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1235) | GLM_INLINE glm::vec<4, T, Q> xwxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1241) | GLM_INLINE glm::vec<4, T, Q> xwxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1247) | GLM_INLINE glm::vec<4, T, Q> xwxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1253) | GLM_INLINE glm::vec<4, T, Q> xwyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1259) | GLM_INLINE glm::vec<4, T, Q> xwyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1265) | GLM_INLINE glm::vec<4, T, Q> xwyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1271) | GLM_INLINE glm::vec<4, T, Q> xwyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1277) | GLM_INLINE glm::vec<4, T, Q> xwzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1283) | GLM_INLINE glm::vec<4, T, Q> xwzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1289) | GLM_INLINE glm::vec<4, T, Q> xwzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1295) | GLM_INLINE glm::vec<4, T, Q> xwzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1301) | GLM_INLINE glm::vec<4, T, Q> xwwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1307) | GLM_INLINE glm::vec<4, T, Q> xwwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1313) | GLM_INLINE glm::vec<4, T, Q> xwwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1319) | GLM_INLINE glm::vec<4, T, Q> xwww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1325) | GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1330) | GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1335) | GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1341) | GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1346) | GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1351) | GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1357) | GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1362) | GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1368) | GLM_INLINE glm::vec<4, T, Q> yxxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1374) | GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1379) | GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1384) | GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1390) | GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1395) | GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1400) | GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1406) | GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1411) | GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1417) | GLM_INLINE glm::vec<4, T, Q> yxyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1423) | GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1428) | GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1434) | GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1439) | GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1445) | GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1450) | GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1456) | GLM_INLINE glm::vec<4, T, Q> yxzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1462) | GLM_INLINE glm::vec<4, T, Q> yxwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1468) | GLM_INLINE glm::vec<4, T, Q> yxwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1474) | GLM_INLINE glm::vec<4, T, Q> yxwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1480) | GLM_INLINE glm::vec<4, T, Q> yxww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1486) | GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1491) | GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1496) | GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1502) | GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1507) | GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1512) | GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1518) | GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1523) | GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1529) | GLM_INLINE glm::vec<4, T, Q> yyxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1535) | GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1540) | GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1545) | GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1551) | GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<2, T, Q> &v) {
function GLM_INLINE (line 1556) | GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1561) | GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1567) | GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1572) | GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1578) | GLM_INLINE glm::vec<4, T, Q> yyyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1584) | GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1589) | GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1595) | GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1600) | GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1606) | GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1611) | GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1617) | GLM_INLINE glm::vec<4, T, Q> yyzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1623) | GLM_INLINE glm::vec<4, T, Q> yywx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1629) | GLM_INLINE glm::vec<4, T, Q> yywy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1635) | GLM_INLINE glm::vec<4, T, Q> yywz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1641) | GLM_INLINE glm::vec<4, T, Q> yyww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1647) | GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1652) | GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1658) | GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1663) | GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1669) | GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1674) | GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1680) | GLM_INLINE glm::vec<4, T, Q> yzxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1686) | GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1691) | GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1697) | GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1702) | GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1708) | GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1713) | GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1719) | GLM_INLINE glm::vec<4, T, Q> yzyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1725) | GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1730) | GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1736) | GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1741) | GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1747) | GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1752) | GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1758) | GLM_INLINE glm::vec<4, T, Q> yzzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1764) | GLM_INLINE glm::vec<4, T, Q> yzwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1770) | GLM_INLINE glm::vec<4, T, Q> yzwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1776) | GLM_INLINE glm::vec<4, T, Q> yzwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1782) | GLM_INLINE glm::vec<4, T, Q> yzww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1788) | GLM_INLINE glm::vec<4, T, Q> ywxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1794) | GLM_INLINE glm::vec<4, T, Q> ywxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1800) | GLM_INLINE glm::vec<4, T, Q> ywxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1806) | GLM_INLINE glm::vec<4, T, Q> ywxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1812) | GLM_INLINE glm::vec<4, T, Q> ywyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1818) | GLM_INLINE glm::vec<4, T, Q> ywyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1824) | GLM_INLINE glm::vec<4, T, Q> ywyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1830) | GLM_INLINE glm::vec<4, T, Q> ywyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1836) | GLM_INLINE glm::vec<4, T, Q> ywzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1842) | GLM_INLINE glm::vec<4, T, Q> ywzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1848) | GLM_INLINE glm::vec<4, T, Q> ywzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1854) | GLM_INLINE glm::vec<4, T, Q> ywzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1860) | GLM_INLINE glm::vec<4, T, Q> ywwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1866) | GLM_INLINE glm::vec<4, T, Q> ywwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1872) | GLM_INLINE glm::vec<4, T, Q> ywwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1878) | GLM_INLINE glm::vec<4, T, Q> ywww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1884) | GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1889) | GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1895) | GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1900) | GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1906) | GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1911) | GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1917) | GLM_INLINE glm::vec<4, T, Q> zxxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1923) | GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1928) | GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1934) | GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1939) | GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1945) | GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1950) | GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1956) | GLM_INLINE glm::vec<4, T, Q> zxyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1962) | GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1967) | GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1973) | GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1978) | GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1984) | GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 1989) | GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 1995) | GLM_INLINE glm::vec<4, T, Q> zxzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2001) | GLM_INLINE glm::vec<4, T, Q> zxwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2007) | GLM_INLINE glm::vec<4, T, Q> zxwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2013) | GLM_INLINE glm::vec<4, T, Q> zxwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2019) | GLM_INLINE glm::vec<4, T, Q> zxww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2025) | GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2030) | GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2036) | GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2041) | GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2047) | GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2052) | GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2058) | GLM_INLINE glm::vec<4, T, Q> zyxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2064) | GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2069) | GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2075) | GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2080) | GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2086) | GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2091) | GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2097) | GLM_INLINE glm::vec<4, T, Q> zyyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2103) | GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2108) | GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2114) | GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2119) | GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2125) | GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2130) | GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2136) | GLM_INLINE glm::vec<4, T, Q> zyzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2142) | GLM_INLINE glm::vec<4, T, Q> zywx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2148) | GLM_INLINE glm::vec<4, T, Q> zywy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2154) | GLM_INLINE glm::vec<4, T, Q> zywz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2160) | GLM_INLINE glm::vec<4, T, Q> zyww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2166) | GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2171) | GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2177) | GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2182) | GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2188) | GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2193) | GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2199) | GLM_INLINE glm::vec<4, T, Q> zzxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2205) | GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2210) | GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2216) | GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2221) | GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2227) | GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2232) | GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2238) | GLM_INLINE glm::vec<4, T, Q> zzyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2244) | GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2249) | GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2255) | GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2260) | GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2266) | GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<3, T, Q> &v) {
function GLM_INLINE (line 2271) | GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2277) | GLM_INLINE glm::vec<4, T, Q> zzzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2283) | GLM_INLINE glm::vec<4, T, Q> zzwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2289) | GLM_INLINE glm::vec<4, T, Q> zzwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2295) | GLM_INLINE glm::vec<4, T, Q> zzwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2301) | GLM_INLINE glm::vec<4, T, Q> zzww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2307) | GLM_INLINE glm::vec<4, T, Q> zwxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2313) | GLM_INLINE glm::vec<4, T, Q> zwxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2319) | GLM_INLINE glm::vec<4, T, Q> zwxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2325) | GLM_INLINE glm::vec<4, T, Q> zwxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2331) | GLM_INLINE glm::vec<4, T, Q> zwyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2337) | GLM_INLINE glm::vec<4, T, Q> zwyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2343) | GLM_INLINE glm::vec<4, T, Q> zwyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2349) | GLM_INLINE glm::vec<4, T, Q> zwyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2355) | GLM_INLINE glm::vec<4, T, Q> zwzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2361) | GLM_INLINE glm::vec<4, T, Q> zwzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2367) | GLM_INLINE glm::vec<4, T, Q> zwzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2373) | GLM_INLINE glm::vec<4, T, Q> zwzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2379) | GLM_INLINE glm::vec<4, T, Q> zwwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2385) | GLM_INLINE glm::vec<4, T, Q> zwwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2391) | GLM_INLINE glm::vec<4, T, Q> zwwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2397) | GLM_INLINE glm::vec<4, T, Q> zwww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2403) | GLM_INLINE glm::vec<4, T, Q> wxxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2409) | GLM_INLINE glm::vec<4, T, Q> wxxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2415) | GLM_INLINE glm::vec<4, T, Q> wxxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2421) | GLM_INLINE glm::vec<4, T, Q> wxxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2427) | GLM_INLINE glm::vec<4, T, Q> wxyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2433) | GLM_INLINE glm::vec<4, T, Q> wxyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2439) | GLM_INLINE glm::vec<4, T, Q> wxyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2445) | GLM_INLINE glm::vec<4, T, Q> wxyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2451) | GLM_INLINE glm::vec<4, T, Q> wxzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2457) | GLM_INLINE glm::vec<4, T, Q> wxzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2463) | GLM_INLINE glm::vec<4, T, Q> wxzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2469) | GLM_INLINE glm::vec<4, T, Q> wxzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2475) | GLM_INLINE glm::vec<4, T, Q> wxwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2481) | GLM_INLINE glm::vec<4, T, Q> wxwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2487) | GLM_INLINE glm::vec<4, T, Q> wxwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2493) | GLM_INLINE glm::vec<4, T, Q> wxww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2499) | GLM_INLINE glm::vec<4, T, Q> wyxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2505) | GLM_INLINE glm::vec<4, T, Q> wyxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2511) | GLM_INLINE glm::vec<4, T, Q> wyxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2517) | GLM_INLINE glm::vec<4, T, Q> wyxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2523) | GLM_INLINE glm::vec<4, T, Q> wyyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2529) | GLM_INLINE glm::vec<4, T, Q> wyyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2535) | GLM_INLINE glm::vec<4, T, Q> wyyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2541) | GLM_INLINE glm::vec<4, T, Q> wyyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2547) | GLM_INLINE glm::vec<4, T, Q> wyzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2553) | GLM_INLINE glm::vec<4, T, Q> wyzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2559) | GLM_INLINE glm::vec<4, T, Q> wyzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2565) | GLM_INLINE glm::vec<4, T, Q> wyzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2571) | GLM_INLINE glm::vec<4, T, Q> wywx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2577) | GLM_INLINE glm::vec<4, T, Q> wywy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2583) | GLM_INLINE glm::vec<4, T, Q> wywz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2589) | GLM_INLINE glm::vec<4, T, Q> wyww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2595) | GLM_INLINE glm::vec<4, T, Q> wzxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2601) | GLM_INLINE glm::vec<4, T, Q> wzxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2607) | GLM_INLINE glm::vec<4, T, Q> wzxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2613) | GLM_INLINE glm::vec<4, T, Q> wzxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2619) | GLM_INLINE glm::vec<4, T, Q> wzyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2625) | GLM_INLINE glm::vec<4, T, Q> wzyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2631) | GLM_INLINE glm::vec<4, T, Q> wzyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2637) | GLM_INLINE glm::vec<4, T, Q> wzyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2643) | GLM_INLINE glm::vec<4, T, Q> wzzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2649) | GLM_INLINE glm::vec<4, T, Q> wzzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2655) | GLM_INLINE glm::vec<4, T, Q> wzzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2661) | GLM_INLINE glm::vec<4, T, Q> wzzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2667) | GLM_INLINE glm::vec<4, T, Q> wzwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2673) | GLM_INLINE glm::vec<4, T, Q> wzwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2679) | GLM_INLINE glm::vec<4, T, Q> wzwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2685) | GLM_INLINE glm::vec<4, T, Q> wzww(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2691) | GLM_INLINE glm::vec<4, T, Q> wwxx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2697) | GLM_INLINE glm::vec<4, T, Q> wwxy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2703) | GLM_INLINE glm::vec<4, T, Q> wwxz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2709) | GLM_INLINE glm::vec<4, T, Q> wwxw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2715) | GLM_INLINE glm::vec<4, T, Q> wwyx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2721) | GLM_INLINE glm::vec<4, T, Q> wwyy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2727) | GLM_INLINE glm::vec<4, T, Q> wwyz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2733) | GLM_INLINE glm::vec<4, T, Q> wwyw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2739) | GLM_INLINE glm::vec<4, T, Q> wwzx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2745) | GLM_INLINE glm::vec<4, T, Q> wwzy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2751) | GLM_INLINE glm::vec<4, T, Q> wwzz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2757) | GLM_INLINE glm::vec<4, T, Q> wwzw(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2763) | GLM_INLINE glm::vec<4, T, Q> wwwx(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2769) | GLM_INLINE glm::vec<4, T, Q> wwwy(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2775) | GLM_INLINE glm::vec<4, T, Q> wwwz(const glm::vec<4, T, Q> &v) {
function GLM_INLINE (line 2781) | GLM_INLINE glm::vec<4, T, Q> wwww(const glm::vec<4, T, Q> &v) {
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/vector_angle.hpp
type glm (line 31) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/vector_query.hpp
type glm (line 28) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/gtx/wrap.hpp
type glm (line 29) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/integer.hpp
type glm (line 23) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/matrix.hpp
type glm (line 31) | namespace glm {
type detail (line 32) | namespace detail
type outerProduct_trait (line 35) | struct outerProduct_trait{}
type outerProduct_trait<2, 2, T, Q> (line 38) | struct outerProduct_trait<2, 2, T, Q>
type outerProduct_trait<2, 3, T, Q> (line 44) | struct outerProduct_trait<2, 3, T, Q>
type outerProduct_trait<2, 4, T, Q> (line 50) | struct outerProduct_trait<2, 4, T, Q>
type outerProduct_trait<3, 2, T, Q> (line 56) | struct outerProduct_trait<3, 2, T, Q>
type outerProduct_trait<3, 3, T, Q> (line 62) | struct outerProduct_trait<3, 3, T, Q>
type outerProduct_trait<3, 4, T, Q> (line 68) | struct outerProduct_trait<3, 4, T, Q>
type outerProduct_trait<4, 2, T, Q> (line 74) | struct outerProduct_trait<4, 2, T, Q>
type outerProduct_trait<4, 3, T, Q> (line 80) | struct outerProduct_trait<4, 3, T, Q>
type outerProduct_trait<4, 4, T, Q> (line 86) | struct outerProduct_trait<4, 4, T, Q>
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/packing.hpp
type glm (line 22) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/simd/common.h
function GLM_FUNC_QUALIFIER (line 10) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_add(glm_f32vec4 a, glm_f32vec4 b)
function GLM_FUNC_QUALIFIER (line 15) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_add(glm_f32vec4 a, glm_f32vec4 b)
function GLM_FUNC_QUALIFIER (line 20) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sub(glm_f32vec4 a, glm_f32vec4 b)
function GLM_FUNC_QUALIFIER (line 25) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sub(glm_f32vec4 a, glm_f32vec4 b)
function GLM_FUNC_QUALIFIER (line 30) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_mul(glm_f32vec4 a, glm_f32vec4 b)
function GLM_FUNC_QUALIFIER (line 35) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_mul(glm_f32vec4 a, glm_f32vec4 b)
function GLM_FUNC_QUALIFIER (line 40) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_div(glm_f32vec4 a, glm_f32vec4 b)
function GLM_FUNC_QUALIFIER (line 45) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_div(glm_f32vec4 a, glm_f32vec4 b)
function GLM_FUNC_QUALIFIER (line 50) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_div_lowp(glm_f32vec4 a, glm_f32v...
function GLM_FUNC_QUALIFIER (line 55) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_swizzle_xyzw(glm_f32vec4 a)
function GLM_FUNC_QUALIFIER (line 64) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_fma(glm_f32vec4 a, glm_f32vec4 b...
function GLM_FUNC_QUALIFIER (line 73) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_fma(glm_f32vec4 a, glm_f32vec4 b...
function GLM_FUNC_QUALIFIER (line 82) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_abs(glm_f32vec4 x)
function GLM_FUNC_QUALIFIER (line 87) | GLM_FUNC_QUALIFIER glm_ivec4 glm_ivec4_abs(glm_ivec4 x)
function GLM_FUNC_QUALIFIER (line 99) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sign(glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 110) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_round(glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 124) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_floor(glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 145) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_roundEven(glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 155) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_ceil(glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 168) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_fract(glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 175) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mod(glm_vec4 x, glm_vec4 y)
function GLM_FUNC_QUALIFIER (line 184) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_clamp(glm_vec4 v, glm_vec4 minVal, ...
function GLM_FUNC_QUALIFIER (line 191) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mix(glm_vec4 v1, glm_vec4 v2, glm_v...
function GLM_FUNC_QUALIFIER (line 199) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_step(glm_vec4 edge, glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 205) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_smoothstep(glm_vec4 edge0, glm_vec4...
function GLM_FUNC_QUALIFIER (line 219) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_nan(glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 233) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_inf(glm_vec4 x)
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/simd/exponential.h
function GLM_FUNC_QUALIFIER (line 10) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sqrt_lowp(glm_f32vec4 x)
function GLM_FUNC_QUALIFIER (line 15) | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sqrt_lowp(glm_f32vec4 x)
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/simd/geometric.h
function GLM_FUNC_QUALIFIER (line 13) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_length(glm_vec4 x)
function GLM_FUNC_QUALIFIER (line 20) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_distance(glm_vec4 p0, glm_vec4 p1)
function GLM_FUNC_QUALIFIER (line 27) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2)
function GLM_FUNC_QUALIFIER (line 46) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2)
function GLM_FUNC_QUALIFIER (line 65) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_cross(glm_vec4 v1, glm_vec4 v2)
function GLM_FUNC_QUALIFIER (line 77) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_normalize(glm_vec4 v)
function GLM_FUNC_QUALIFIER (line 85) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_faceforward(glm_vec4 N, glm_vec4 I,...
function GLM_FUNC_QUALIFIER (line 94) | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_reflect(glm_vec4 I, glm_vec4 N)
function GLM_FUNC_QUALIFIER (line 103) | GLM_FUNC_QUALIFIER __m128 glm_vec4_refract(glm_vec4 I, glm_vec4 N, glm_v...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/simd/integer.h
function GLM_FUNC_QUALIFIER (line 8) | GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave(glm_uvec4 x)
function GLM_FUNC_QUALIFIER (line 62) | GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave2(glm_uvec4 x, glm_uvec4 y)
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/simd/matrix.h
function GLM_FUNC_QUALIFIER (line 10) | GLM_FUNC_QUALIFIER void glm_mat4_matrixCompMult(glm_vec4 const in1[4], g...
function GLM_FUNC_QUALIFIER (line 18) | GLM_FUNC_QUALIFIER void glm_mat4_add(glm_vec4 const in1[4], glm_vec4 con...
function GLM_FUNC_QUALIFIER (line 26) | GLM_FUNC_QUALIFIER void glm_mat4_sub(glm_vec4 const in1[4], glm_vec4 con...
function GLM_FUNC_QUALIFIER (line 34) | GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_mul_vec4(glm_vec4 const m[4], glm_v...
function GLM_FUNC_QUALIFIER (line 53) | GLM_FUNC_QUALIFIER __m128 glm_vec4_mul_mat4(glm_vec4 v, glm_vec4 const m...
function GLM_FUNC_QUALIFIER (line 80) | GLM_FUNC_QUALIFIER void glm_mat4_mul(glm_vec4 const in1[4], glm_vec4 con...
function GLM_FUNC_QUALIFIER (line 156) | GLM_FUNC_QUALIFIER void glm_mat4_transpose(glm_vec4 const in[4], glm_vec...
function GLM_FUNC_QUALIFIER (line 169) | GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_highp(glm_vec4 const in...
function GLM_FUNC_QUALIFIER (line 383) | GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_lowp(glm_vec4 const m[4])
function GLM_FUNC_QUALIFIER (line 446) | GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant(glm_vec4 const m[4])
function GLM_FUNC_QUALIFIER (line 509) | GLM_FUNC_QUALIFIER void glm_mat4_inverse(glm_vec4 const in[4], glm_vec4 ...
function GLM_FUNC_QUALIFIER (line 730) | GLM_FUNC_QUALIFIER void glm_mat4_inverse_lowp(glm_vec4 const in[4], glm_...
function GLM_FUNC_QUALIFIER (line 1020) | GLM_FUNC_QUALIFIER void glm_mat4_outerProduct(__m128 const& c, __m128 co...
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/simd/neon.h
function namespace (line 9) | namespace glm {
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/simd/platform.h
type __m128 (line 382) | typedef __m128 glm_f32vec4;
type __m128i (line 383) | typedef __m128i glm_i32vec4;
type __m128i (line 384) | typedef __m128i glm_u32vec4;
type __m128d (line 385) | typedef __m128d glm_f64vec2;
type __m128i (line 386) | typedef __m128i glm_i64vec2;
type __m128i (line 387) | typedef __m128i glm_u64vec2;
type glm_f32vec4 (line 389) | typedef glm_f32vec4 glm_vec4;
type glm_i32vec4 (line 390) | typedef glm_i32vec4 glm_ivec4;
type glm_u32vec4 (line 391) | typedef glm_u32vec4 glm_uvec4;
type glm_f64vec2 (line 392) | typedef glm_f64vec2 glm_dvec2;
type __m256d (line 396) | typedef __m256d glm_f64vec4;
type glm_f64vec4 (line 397) | typedef glm_f64vec4 glm_dvec4;
type __m256i (line 401) | typedef __m256i glm_i64vec4;
type __m256i (line 402) | typedef __m256i glm_u64vec4;
type float32x4_t (line 406) | typedef float32x4_t glm_f32vec4;
type int32x4_t (line 407) | typedef int32x4_t glm_i32vec4;
type uint32x4_t (line 408) | typedef uint32x4_t glm_u32vec4;
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/trigonometric.hpp
type glm (line 24) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/glm/vector_relational.hpp
type glm (line 25) | namespace glm
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/bug/bug_ms_vec_static.cpp
type vec2 (line 4) | struct vec2
type _swizzle (line 6) | struct _swizzle
type vec2 (line 11) | struct vec2
function main (line 28) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/cmake/test_find_glm.cpp
function camera (line 5) | glm::mat4 camera(float Translate, glm::vec2 const& Rotate)
function main (line 15) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_cpp_constexpr.cpp
function test_vec1 (line 14) | static int test_vec1()
function test_vec2 (line 171) | static int test_vec2()
function test_vec3 (line 344) | static int test_vec3()
function test_vec4 (line 537) | static int test_vec4()
function test_quat (line 708) | static int test_quat()
function test_mat2x2 (line 724) | static int test_mat2x2()
function main (line 735) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_cpp_defaulted_ctor.cpp
function test_vec_memcpy (line 12) | static int test_vec_memcpy()
function test_mat_memcpy (line 47) | static int test_mat_memcpy()
function test_quat_memcpy (line 117) | static int test_quat_memcpy()
function main (line 133) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_aligned_gentypes.cpp
function main (line 4) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_arch_unknown.cpp
function main (line 8) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_compiler_unknown.cpp
function main (line 8) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_ctor_init.cpp
function test_vec (line 6) | static int test_vec()
function test_mat (line 37) | static int test_mat()
function test_qua (line 116) | static int test_qua()
function main (line 129) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_cxx03.cpp
function main (line 8) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_cxx98.cpp
function main (line 8) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_cxx_unknown.cpp
function main (line 8) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_depth_zero_to_one.cpp
function main (line 6) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_explicit_ctor.cpp
function main (line 6) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_inline.cpp
function main (line 6) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_left_handed.cpp
function main (line 6) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_platform_unknown.cpp
function main (line 8) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_pure.cpp
function test_vec4_ctor (line 14) | static int test_vec4_ctor()
function test_bvec4_ctor (line 140) | static int test_bvec4_ctor()
function test_vec4_operators (line 164) | static int test_vec4_operators()
function test_vec4_equal (line 300) | static int test_vec4_equal()
function test_vec4_size (line 321) | static int test_vec4_size()
function test_vec4_swizzle_partial (line 339) | static int test_vec4_swizzle_partial()
function test_operator_increment (line 377) | static int test_operator_increment()
function test_vec4_simd (line 404) | static int test_vec4_simd()
function main (line 419) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_quat_xyzw.cpp
function main (line 7) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_size_t_length.cpp
function main (line 6) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_unrestricted_gentype.cpp
function main (line 6) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_force_xyzw_only.cpp
function test_comp (line 10) | static int test_comp()
function test_constexpr (line 43) | static int test_constexpr()
function main (line 50) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_func_common.cpp
type floor_ (line 22) | namespace floor_
function test (line 24) | static int test()
type modf_ (line 100) | namespace modf_
function test (line 102) | static int test()
type mod_ (line 146) | namespace mod_
function test (line 148) | static int test()
type floatBitsToInt (line 196) | namespace floatBitsToInt
function test (line 198) | static int test()
type floatBitsToUint (line 234) | namespace floatBitsToUint
function test (line 236) | static int test()
type min_ (line 272) | namespace min_
function test (line 274) | static int test()
function min_tern (line 300) | int min_tern(int a, int b)
function min_int (line 305) | int min_int(int x, int y)
function perf (line 310) | static int perf(std::size_t Count)
type max_ (line 357) | namespace max_
function test (line 359) | static int test()
type clamp_ (line 387) | namespace clamp_
function test (line 389) | static int test()
type mix_ (line 397) | namespace mix_
type entry (line 400) | struct entry
function test (line 475) | static int test()
type step_ (line 567) | namespace step_
type entry (line 570) | struct entry
function test (line 592) | static int test()
type round_ (line 632) | namespace round_
function test (line 634) | static int test()
type roundEven (line 676) | namespace roundEven
function test (line 678) | static int test()
type isnan_ (line 822) | namespace isnan_
function test (line 824) | static int test()
type isinf_ (line 849) | namespace isinf_
function test (line 851) | static int test()
type sign (line 884) | namespace sign
function GLM_FUNC_QUALIFIER (line 887) | GLM_FUNC_QUALIFIER genFIType sign_if(genFIType x)
function GLM_FUNC_QUALIFIER (line 904) | GLM_FUNC_QUALIFIER genFIType sign_alu1(genFIType x)
function GLM_FUNC_QUALIFIER (line 913) | GLM_FUNC_QUALIFIER int sign_alu2(int x)
function GLM_FUNC_QUALIFIER (line 930) | GLM_FUNC_QUALIFIER genFIType sign_sub(genFIType x)
function GLM_FUNC_QUALIFIER (line 940) | GLM_FUNC_QUALIFIER genFIType sign_cmp(genFIType x)
type type (line 950) | struct type
function test_int32 (line 956) | int test_int32()
function test_i32vec4 (line 1006) | int test_i32vec4()
function test_f32vec4 (line 1030) | int test_f32vec4()
function test (line 1054) | static int test()
function perf_rand (line 1065) | int perf_rand(std::size_t Samples)
function perf_linear (line 1118) | int perf_linear(std::size_t Samples)
function perf_linear_cal (line 1165) | int perf_linear_cal(std::size_t Samples)
function perf (line 1210) | static int perf(std::size_t Samples)
type frexp_ (line 1222) | namespace frexp_
function test (line 1224) | static int test()
type ldexp_ (line 1264) | namespace ldexp_
function test (line 1266) | static int test()
function test_constexpr (line 1302) | static int test_constexpr()
function main (line 1315) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_func_exponential.cpp
function test_pow (line 11) | static int test_pow()
function test_sqrt (line 33) | static int test_sqrt()
function test_exp (line 55) | static int test_exp()
function test_log (line 77) | static int test_log()
function test_exp2 (line 99) | static int test_exp2()
function test_log2 (line 127) | static int test_log2()
function test_inversesqrt (line 149) | static int test_inversesqrt()
function main (line 171) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_func_geometric.cpp
type length (line 14) | namespace length
function test (line 16) | int test()
type distance (line 34) | namespace distance
function test (line 36) | int test()
type dot (line 54) | namespace dot
function test (line 56) | int test()
type cross (line 74) | namespace cross
function test (line 76) | int test()
type normalize (line 90) | namespace normalize
function test (line 92) | int test()
type faceforward (line 113) | namespace faceforward
function test (line 115) | int test()
type reflect (line 130) | namespace reflect
function test (line 132) | int test()
type refract (line 154) | namespace refract
function test (line 156) | int test()
function main (line 185) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_func_integer.cpp
type result (line 17) | enum result
type bitfieldInsert (line 25) | namespace bitfieldInsert
type type (line 28) | struct type
function test (line 49) | static int test()
type bitfieldExtract (line 69) | namespace bitfieldExtract
type type (line 72) | struct type
function test (line 107) | static int test()
type bitfieldReverse (line 134) | namespace bitfieldReverse
function GLM_FUNC_QUALIFIER (line 164) | GLM_FUNC_QUALIFIER glm::vec<L, T, Q> bitfieldReverseLoop(glm::vec<L, T...
function GLM_FUNC_QUALIFIER (line 180) | GLM_FUNC_QUALIFIER T bitfieldReverseLoop(T v)
function GLM_FUNC_QUALIFIER (line 185) | GLM_FUNC_QUALIFIER glm::uint32 bitfieldReverseUint32(glm::uint32 x)
function GLM_FUNC_QUALIFIER (line 195) | GLM_FUNC_QUALIFIER glm::uint64 bitfieldReverseUint64(glm::uint64 x)
type compute_bitfieldReverseStep (line 207) | struct compute_bitfieldReverseStep
method GLM_FUNC_QUALIFIER (line 210) | GLM_FUNC_QUALIFIER static glm::vec<L, T, Q> call(glm::vec<L, T, Q> c...
type compute_bitfieldReverseStep<true> (line 217) | struct compute_bitfieldReverseStep<true>
method GLM_FUNC_QUALIFIER (line 220) | GLM_FUNC_QUALIFIER static glm::vec<L, T, Q> call(glm::vec<L, T, Q> c...
function GLM_FUNC_QUALIFIER (line 227) | GLM_FUNC_QUALIFIER glm::vec<L, T, Q> bitfieldReverseOps(glm::vec<L, T,...
function GLM_FUNC_QUALIFIER (line 240) | GLM_FUNC_QUALIFIER genType bitfieldReverseOps(genType x)
type type (line 246) | struct type
function test32_bitfieldReverse (line 277) | static int test32_bitfieldReverse()
function test32_bitfieldReverseLoop (line 297) | static int test32_bitfieldReverseLoop()
function test32_bitfieldReverseUint32 (line 317) | static int test32_bitfieldReverseUint32()
function test32_bitfieldReverseOps (line 337) | static int test32_bitfieldReverseOps()
function test64_bitfieldReverse (line 357) | static int test64_bitfieldReverse()
function test64_bitfieldReverseLoop (line 377) | static int test64_bitfieldReverseLoop()
function test64_bitfieldReverseUint64 (line 397) | static int test64_bitfieldReverseUint64()
function test64_bitfieldReverseOps (line 417) | static int test64_bitfieldReverseOps()
function test (line 437) | static int test()
function perf32 (line 454) | static int perf32(glm::uint32 Count)
function perf64 (line 491) | static int perf64(glm::uint64 Count)
function perf (line 528) | static int perf(std::size_t Samples)
type findMSB (line 539) | namespace findMSB
type type (line 542) | struct type
function findMSB_intrinsic (line 550) | static int findMSB_intrinsic(genIUType Value)
function findMSB_avx (line 565) | static int findMSB_avx(genIUType Value)
function findMSB_095 (line 577) | static int findMSB_095(genIUType Value)
function findMSB_nlz1 (line 601) | static int findMSB_nlz1(genIUType x)
function findMSB_nlz2 (line 617) | static int findMSB_nlz2(unsigned int x)
function findMSB_pop (line 630) | static int findMSB_pop(unsigned int x)
function perf_int (line 640) | static int perf_int(std::size_t Count)
function test_ivec4 (line 769) | static int test_ivec4()
function test_int (line 821) | static int test_int()
function test (line 907) | static int test()
function perf (line 917) | static int perf(std::size_t Samples)
type findLSB (line 927) | namespace findLSB
type type (line 930) | struct type
function findLSB_intrinsic (line 953) | static int findLSB_intrinsic(genIUType Value)
function findLSB_095 (line 967) | static int findLSB_095(genIUType Value)
function findLSB_ntz2 (line 979) | static int findLSB_ntz2(genIUType x)
function findLSB_branchfree (line 988) | static int findLSB_branchfree(genIUType x)
function test_int (line 997) | static int test_int()
function test (line 1036) | static int test()
function perf_int (line 1045) | static int perf_int(std::size_t Count)
function perf (line 1111) | static int perf(std::size_t Samples)
type uaddCarry (line 1121) | namespace uaddCarry
function test (line 1123) | static int test()
type usubBorrow (line 1171) | namespace usubBorrow
function test (line 1173) | static int test()
type umulExtended (line 1231) | namespace umulExtended
function test (line 1233) | static int test()
type imulExtended (line 1296) | namespace imulExtended
function test (line 1298) | static int test()
type bitCount (line 1361) | namespace bitCount
type type (line 1364) | struct type
function bitCount_if (line 1380) | inline int bitCount_if(T v)
function bitCount_vec (line 1394) | inline int bitCount_vec(T v)
type compute_bitfieldBitCountStep (line 1407) | struct compute_bitfieldBitCountStep
method GLM_FUNC_QUALIFIER (line 1410) | GLM_FUNC_QUALIFIER static glm::vec<L, T, Q> call(glm::vec<L, T, Q> c...
type compute_bitfieldBitCountStep<true> (line 1417) | struct compute_bitfieldBitCountStep<true>
method GLM_FUNC_QUALIFIER (line 1420) | GLM_FUNC_QUALIFIER static glm::vec<L, T, Q> call(glm::vec<L, T, Q> c...
function bitCount_bitfield (line 1427) | static glm::vec<L, int, Q> bitCount_bitfield(glm::vec<L, T, Q> const& v)
function bitCount_bitfield (line 1440) | static int bitCount_bitfield(genType x)
function perf (line 1445) | static int perf(std::size_t Size)
function test (line 1506) | static int test()
function main (line 1529) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_func_integer_bit_count.cpp
function rotatel (line 8) | unsigned rotatel(unsigned x, int n)
function pop0 (line 14) | int pop0(unsigned x)
function pop1 (line 24) | int pop1(unsigned x)
function pop2 (line 37) | int pop2(unsigned x)
function pop3 (line 54) | int pop3(unsigned x)
function pop4 (line 69) | int pop4(unsigned x)
function pop5 (line 81) | int pop5(unsigned x)
function pop5a (line 95) | int pop5a(unsigned x)
function pop6 (line 109) | int pop6(unsigned x)
function pop7 (line 139) | int pop7(unsigned x)
function pop8 (line 150) | int pop8(unsigned x)
function pop9 (line 160) | int pop9(unsigned x)
function error (line 171) | void error(int x, int y)
function main (line 177) | int main()
FILE: submodules/diff-gaussian-rasterization-abs/third_party/glm/test/core/core_func_integer_find_lsb.cpp
function nlz (line 6) | int nlz(unsigned x)
function pop (line 18) | int pop(unsigned x)
function ntz1 (line 28) | int ntz1(unsigned x)
function ntz2 (line 33) | int ntz2(unsigned x)
function ntz3 (line 38) | int ntz3(unsigned x)
function ntz4 (line 51) | i
Copy disabled (too large)
Download .json
Condensed preview — 1513 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (18,422K chars).
[
{
"path": ".gitignore",
"chars": 47,
"preview": "# 默认忽略的文件\n.idea\n/shelf/\n/workspace.xml\n/output\n"
},
{
"path": ".gitmodules",
"chars": 229,
"preview": "[submodule \"submodules/simple-knn\"]\n\tpath = submodules/simple-knn\n\turl = https://gitlab.inria.fr/bkerbl/simple-knn.git\n["
},
{
"path": "LICENSE.md",
"chars": 4276,
"preview": "Gaussian-Splatting License \n=========================== \n\n**Inria** and **the Max Planck Institut for Informatik (MPII"
},
{
"path": "README.md",
"chars": 5597,
"preview": "\n- <p align=\"center\">\n <h1 align=\"center\">AbsGS: Recovering Fine Details for 3D Gaussian Splatting</h1>\n <p align=\"c"
},
{
"path": "arguments/__init__.py",
"chars": 4142,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "convert.py",
"chars": 5349,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "environment.yml",
"chars": 302,
"preview": "name: Absgs\nchannels:\n - pytorch\n - conda-forge\n - defaults\ndependencies:\n - cudatoolkit=11.6\n - plyfile\n - python"
},
{
"path": "full_eval.py",
"chars": 3589,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "gaussian_renderer/__init__.py",
"chars": 3883,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "gaussian_renderer/network_gui.py",
"chars": 2716,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "lpipsPyTorch/__init__.py",
"chars": 635,
"preview": "import torch\n\nfrom .modules.lpips import LPIPS\n\n\ndef lpips(x: torch.Tensor,\n y: torch.Tensor,\n net_typ"
},
{
"path": "lpipsPyTorch/modules/lpips.py",
"chars": 1151,
"preview": "import torch\nimport torch.nn as nn\n\nfrom .networks import get_network, LinLayers\nfrom .utils import get_state_dict\n\n\ncla"
},
{
"path": "lpipsPyTorch/modules/networks.py",
"chars": 2692,
"preview": "from typing import Sequence\n\nfrom itertools import chain\n\nimport torch\nimport torch.nn as nn\nfrom torchvision import mod"
},
{
"path": "lpipsPyTorch/modules/utils.py",
"chars": 885,
"preview": "from collections import OrderedDict\n\nimport torch\n\n\ndef normalize_activation(x, eps=1e-10):\n norm_factor = torch.sqrt"
},
{
"path": "metrics.py",
"chars": 4143,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "render.py",
"chars": 2823,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "scene/__init__.py",
"chars": 4050,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "scene/cameras.py",
"chars": 2572,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "scene/colmap_loader.py",
"chars": 15509,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "scene/dataset_readers.py",
"chars": 10302,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "scene/gaussian_model.py",
"chars": 22930,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/.gitignore",
"chars": 74,
"preview": "build/\ndiff_gaussian_rasterization_abs.egg-info/\ndist/\ncmake-build-debug/\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/.gitmodules",
"chars": 95,
"preview": "[submodule \"third_party/glm\"]\n\tpath = third_party/glm\n\turl = https://github.com/g-truc/glm.git\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/CMakeLists.txt",
"chars": 1046,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/LICENSE.md",
"chars": 4275,
"preview": "Gaussian-Splatting License \n=========================== \n\n**Inria** and **the Max Planck Institut for Informatik (MPII"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/README.md",
"chars": 1313,
"preview": "# Differential Gaussian Rasterization\n\nUsed as the rasterization engine for the paper \"AbsGS: Recovering Fine Details fo"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/auxiliary.h",
"chars": 5499,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/backward.cu",
"chars": 24230,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/backward.h",
"chars": 1501,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/config.h",
"chars": 468,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/forward.cu",
"chars": 13969,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/forward.h",
"chars": 1597,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/rasterizer.h",
"chars": 2063,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/rasterizer_impl.cu",
"chars": 12393,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/cuda_rasterizer/rasterizer_impl.h",
"chars": 1596,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/diff_gaussian_rasterization_abs/__init__.py",
"chars": 7346,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/ext.cpp",
"chars": 571,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/rasterize_points.cu",
"chars": 7001,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/rasterize_points.h",
"chars": 1984,
"preview": "/*\n * Copyright (C) 2023, Inria\n * GRAPHDECO research group, https://team.inria.fr/graphdeco\n * All rights reserved.\n *\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/setup.py",
"chars": 1048,
"preview": "#\n# Copyright (C) 2023, Inria\n# GRAPHDECO research group, https://team.inria.fr/graphdeco\n# All rights reserved.\n#\n# Thi"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/.appveyor.yml",
"chars": 3257,
"preview": "shallow_clone: true\n\nplatform:\n - x86\n - x64\n\nconfiguration:\n - Debug\n - Release\n\nimage:\n - Visual Studio 2013\n - "
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/.gitignore",
"chars": 604,
"preview": "# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled Dynamic libraries\n*.so\n*.dyl"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/.travis.yml",
"chars": 13878,
"preview": "language: cpp\n\nbranches:\n only:\n - master\n - stable\n\njobs:\n include:\n - name: \"Xcode 7.3 C++98 pure release\"\n"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/CMakeLists.txt",
"chars": 1809,
"preview": "cmake_minimum_required(VERSION 3.2 FATAL_ERROR)\ncmake_policy(VERSION 3.2)\n\n\nfile(READ \"glm/detail/setup.hpp\" GLM_SETUP_F"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/cmake/cmake_uninstall.cmake.in",
"chars": 852,
"preview": "if(NOT EXISTS \"@CMAKE_BINARY_DIR@/install_manifest.txt\")\n message(FATAL_ERROR \"Cannot find install manifest: @CMAKE_BIN"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/copying.txt",
"chars": 2865,
"preview": "================================================================================\nOpenGL Mathematics (GLM)\n--------------"
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00001_source.html",
"chars": 59169,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00002_source.html",
"chars": 7003,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00003_source.html",
"chars": 17423,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00004_source.html",
"chars": 158134,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00005_source.html",
"chars": 123923,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00006_source.html",
"chars": 31163,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00007.html",
"chars": 26643,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00007_source.html",
"chars": 30822,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00008.html",
"chars": 12465,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00008_source.html",
"chars": 14301,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00009.html",
"chars": 28311,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00009_source.html",
"chars": 27455,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00010.html",
"chars": 7102,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00010_source.html",
"chars": 9819,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00011.html",
"chars": 8836,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00011_source.html",
"chars": 11747,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00012.html",
"chars": 9003,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00012_source.html",
"chars": 10803,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00013.html",
"chars": 10307,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00013_source.html",
"chars": 13071,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00014.html",
"chars": 8714,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00014_source.html",
"chars": 12106,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00015.html",
"chars": 38405,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00015_source.html",
"chars": 42265,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00016.html",
"chars": 8948,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00016_source.html",
"chars": 12060,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00017.html",
"chars": 62097,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00017_source.html",
"chars": 69988,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00018.html",
"chars": 10443,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00018_source.html",
"chars": 13268,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00019_source.html",
"chars": 11695,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00020_source.html",
"chars": 8874,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00021.html",
"chars": 25870,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00021_source.html",
"chars": 27644,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00022.html",
"chars": 20831,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00022_source.html",
"chars": 44282,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00023.html",
"chars": 31038,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00023_source.html",
"chars": 36268,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00024.html",
"chars": 8996,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00024_source.html",
"chars": 10909,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00025.html",
"chars": 40989,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00025_source.html",
"chars": 62273,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00026.html",
"chars": 11161,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00026_source.html",
"chars": 13745,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00027.html",
"chars": 4744,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00027_source.html",
"chars": 65218,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00028.html",
"chars": 6151,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00028_source.html",
"chars": 8797,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00029.html",
"chars": 20183,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00029_source.html",
"chars": 25362,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00030.html",
"chars": 6308,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00030_source.html",
"chars": 8557,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00031.html",
"chars": 15210,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00031_source.html",
"chars": 15505,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00032.html",
"chars": 12761,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00032_source.html",
"chars": 14317,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00033.html",
"chars": 11561,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00033_source.html",
"chars": 14210,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00034.html",
"chars": 7082,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00034_source.html",
"chars": 10006,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00035_source.html",
"chars": 484976,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00036.html",
"chars": 12254,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00036_source.html",
"chars": 14825,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00037.html",
"chars": 4718,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00037_source.html",
"chars": 12862,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00038.html",
"chars": 7266,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00038_source.html",
"chars": 10566,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00039.html",
"chars": 7136,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00039_source.html",
"chars": 10348,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00040.html",
"chars": 5021,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00040_source.html",
"chars": 24701,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00041.html",
"chars": 7895,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00041_source.html",
"chars": 10036,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00042.html",
"chars": 11811,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00042_source.html",
"chars": 13430,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00043.html",
"chars": 16811,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00043_source.html",
"chars": 20751,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00044.html",
"chars": 11449,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00044_source.html",
"chars": 18456,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00045.html",
"chars": 5719,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00045_source.html",
"chars": 34794,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00046.html",
"chars": 6908,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00046_source.html",
"chars": 9666,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00047_source.html",
"chars": 377848,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00048.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00048_source.html",
"chars": 6157,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00049.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00049_source.html",
"chars": 6157,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00050.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00050_source.html",
"chars": 6157,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00051.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00051_source.html",
"chars": 6157,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00052.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00052_source.html",
"chars": 6072,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00053.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00053_source.html",
"chars": 6072,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00054.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00054_source.html",
"chars": 5957,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00055.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00055_source.html",
"chars": 6072,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00056.html",
"chars": 4727,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00056_source.html",
"chars": 6157,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00057.html",
"chars": 9675,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00057_source.html",
"chars": 23070,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00058.html",
"chars": 8572,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00058_source.html",
"chars": 10814,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00059.html",
"chars": 42511,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00059_source.html",
"chars": 50213,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00060.html",
"chars": 4859,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00060_source.html",
"chars": 8524,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00061.html",
"chars": 7006,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00061_source.html",
"chars": 9462,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00062.html",
"chars": 6335,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00062_source.html",
"chars": 11190,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00063.html",
"chars": 6426,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00063_source.html",
"chars": 7367,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00064.html",
"chars": 9472,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00064_source.html",
"chars": 11127,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00065.html",
"chars": 5752,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00065_source.html",
"chars": 6503,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00066.html",
"chars": 7292,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00066_source.html",
"chars": 8399,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00067.html",
"chars": 5752,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00067_source.html",
"chars": 6503,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00068.html",
"chars": 7292,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00068_source.html",
"chars": 8399,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00069.html",
"chars": 5752,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00069_source.html",
"chars": 6503,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00070.html",
"chars": 7292,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00070_source.html",
"chars": 8399,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00071.html",
"chars": 6426,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00071_source.html",
"chars": 7367,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00072.html",
"chars": 9472,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00072_source.html",
"chars": 11127,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00073.html",
"chars": 5752,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00073_source.html",
"chars": 6503,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00074.html",
"chars": 7292,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00074_source.html",
"chars": 8399,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00075.html",
"chars": 5752,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00075_source.html",
"chars": 6503,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00076.html",
"chars": 7292,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00076_source.html",
"chars": 8399,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00077.html",
"chars": 5752,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00077_source.html",
"chars": 6503,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00078.html",
"chars": 7292,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00078_source.html",
"chars": 8399,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00079.html",
"chars": 6426,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00079_source.html",
"chars": 7367,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00080.html",
"chars": 9472,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00080_source.html",
"chars": 11127,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00081.html",
"chars": 8869,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00081_source.html",
"chars": 12383,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00082.html",
"chars": 6419,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
},
{
"path": "submodules/diff-gaussian-rasterization-abs/third_party/glm/doc/api/a00082_source.html",
"chars": 7355,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""
}
]
// ... and 1313 more files (download for full content)
About this extraction
This page contains the full source code of the TY424/AbsGS GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1513 files (16.5 MB), approximately 4.4M tokens, and a symbol index with 2894 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.